---

machine.cc

Go to the documentation of this file.

// machine.cc 
//      Routines for simulating the execution of user programs.
//
//  DO NOT CHANGE -- part of the machine emulation
//
// Copyright (c) 1992-1993 The Regents of the University of California.
// All rights reserved.  See copyright.h for copyright notice and limitation 
// of liability and disclaimer of warranty provisions.

#include "copyright.h"
#include "machine.h"
#include "system.h"

// Textual names of the exceptions that can be generated by user program
// execution, for debugging.
static char* exceptionNames[] = { "no exception", "syscall", 
                                "page fault/no TLB entry", "page read only",
                                "bus error", "address error", "overflow",
                                "illegal instruction" };

//----------------------------------------------------------------------
// CheckEndian
//      Check to be sure that the host really uses the format it says it 
//      does, for storing the bytes of an integer.  Stop on error.
//----------------------------------------------------------------------

static
void CheckEndian()
{
    union checkit {
        char charword[4];
        unsigned int intword;
    } check;

    check.charword[0] = 1;
    check.charword[1] = 2;
    check.charword[2] = 3;
    check.charword[3] = 4;

#ifdef HOST_IS_BIG_ENDIAN
    ASSERT (check.intword == 0x01020304);
#else
    ASSERT (check.intword == 0x04030201);
#endif
}

//----------------------------------------------------------------------
// Machine::Machine
//      Initialize the simulation of user program execution.
//
//      "debug" -- if TRUE, drop into the debugger after each user instruction
//              is executed.
//----------------------------------------------------------------------

Machine::Machine(bool debug)
{
    int i;

    for (i = 0; i < NumTotalRegs; i++)
        registers[i] = 0;
    mainMemory = new char[MemorySize];
    for (i = 0; i < MemorySize; i++)
        mainMemory[i] = 0;
#ifdef USE_TLB
    tlb = new TranslationEntry[TLBSize];
    for (i = 0; i < TLBSize; i++)
        tlb[i].valid = FALSE;
    pageTable = NULL;
#else   // use linear page table
    tlb = NULL;
    pageTable = NULL;
#endif

    singleStep = debug;
    CheckEndian();
}

//----------------------------------------------------------------------
// Machine::~Machine
//      De-allocate the data structures used to simulate user program execution.
//----------------------------------------------------------------------

Machine::~Machine()
{
    delete [] mainMemory;
    if (tlb != NULL)
        delete [] tlb;
}

//----------------------------------------------------------------------
// Machine::RaiseException
//      Transfer control to the Nachos kernel from user mode, because
//      the user program either invoked a system call, or some exception
//      occured (such as the address translation failed).
//
//      "which" -- the cause of the kernel trap
//      "badVaddr" -- the virtual address causing the trap, if appropriate
//----------------------------------------------------------------------

void
Machine::RaiseException(ExceptionType which, int badVAddr)
{
    DEBUG('m', "Exception: %s\n", exceptionNames[which]);
    
//  ASSERT(interrupt->getStatus() == UserMode);
    registers[BadVAddrReg] = badVAddr;
    DelayedLoad(0, 0);                  // finish anything in progress
    interrupt->setStatus(SystemMode);
    ExceptionHandler(which);            // interrupts are enabled at this point
    interrupt->setStatus(UserMode);
}

//----------------------------------------------------------------------
// Machine::Debugger
//      Primitive debugger for user programs.  Note that we can't use
//      gdb to debug user programs, since gdb doesn't run on top of Nachos.
//      It could, but you'd have to implement *a lot* more system calls
//      to get it to work!
//
//      So just allow single-stepping, and printing the contents of memory.
//----------------------------------------------------------------------

void Machine::Debugger()
{
    char *buf = new char[80];
    int num;

    interrupt->DumpState();
    DumpState();
    printf("%d> ", stats->totalTicks);
    fflush(stdout);
    fgets(buf, 80, stdin);
    if (sscanf(buf, "%d", &num) == 1)
        runUntilTime = num;
    else {
        runUntilTime = 0;
        switch (*buf) {
          case '\n':
            break;
            
          case 'c':
            singleStep = FALSE;
            break;
            
          case '?':
            printf("Machine commands:\n");
            printf("    <return>  execute one instruction\n");
            printf("    <number>  run until the given timer tick\n");
            printf("    c         run until completion\n");
            printf("    ?         print help message\n");
            break;
        }
    }
    delete [] buf;
}
 
//----------------------------------------------------------------------
// Machine::DumpState
//      Print the user program's CPU state.  We might print the contents
//      of memory, but that seemed like overkill.
//----------------------------------------------------------------------

void
Machine::DumpState()
{
    int i;
    
    printf("Machine registers:\n");
    for (i = 0; i < NumGPRegs; i++)
        switch (i) {
          case StackReg:
            printf("\tSP(%d):\t0x%x%s", i, registers[i],
                   ((i % 4) == 3) ? "\n" : "");
            break;
            
          case RetAddrReg:
            printf("\tRA(%d):\t0x%x%s", i, registers[i],
                   ((i % 4) == 3) ? "\n" : "");
            break;
          
          default:
            printf("\t%d:\t0x%x%s", i, registers[i],
                   ((i % 4) == 3) ? "\n" : "");
            break;
        }
    
    printf("\tHi:\t0x%x", registers[HiReg]);
    printf("\tLo:\t0x%x\n", registers[LoReg]);
    printf("\tPC:\t0x%x", registers[PCReg]);
    printf("\tNextPC:\t0x%x", registers[NextPCReg]);
    printf("\tPrevPC:\t0x%x\n", registers[PrevPCReg]);
    printf("\tLoad:\t0x%x", registers[LoadReg]);
    printf("\tLoadV:\t0x%x\n", registers[LoadValueReg]);
    printf("\n");
}

//----------------------------------------------------------------------
// Machine::ReadRegister/WriteRegister
//      Fetch or write the contents of a user program register.
//----------------------------------------------------------------------

int Machine::ReadRegister(int num)
    {
        ASSERT((num >= 0) && (num < NumTotalRegs));
        return registers[num];
    }

void Machine::WriteRegister(int num, int value)
    {
        ASSERT((num >= 0) && (num < NumTotalRegs));
        // DEBUG('m', "WriteRegister %d, value %d\n", num, value);
        registers[num] = value;
    }

---

The University of Southern California does not screen or control the content on this website and thus does not guarantee the accuracy, integrity, or quality of such content. All content on this website is provided by and is the sole responsibility of the person from which such content originated, and such content does not necessarily reflect the opinions of the University administration or the Board of Trustees