---

translate.cc

Go to the documentation of this file.

// translate.cc 
//      Routines to translate virtual addresses to physical addresses.
//      Software sets up a table of legal translations.  We look up
//      in the table on every memory reference to find the true physical
//      memory location.
//
// Two types of translation are supported here.
//
//      Linear page table -- the virtual page # is used as an index
//      into the table, to find the physical page #.
//
//      Translation lookaside buffer -- associative lookup in the table
//      to find an entry with the same virtual page #.  If found,
//      this entry is used for the translation.
//      If not, it traps to software with an exception. 
//
//      In practice, the TLB is much smaller than the amount of physical
//      memory (16 entries is common on a machine that has 1000's of
//      pages).  Thus, there must also be a backup translation scheme
//      (such as page tables), but the hardware doesn't need to know
//      anything at all about that.
//
//      Note that the contents of the TLB are specific to an address space.
//      If the address space changes, so does the contents of the TLB!
//
// 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 "addrspace.h"
#include "system.h"

// Routines for converting Words and Short Words to and from the
// simulated machine's format of little endian.  These end up
// being NOPs when the host machine is also little endian (DEC and Intel).

unsigned int
WordToHost(unsigned int word) {
#ifdef HOST_IS_BIG_ENDIAN
         register unsigned long result;
         result = (word >> 24) & 0x000000ff;
         result |= (word >> 8) & 0x0000ff00;
         result |= (word << 8) & 0x00ff0000;
         result |= (word << 24) & 0xff000000;
         return result;
#else 
         return word;
#endif /* HOST_IS_BIG_ENDIAN */
}

unsigned short
ShortToHost(unsigned short shortword) {
#ifdef HOST_IS_BIG_ENDIAN
         register unsigned short result;
         result = (shortword << 8) & 0xff00;
         result |= (shortword >> 8) & 0x00ff;
         return result;
#else 
         return shortword;
#endif /* HOST_IS_BIG_ENDIAN */
}

unsigned int
WordToMachine(unsigned int word) { return WordToHost(word); }

unsigned short
ShortToMachine(unsigned short shortword) { return ShortToHost(shortword); }


//----------------------------------------------------------------------
// Machine::ReadMem
//      Read "size" (1, 2, or 4) bytes of virtual memory at "addr" into 
//      the location pointed to by "value".
//
//      Returns FALSE if the translation step from virtual to physical memory
//      failed.
//
//      "addr" -- the virtual address to read from
//      "size" -- the number of bytes to read (1, 2, or 4)
//      "value" -- the place to write the result
//----------------------------------------------------------------------

bool
Machine::ReadMem(int addr, int size, int *value)
{
    int data;
    ExceptionType exception;
    int physicalAddress;
    
    DEBUG('a', "Reading VA 0x%x, size %d\n", addr, size);
    
    exception = Translate(addr, &physicalAddress, size, FALSE);
    if (exception != NoException) {
        machine->RaiseException(exception, addr);
        return FALSE;
    }
    switch (size) {
      case 1:
        data = machine->mainMemory[physicalAddress];
        *value = data;
        break;
        
      case 2:
        data = *(unsigned short *) &machine->mainMemory[physicalAddress];
        *value = ShortToHost(data);
        break;
        
      case 4:
        data = *(unsigned int *) &machine->mainMemory[physicalAddress];
        *value = WordToHost(data);
        break;

      default: ASSERT(FALSE);
    }
    
    DEBUG('a', "\tvalue read = %8.8x\n", *value);
    return (TRUE);
}

//----------------------------------------------------------------------
// Machine::WriteMem
//      Write "size" (1, 2, or 4) bytes of the contents of "value" into
//      virtual memory at location "addr".
//
//      Returns FALSE if the translation step from virtual to physical memory
//      failed.
//
//      "addr" -- the virtual address to write to
//      "size" -- the number of bytes to be written (1, 2, or 4)
//      "value" -- the data to be written
//----------------------------------------------------------------------

bool
Machine::WriteMem(int addr, int size, int value)
{
    ExceptionType exception;
    int physicalAddress;
     
    DEBUG('a', "Writing VA 0x%x, size %d, value 0x%x\n", addr, size, value);

    exception = Translate(addr, &physicalAddress, size, TRUE);
    if (exception != NoException) {
        machine->RaiseException(exception, addr);
        return FALSE;
    }
    switch (size) {
      case 1:
        machine->mainMemory[physicalAddress] = (unsigned char) (value & 0xff);
        break;

      case 2:
        *(unsigned short *) &machine->mainMemory[physicalAddress]
                = ShortToMachine((unsigned short) (value & 0xffff));
        break;
      
      case 4:
        *(unsigned int *) &machine->mainMemory[physicalAddress]
                = WordToMachine((unsigned int) value);
        break;
        
      default: ASSERT(FALSE);
    }
    
    return TRUE;
}

//----------------------------------------------------------------------
// Machine::Translate
//      Translate a virtual address into a physical address, using 
//      either a page table or a TLB.  Check for alignment and all sorts 
//      of other errors, and if everything is ok, set the use/dirty bits in 
//      the translation table entry, and store the translated physical 
//      address in "physAddr".  If there was an error, returns the type
//      of the exception.
//
//      "virtAddr" -- the virtual address to translate
//      "physAddr" -- the place to store the physical address
//      "size" -- the amount of memory being read or written
//      "writing" -- if TRUE, check the "read-only" bit in the TLB
//----------------------------------------------------------------------

ExceptionType
Machine::Translate(int virtAddr, int* physAddr, int size, bool writing)
{
    int i;
    unsigned int vpn, offset;
    TranslationEntry *entry;
    unsigned int pageFrame;

    DEBUG('a', "\tTranslate 0x%x, %s: ", virtAddr, writing ? "write" : "read");

// check for alignment errors
    if (((size == 4) && (virtAddr & 0x3)) || ((size == 2) && (virtAddr & 0x1))){
        DEBUG('a', "alignment problem at %d, size %d!\n", virtAddr, size);
        return AddressErrorException;
    }
    
    // we must have either a TLB or a page table, but not both!
    ASSERT(tlb == NULL || pageTable == NULL);   
    ASSERT(tlb != NULL || pageTable != NULL);   

// calculate the virtual page number, and offset within the page,
// from the virtual address
    vpn = (unsigned) virtAddr / PageSize;
    offset = (unsigned) virtAddr % PageSize;
    
    if (tlb == NULL) {          // => page table => vpn is index into table
        if (vpn >= pageTableSize) {
            DEBUG('a', "virtual page # %d too large for page table size %d!\n", 
                        virtAddr, pageTableSize);
            return AddressErrorException;
        } else if (!pageTable[vpn].valid) {
            DEBUG('a', "virtual page # %d too large for page table size %d!\n", 
                        virtAddr, pageTableSize);
            return PageFaultException;
        }
        entry = &pageTable[vpn];
    } else {
        for (entry = NULL, i = 0; i < TLBSize; i++)
            if (tlb[i].valid && ((unsigned) tlb[i].virtualPage == vpn)) {
                entry = &tlb[i];                        // FOUND!
                break;
            }
        if (entry == NULL) {                            // not found
            DEBUG('a', "*** no valid TLB entry found for this virtual page!\n");
            return PageFaultException;          // really, this is a TLB fault,
                                                // the page may be in memory,
                                                // but not in the TLB
        }
    }

    if (entry->readOnly && writing) {   // trying to write to a read-only page
        DEBUG('a', "%d mapped read-only at %d in TLB!\n", virtAddr, i);
        return ReadOnlyException;
    }
    pageFrame = entry->physicalPage;

    // if the pageFrame is too big, there is something really wrong! 
    // An invalid translation was loaded into the page table or TLB. 
    if (pageFrame >= NumPhysPages) { 
        DEBUG('a', "*** frame %d > %d!\n", pageFrame, NumPhysPages);
        return BusErrorException;
    }
    entry->use = TRUE;          // set the use, dirty bits
    if (writing)
        entry->dirty = TRUE;
    *physAddr = pageFrame * PageSize + offset;
    ASSERT((*physAddr >= 0) && ((*physAddr + size) <= MemorySize));
    DEBUG('a', "phys addr = 0x%x\n", *physAddr);
    return NoException;
}

---

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