tlb: Don't separate the TLB classes into an instruction TLB and a data TLB

src/arch/alpha/AlphaTLB.py

@@ -33,15 +33,5 @@ from BaseTLB import BaseTLB
 
 class AlphaTLB(BaseTLB):
     type = 'AlphaTLB'
-    abstract = True
+    cxx_class = 'AlphaISA::TLB'
-    size = Param.Int("TLB size")
+    size = Param.Int(64, "TLB size")
-
-class AlphaDTB(AlphaTLB):
-    type = 'AlphaDTB'
-    cxx_class = 'AlphaISA::DTB'
-    size = 64
-
-class AlphaITB(AlphaTLB):
-    type = 'AlphaITB'
-    cxx_class = 'AlphaISA::ITB'
-    size = 48

src/arch/alpha/tlb.cc

@@ -72,6 +72,90 @@ TLB::~TLB()
         delete [] table;
 }
 
+void
+TLB::regStats()
+{
+    fetch_hits
+        .name(name() + ".fetch_hits")
+        .desc("ITB hits");
+    fetch_misses
+        .name(name() + ".fetch_misses")
+        .desc("ITB misses");
+    fetch_acv
+        .name(name() + ".fetch_acv")
+        .desc("ITB acv");
+    fetch_accesses
+        .name(name() + ".fetch_accesses")
+        .desc("ITB accesses");
+
+    fetch_accesses = fetch_hits + fetch_misses;
+
+    read_hits
+        .name(name() + ".read_hits")
+        .desc("DTB read hits")
+        ;
+
+    read_misses
+        .name(name() + ".read_misses")
+        .desc("DTB read misses")
+        ;
+
+    read_acv
+        .name(name() + ".read_acv")
+        .desc("DTB read access violations")
+        ;
+
+    read_accesses
+        .name(name() + ".read_accesses")
+        .desc("DTB read accesses")
+        ;
+
+    write_hits
+        .name(name() + ".write_hits")
+        .desc("DTB write hits")
+        ;
+
+    write_misses
+        .name(name() + ".write_misses")
+        .desc("DTB write misses")
+        ;
+
+    write_acv
+        .name(name() + ".write_acv")
+        .desc("DTB write access violations")
+        ;
+
+    write_accesses
+        .name(name() + ".write_accesses")
+        .desc("DTB write accesses")
+        ;
+
+    data_hits
+        .name(name() + ".data_hits")
+        .desc("DTB hits")
+        ;
+
+    data_misses
+        .name(name() + ".data_misses")
+        .desc("DTB misses")
+        ;
+
+    data_acv
+        .name(name() + ".data_acv")
+        .desc("DTB access violations")
+        ;
+
+    data_accesses
+        .name(name() + ".data_accesses")
+        .desc("DTB accesses")
+        ;
+
+    data_hits = read_hits + write_hits;
+    data_misses = read_misses + write_misses;
+    data_acv = read_acv + write_acv;
+    data_accesses = read_accesses + write_accesses;
+}
+
 // look up an entry in the TLB
 TlbEntry *
 TLB::lookup(Addr vpn, uint8_t asn)
@@ -288,36 +372,8 @@ TLB::unserialize(Checkpoint *cp, const string &section)
     }
 }
 
-///////////////////////////////////////////////////////////////////////
-//
-//  Alpha ITB
-//
-ITB::ITB(const Params *p)
-    : TLB(p)
-{}
-
-
-void
-ITB::regStats()
-{
-    hits
-        .name(name() + ".hits")
-        .desc("ITB hits");
-    misses
-        .name(name() + ".misses")
-        .desc("ITB misses");
-    acv
-        .name(name() + ".acv")
-        .desc("ITB acv");
-    accesses
-        .name(name() + ".accesses")
-        .desc("ITB accesses");
-
-    accesses = hits + misses;
-}
-
 Fault
-ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
+TLB::translateInst(RequestPtr req, ThreadContext *tc)
 {
     //If this is a pal pc, then set PHYSICAL
     if (FULL_SYSTEM && PcPAL(req->getPC()))
@@ -326,7 +382,7 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
     if (PcPAL(req->getPC())) {
         // strip off PAL PC marker (lsb is 1)
         req->setPaddr((req->getVaddr() & ~3) & PAddrImplMask);
-        hits++;
+        fetch_hits++;
         return NoFault;
     }
 
@@ -335,7 +391,7 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
     } else {
         // verify that this is a good virtual address
         if (!validVirtualAddress(req->getVaddr())) {
-            acv++;
+            fetch_acv++;
             return new ItbAcvFault(req->getVaddr());
         }
 
@@ -352,7 +408,7 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
             // only valid in kernel mode
             if (ICM_CM(tc->readMiscRegNoEffect(IPR_ICM)) !=
                 mode_kernel) {
-                acv++;
+                fetch_acv++;
                 return new ItbAcvFault(req->getVaddr());
             }
 
@@ -373,7 +429,7 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
                               asn);
 
             if (!entry) {
-                misses++;
+                fetch_misses++;
                 return new ItbPageFault(req->getVaddr());
             }
 
@@ -385,11 +441,11 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
             if (!(entry->xre &
                   (1 << ICM_CM(tc->readMiscRegNoEffect(IPR_ICM))))) {
                 // instruction access fault
-                acv++;
+                fetch_acv++;
                 return new ItbAcvFault(req->getVaddr());
             }
 
-            hits++;
+            fetch_hits++;
         }
     }
 
@@ -401,93 +457,8 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
 
 }
 
-void
-ITB::translateTiming(RequestPtr req, ThreadContext *tc,
-        Translation *translation)
-{
-    assert(translation);
-    translation->finish(translateAtomic(req, tc), req, tc, false);
-}
-
-///////////////////////////////////////////////////////////////////////
-//
-//  Alpha DTB
-//
-DTB::DTB(const Params *p)
-     : TLB(p)
-{}
-
-void
-DTB::regStats()
-{
-    read_hits
-        .name(name() + ".read_hits")
-        .desc("DTB read hits")
-        ;
-
-    read_misses
-        .name(name() + ".read_misses")
-        .desc("DTB read misses")
-        ;
-
-    read_acv
-        .name(name() + ".read_acv")
-        .desc("DTB read access violations")
-        ;
-
-    read_accesses
-        .name(name() + ".read_accesses")
-        .desc("DTB read accesses")
-        ;
-
-    write_hits
-        .name(name() + ".write_hits")
-        .desc("DTB write hits")
-        ;
-
-    write_misses
-        .name(name() + ".write_misses")
-        .desc("DTB write misses")
-        ;
-
-    write_acv
-        .name(name() + ".write_acv")
-        .desc("DTB write access violations")
-        ;
-
-    write_accesses
-        .name(name() + ".write_accesses")
-        .desc("DTB write accesses")
-        ;
-
-    hits
-        .name(name() + ".hits")
-        .desc("DTB hits")
-        ;
-
-    misses
-        .name(name() + ".misses")
-        .desc("DTB misses")
-        ;
-
-    acv
-        .name(name() + ".acv")
-        .desc("DTB access violations")
-        ;
-
-    accesses
-        .name(name() + ".accesses")
-        .desc("DTB accesses")
-        ;
-
-    hits = read_hits + write_hits;
-    misses = read_misses + write_misses;
-    acv = read_acv + write_acv;
-    accesses = read_accesses + write_accesses;
-}
-
 Fault
-DTB::translateAtomic(RequestPtr req, ThreadContext *tc, bool write)
+TLB::translateData(RequestPtr req, ThreadContext *tc, bool write)
 {
     Addr pc = tc->readPC();
 
@@ -624,14 +595,6 @@ DTB::translateAtomic(RequestPtr req, ThreadContext *tc, bool write)
     return checkCacheability(req);
 }
 
-void
-DTB::translateTiming(RequestPtr req, ThreadContext *tc,
-        Translation *translation, bool write)
-{
-    assert(translation);
-    translation->finish(translateAtomic(req, tc, write), req, tc, write);
-}
-
 TlbEntry &
 TLB::index(bool advance)
 {
@@ -643,16 +606,30 @@ TLB::index(bool advance)
     return *entry;
 }
 
+Fault
+TLB::translateAtomic(RequestPtr req, ThreadContext *tc,
+        bool write, bool execute)
+{
+    if (execute)
+        return translateInst(req, tc);
+    else
+        return translateData(req, tc, write);
+}
+
+void
+TLB::translateTiming(RequestPtr req, ThreadContext *tc,
+        Translation *translation,
+        bool write, bool execute)
+{
+    assert(translation);
+    translation->finish(translateAtomic(req, tc, write, execute),
+            req, tc, write, execute);
+}
+
 /* end namespace AlphaISA */ }
 
-AlphaISA::ITB *
+AlphaISA::TLB *
-AlphaITBParams::create()
+AlphaTLBParams::create()
 {
-    return new AlphaISA::ITB(this);
+    return new AlphaISA::TLB(this);
-}
-
-AlphaISA::DTB *
-AlphaDTBParams::create()
-{
-    return new AlphaISA::DTB(this);
 }

src/arch/alpha/tlb.hh

@@ -41,8 +41,7 @@
 #include "arch/alpha/vtophys.hh"
 #include "base/statistics.hh"
 #include "mem/request.hh"
-#include "params/AlphaDTB.hh"
+#include "params/AlphaTLB.hh"
-#include "params/AlphaITB.hh"
 #include "sim/faults.hh"
 #include "sim/tlb.hh"
 
@@ -55,6 +54,24 @@ class TlbEntry;
 class TLB : public BaseTLB
 {
   protected:
+    mutable Stats::Scalar fetch_hits;
+    mutable Stats::Scalar fetch_misses;
+    mutable Stats::Scalar fetch_acv;
+    mutable Stats::Formula fetch_accesses;
+    mutable Stats::Scalar read_hits;
+    mutable Stats::Scalar read_misses;
+    mutable Stats::Scalar read_acv;
+    mutable Stats::Scalar read_accesses;
+    mutable Stats::Scalar write_hits;
+    mutable Stats::Scalar write_misses;
+    mutable Stats::Scalar write_acv;
+    mutable Stats::Scalar write_accesses;
+    Stats::Formula data_hits;
+    Stats::Formula data_misses;
+    Stats::Formula data_acv;
+    Stats::Formula data_accesses;
+
+
     typedef std::multimap<Addr, int> PageTable;
     PageTable lookupTable;  // Quick lookup into page table
 
@@ -70,6 +87,8 @@ class TLB : public BaseTLB
     TLB(const Params *p);
     virtual ~TLB();
 
+    virtual void regStats();
+
     int getsize() const { return size; }
 
     TlbEntry &index(bool advance = true);
@@ -116,50 +135,17 @@ class TLB : public BaseTLB
         EntryCache[0] = entry;
         return entry;
     }
-};
 
-class ITB : public TLB
-{
   protected:
-    mutable Stats::Scalar hits;
+    Fault translateData(RequestPtr req, ThreadContext *tc, bool write);
-    mutable Stats::Scalar misses;
+    Fault translateInst(RequestPtr req, ThreadContext *tc);
-    mutable Stats::Scalar acv;
-    mutable Stats::Formula accesses;
 
   public:
-    typedef AlphaITBParams Params;
+    Fault translateAtomic(RequestPtr req, ThreadContext *tc,
-    ITB(const Params *p);
+            bool write = false, bool execute = false);
-    virtual void regStats();
-
-    Fault translateAtomic(RequestPtr req, ThreadContext *tc);
     void translateTiming(RequestPtr req, ThreadContext *tc,
-            Translation *translation);
+            Translation *translation,
-};
+            bool write = false, bool execute = false);
-
-class DTB : public TLB
-{
-  protected:
-    mutable Stats::Scalar read_hits;
-    mutable Stats::Scalar read_misses;
-    mutable Stats::Scalar read_acv;
-    mutable Stats::Scalar read_accesses;
-    mutable Stats::Scalar write_hits;
-    mutable Stats::Scalar write_misses;
-    mutable Stats::Scalar write_acv;
-    mutable Stats::Scalar write_accesses;
-    Stats::Formula hits;
-    Stats::Formula misses;
-    Stats::Formula acv;
-    Stats::Formula accesses;
-
-  public:
-    typedef AlphaDTBParams Params;
-    DTB(const Params *p);
-    virtual void regStats();
-
-    Fault translateAtomic(RequestPtr req, ThreadContext *tc, bool write);
-    void translateTiming(RequestPtr req, ThreadContext *tc,
-            Translation *translation, bool write);
 };
 
 } // namespace AlphaISA

src/arch/mips/MipsTLB.py

@@ -36,21 +36,5 @@ from BaseTLB import BaseTLB
 
 class MipsTLB(BaseTLB):
     type = 'MipsTLB'
-    abstract = True
+    cxx_class = 'MipsISA::TLB'
-    size = Param.Int("TLB size")
+    size = Param.Int(64, "TLB size")
-
-class MipsDTB(MipsTLB):
-    type = 'MipsDTB'
-    cxx_class = 'MipsISA::DTB'
-    size = 64
-
-class MipsITB(MipsTLB):
-    type = 'MipsITB'
-    cxx_class = 'MipsISA::ITB'
-    size = 64
-
-class MipsUTB(MipsTLB):
-    type = 'MipsUTB'
-    cxx_class = 'MipsISA::UTB'
-    size = 64
-

src/arch/mips/tlb.cc

@@ -45,10 +45,7 @@
 #include "cpu/thread_context.hh"
 #include "sim/process.hh"
 #include "mem/page_table.hh"
-#include "params/MipsDTB.hh"
-#include "params/MipsITB.hh"
 #include "params/MipsTLB.hh"
-#include "params/MipsUTB.hh"
 
 
 using namespace std;
@@ -310,7 +307,7 @@ TLB::regStats()
 }
 
 Fault
-ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
+TLB::translateInst(RequestPtr req, ThreadContext *tc)
 {
 #if !FULL_SYSTEM
     Process * p = tc->getProcessPtr();
@@ -426,16 +423,8 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
 #endif
 }
 
-void
-ITB::translateTiming(RequestPtr req, ThreadContext *tc,
-        Translation *translation)
-{
-    assert(translation);
-    translation->finish(translateAtomic(req, tc), req, tc, false);
-}
-
 Fault
-DTB::translateAtomic(RequestPtr req, ThreadContext *tc, bool write)
+TLB::translateData(RequestPtr req, ThreadContext *tc, bool write)
 {
 #if !FULL_SYSTEM
     Process * p = tc->getProcessPtr();
@@ -572,60 +561,24 @@ DTB::translateAtomic(RequestPtr req, ThreadContext *tc, bool write)
 #endif
 }
 
-void
+Fault
-DTB::translateTiming(RequestPtr req, ThreadContext *tc,
+TLB::translateAtomic(RequestPtr req, ThreadContext *tc,
-        Translation *translation, bool write)
+        bool write, bool execute)
 {
-    assert(translation);
+    if (execute)
-    translation->finish(translateAtomic(req, tc, write), req, tc, write);
+        return translateInst(req, tc);
+    else
+        return translateData(req, tc, write);
 }
 
-///////////////////////////////////////////////////////////////////////
+void
-//
+TLB::translateTiming(RequestPtr req, ThreadContext *tc,
-//  Mips ITB
+        Translation *translation, bool write, bool execute)
-//
+{
-ITB::ITB(const Params *p)
+    assert(translation);
-    : TLB(p)
+    translation->finish(translateAtomic(req, tc, write, execute),
-{}
+            req, tc, write, execute);
-
+}
-
-// void
-// ITB::regStats()
-// {
-//   /*    hits - causes failure for some reason
-//      .name(name() + ".hits")
-//      .desc("ITB hits");
-//     misses
-//      .name(name() + ".misses")
-//      .desc("ITB misses");
-//     acv
-//      .name(name() + ".acv")
-//      .desc("ITB acv");
-//     accesses
-//      .name(name() + ".accesses")
-//      .desc("ITB accesses");
-
-//      accesses = hits + misses + invalids; */
-// }
-
-
-
-///////////////////////////////////////////////////////////////////////
-//
-//  Mips DTB
-//
-DTB::DTB(const Params *p)
-    : TLB(p)
-{}
-
-///////////////////////////////////////////////////////////////////////
-//
-//  Mips UTB
-//
-UTB::UTB(const Params *p)
-    : ITB(p), DTB(p)
-{}
-
 
 
 MipsISA::PTE &
@@ -639,20 +592,8 @@ TLB::index(bool advance)
     return *pte;
 }
 
-MipsISA::ITB *
+MipsISA::TLB *
-MipsITBParams::create()
+MipsTLBParams::create()
 {
-    return new MipsISA::ITB(this);
+    return new MipsISA::TLB(this);
-}
-
-MipsISA::DTB *
-MipsDTBParams::create()
-{
-    return new MipsISA::DTB(this);
-}
-
-MipsISA::UTB *
-MipsUTBParams::create()
-{
-    return new MipsISA::UTB(this);
 }

src/arch/mips/tlb.hh

@@ -43,8 +43,7 @@
 #include "arch/mips/pagetable.hh"
 #include "base/statistics.hh"
 #include "mem/request.hh"
-#include "params/MipsDTB.hh"
+#include "params/MipsTLB.hh"
-#include "params/MipsITB.hh"
 #include "sim/faults.hh"
 #include "sim/tlb.hh"
 #include "sim/sim_object.hh"
@@ -138,34 +137,15 @@ class TLB : public BaseTLB
     void unserialize(Checkpoint *cp, const std::string &section);
 
     void regStats();
-};
-
-class ITB : public TLB {
-  public:
-    typedef MipsTLBParams Params;
-    ITB(const Params *p);
-
-    Fault translateAtomic(RequestPtr req, ThreadContext *tc);
-    void translateTiming(RequestPtr req, ThreadContext *tc,
-            Translation *translation);
-};
-
-class DTB : public TLB {
-  public:
-    typedef MipsTLBParams Params;
-    DTB(const Params *p);
 
     Fault translateAtomic(RequestPtr req, ThreadContext *tc,
-            bool write = false);
+            bool write=false, bool execute=false);
     void translateTiming(RequestPtr req, ThreadContext *tc,
-            Translation *translation, bool write = false);
+            Translation *translation, bool write=false, bool execute=false);
-};
-
-class UTB : public ITB, public DTB {
-  public:
-    typedef MipsTLBParams Params;
-    UTB(const Params *p);
 
+  private:
+    Fault translateInst(RequestPtr req, ThreadContext *tc);
+    Fault translateData(RequestPtr req, ThreadContext *tc, bool write);
 };
 
 }

src/arch/sparc/SparcTLB.py

@@ -33,15 +33,5 @@ from BaseTLB import BaseTLB
 
 class SparcTLB(BaseTLB):
     type = 'SparcTLB'
-    abstract = True
+    cxx_class = 'SparcISA::TLB'
-    size = Param.Int("TLB size")
+    size = Param.Int(64, "TLB size")
-
-class SparcDTB(SparcTLB):
-    type = 'SparcDTB'
-    cxx_class = 'SparcISA::DTB'
-    size = 64
-
-class SparcITB(SparcTLB):
-    type = 'SparcITB'
-    cxx_class = 'SparcISA::ITB'
-    size = 64

src/arch/sparc/tlb.cc

@@ -67,6 +67,9 @@ TLB::TLB(const Params *p)
     cx_config = 0;
     sfsr = 0;
     tag_access = 0;
+    sfar = 0;
+    cacheEntry[0] = NULL;
+    cacheEntry[1] = NULL;
 }
 
 void
@@ -418,25 +421,17 @@ TLB::writeTagAccess(Addr va, int context)
 }
 
 void
-ITB::writeSfsr(bool write, ContextType ct, bool se, FaultTypes ft, int asi)
+TLB::writeSfsr(Addr a, bool write, ContextType ct,
-{
-    DPRINTF(TLB, "TLB: ITB Fault:  w=%d ct=%d ft=%d asi=%d\n",
-             (int)write, ct, ft, asi);
-    TLB::writeSfsr(write, ct, se, ft, asi);
-}
-
-void
-DTB::writeSfsr(Addr a, bool write, ContextType ct,
         bool se, FaultTypes ft, int asi)
 {
-    DPRINTF(TLB, "TLB: DTB Fault: A=%#x w=%d ct=%d ft=%d asi=%d\n",
+    DPRINTF(TLB, "TLB: Fault: A=%#x w=%d ct=%d ft=%d asi=%d\n",
             a, (int)write, ct, ft, asi);
     TLB::writeSfsr(write, ct, se, ft, asi);
     sfar = a;
 }
 
 Fault
-ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
+TLB::translateInst(RequestPtr req, ThreadContext *tc)
 {
     uint64_t tlbdata = tc->readMiscRegNoEffect(MISCREG_TLB_DATA);
 
@@ -450,10 +445,10 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
 
     // Be fast if we can!
     if (cacheValid && cacheState == tlbdata) {
-        if (cacheEntry) {
+        if (cacheEntry[0]) {
-            if (cacheEntry->range.va < vaddr + sizeof(MachInst) &&
+            if (cacheEntry[0]->range.va < vaddr + sizeof(MachInst) &&
-                cacheEntry->range.va + cacheEntry->range.size >= vaddr) {
+                cacheEntry[0]->range.va + cacheEntry[0]->range.size >= vaddr) {
-                req->setPaddr(cacheEntry->pte.translate(vaddr));
+                req->setPaddr(cacheEntry[0]->pte.translate(vaddr));
                 return NoFault;
             }
         } else {
@@ -492,7 +487,7 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
     if ( hpriv || red ) {
         cacheValid = true;
         cacheState = tlbdata;
-        cacheEntry = NULL;
+        cacheEntry[0] = NULL;
         req->setPaddr(vaddr & PAddrImplMask);
         return NoFault;
     }
@@ -541,23 +536,15 @@ ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
     // cache translation date for next translation
     cacheValid = true;
     cacheState = tlbdata;
-    cacheEntry = e;
+    cacheEntry[0] = e;
 
     req->setPaddr(e->pte.translate(vaddr));
     DPRINTF(TLB, "TLB: %#X -> %#X\n", vaddr, req->getPaddr());
     return NoFault;
 }
 
-void
-ITB::translateTiming(RequestPtr req, ThreadContext *tc,
-        Translation *translation)
-{
-    assert(translation);
-    translation->finish(translateAtomic(req, tc), req, tc, false);
-}
-
 Fault
-DTB::translateAtomic(RequestPtr req, ThreadContext *tc, bool write)
+TLB::translateData(RequestPtr req, ThreadContext *tc, bool write)
 {
     /*
      * @todo this could really use some profiling and fixing to make
@@ -855,18 +842,29 @@ handleMmuRegAccess:
     return NoFault;
 };
 
+Fault
+TLB::translateAtomic(RequestPtr req, ThreadContext *tc,
+        bool write, bool execute)
+{
+    if (execute)
+        return translateInst(req, tc);
+    else
+        return translateData(req, tc, write);
+}
+
 void
-DTB::translateTiming(RequestPtr req, ThreadContext *tc,
+TLB::translateTiming(RequestPtr req, ThreadContext *tc,
-        Translation *translation, bool write)
+        Translation *translation, bool write, bool execute)
 {
     assert(translation);
-    translation->finish(translateAtomic(req, tc, write), req, tc, write);
+    translation->finish(translateAtomic(req, tc, write, execute),
+            req, tc, write, execute);
 }
 
 #if FULL_SYSTEM
 
 Tick
-DTB::doMmuRegRead(ThreadContext *tc, Packet *pkt)
+TLB::doMmuRegRead(ThreadContext *tc, Packet *pkt)
 {
     Addr va = pkt->getAddr();
     ASI asi = (ASI)pkt->req->getAsi();
@@ -875,7 +873,7 @@ DTB::doMmuRegRead(ThreadContext *tc, Packet *pkt)
     DPRINTF(IPR, "Memory Mapped IPR Read: asi=%#X a=%#x\n",
          (uint32_t)pkt->req->getAsi(), pkt->getAddr());
 
-    ITB *itb = tc->getITBPtr();
+    TLB *itb = tc->getITBPtr();
 
     switch (asi) {
       case ASI_LSU_CONTROL_REG:
@@ -1051,7 +1049,7 @@ doMmuReadError:
 }
 
 Tick
-DTB::doMmuRegWrite(ThreadContext *tc, Packet *pkt)
+TLB::doMmuRegWrite(ThreadContext *tc, Packet *pkt)
 {
     uint64_t data = gtoh(pkt->get<uint64_t>());
     Addr va = pkt->getAddr();
@@ -1071,7 +1069,7 @@ DTB::doMmuRegWrite(ThreadContext *tc, Packet *pkt)
     DPRINTF(IPR, "Memory Mapped IPR Write: asi=%#X a=%#x d=%#X\n",
          (uint32_t)asi, va, data);
 
-    ITB *itb = tc->getITBPtr();
+    TLB *itb = tc->getITBPtr();
 
     switch (asi) {
       case ASI_LSU_CONTROL_REG:
@@ -1306,10 +1304,10 @@ doMmuWriteError:
 #endif
 
 void
-DTB::GetTsbPtr(ThreadContext *tc, Addr addr, int ctx, Addr *ptrs)
+TLB::GetTsbPtr(ThreadContext *tc, Addr addr, int ctx, Addr *ptrs)
 {
     uint64_t tag_access = mbits(addr,63,13) | mbits(ctx,12,0);
-    ITB * itb = tc->getITBPtr();
+    TLB * itb = tc->getITBPtr();
     ptrs[0] = MakeTsbPtr(Ps0, tag_access,
                 c0_tsb_ps0,
                 c0_config,
@@ -1333,7 +1331,7 @@ DTB::GetTsbPtr(ThreadContext *tc, Addr addr, int ctx, Addr *ptrs)
 }
 
 uint64_t
-DTB::MakeTsbPtr(TsbPageSize ps, uint64_t tag_access, uint64_t c0_tsb,
+TLB::MakeTsbPtr(TsbPageSize ps, uint64_t tag_access, uint64_t c0_tsb,
         uint64_t c0_config, uint64_t cX_tsb, uint64_t cX_config)
 {
     uint64_t tsb;
@@ -1391,6 +1389,7 @@ TLB::serialize(std::ostream &os)
         nameOut(os, csprintf("%s.PTE%d", name(), x));
         tlb[x].serialize(os);
     }
+    SERIALIZE_SCALAR(sfar);
 }
 
 void
@@ -1429,32 +1428,13 @@ TLB::unserialize(Checkpoint *cp, const std::string &section)
             lookupTable.insert(tlb[x].range, &tlb[x]);
 
     }
-}
-
-void
-DTB::serialize(std::ostream &os)
-{
-    TLB::serialize(os);
-    SERIALIZE_SCALAR(sfar);
-}
-
-void
-DTB::unserialize(Checkpoint *cp, const std::string &section)
-{
-    TLB::unserialize(cp, section);
     UNSERIALIZE_SCALAR(sfar);
 }
 
 /* end namespace SparcISA */ }
 
-SparcISA::ITB *
+SparcISA::TLB *
-SparcITBParams::create()
+SparcTLBParams::create()
 {
-    return new SparcISA::ITB(this);
+    return new SparcISA::TLB(this);
-}
-
-SparcISA::DTB *
-SparcDTBParams::create()
-{
-    return new SparcISA::DTB(this);
 }

src/arch/sparc/tlb.hh

@@ -36,8 +36,7 @@
 #include "base/misc.hh"
 #include "config/full_system.hh"
 #include "mem/request.hh"
-#include "params/SparcDTB.hh"
+#include "params/SparcTLB.hh"
-#include "params/SparcITB.hh"
 #include "sim/faults.hh"
 #include "sim/tlb.hh"
 
@@ -57,6 +56,8 @@ class TLB : public BaseTLB
 
     //TLB state
   protected:
+    // Only used when this is the data TLB.
+    uint64_t sfar;
     uint64_t c0_tsb_ps0;
     uint64_t c0_tsb_ps1;
     uint64_t c0_config;
@@ -148,6 +149,9 @@ class TLB : public BaseTLB
 
     void writeTagAccess(Addr va, int context);
 
+    Fault translateInst(RequestPtr req, ThreadContext *tc);
+    Fault translateData(RequestPtr req, ThreadContext *tc, bool write);
+
   public:
     typedef SparcTLBParams Params;
     TLB(const Params *p);
@@ -159,52 +163,10 @@ class TLB : public BaseTLB
 
     void dumpAll();
 
-    // Checkpointing
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
-
-    /** Give an entry id, read that tlb entries' tte */
-    uint64_t TteRead(int entry);
-
-};
-
-class ITB : public TLB
-{
-  public:
-    typedef SparcITBParams Params;
-    ITB(const Params *p) : TLB(p)
-    {
-        cacheEntry = NULL;
-    }
-
-    Fault translateAtomic(RequestPtr req, ThreadContext *tc);
-    void translateTiming(RequestPtr req, ThreadContext *tc,
-            Translation *translation);
-  private:
-    void writeSfsr(bool write, ContextType ct,
-            bool se, FaultTypes ft, int asi);
-    TlbEntry *cacheEntry;
-    friend class DTB;
-};
-
-class DTB : public TLB
-{
-    //DTLB specific state
-  protected:
-    uint64_t sfar;
-  public:
-    typedef SparcDTBParams Params;
-    DTB(const Params *p) : TLB(p)
-    {
-        sfar = 0;
-        cacheEntry[0] = NULL;
-        cacheEntry[1] = NULL;
-    }
-
     Fault translateAtomic(RequestPtr req,
-            ThreadContext *tc, bool write=false);
+            ThreadContext *tc, bool write=false, bool execute=false);
     void translateTiming(RequestPtr req, ThreadContext *tc,
-            Translation *translation, bool write=false);
+            Translation *translation, bool write=false, bool execute=false);
 #if FULL_SYSTEM
     Tick doMmuRegRead(ThreadContext *tc, Packet *pkt);
     Tick doMmuRegWrite(ThreadContext *tc, Packet *pkt);
@@ -215,6 +177,9 @@ class DTB : public TLB
     virtual void serialize(std::ostream &os);
     virtual void unserialize(Checkpoint *cp, const std::string &section);
 
+    /** Give an entry id, read that tlb entries' tte */
+    uint64_t TteRead(int entry);
+
   private:
     void writeSfsr(Addr a, bool write, ContextType ct,
             bool se, FaultTypes ft, int asi);

src/arch/sparc/vtophys.cc

@@ -81,8 +81,8 @@ vtophys(ThreadContext *tc, Addr addr)
     //int sec_context = bits(tlbdata,63,48);
 
     FunctionalPort *mem = tc->getPhysPort();
-    ITB* itb = tc->getITBPtr();
+    TLB* itb = tc->getITBPtr();
-    DTB* dtb = tc->getDTBPtr();
+    TLB* dtb = tc->getDTBPtr();
     TlbEntry* tbe;
     PageTableEntry pte;
     Addr tsbs[4];

src/arch/x86/X86TLB.py

@@ -68,18 +68,8 @@ if build_env['FULL_SYSTEM']:
 
 class X86TLB(BaseTLB):
     type = 'X86TLB'
-    abstract = True
+    cxx_class = 'X86ISA::TLB'
-    size = Param.Int("TLB size")
+    size = Param.Int(64, "TLB size")
     if build_env['FULL_SYSTEM']:
         walker = Param.X86PagetableWalker(\
                 X86PagetableWalker(), "page table walker")
-
-class X86DTB(X86TLB):
-    type = 'X86DTB'
-    cxx_class = 'X86ISA::DTB'
-    size = 64
-
-class X86ITB(X86TLB):
-    type = 'X86ITB'
-    cxx_class = 'X86ISA::ITB'
-    size = 64

src/arch/x86/pagetable_walker.cc

@@ -98,7 +98,7 @@ Walker::doNext(PacketPtr &write)
     bool uncacheable = pte.pcd;
     Addr nextRead = 0;
     bool doWrite = false;
-    bool badNX = pte.nx && (!tlb->allowNX() || !enableNX);
+    bool badNX = pte.nx && execute && enableNX;
     switch(state) {
       case LongPML4:
         DPRINTF(PageTableWalker,

src/arch/x86/tlb.cc

@@ -700,55 +700,36 @@ TLB::translate(RequestPtr req, ThreadContext *tc,
 };
 
 Fault
-DTB::translateAtomic(RequestPtr req, ThreadContext *tc, bool write)
+TLB::translateAtomic(RequestPtr req, ThreadContext *tc,
+        bool write, bool execute)
 {
     bool delayedResponse;
     return TLB::translate(req, tc, NULL, write,
-            false, delayedResponse, false);
+            execute, delayedResponse, false);
 }
 
 void
-DTB::translateTiming(RequestPtr req, ThreadContext *tc,
+TLB::translateTiming(RequestPtr req, ThreadContext *tc,
-        Translation *translation, bool write)
+        Translation *translation, bool write, bool execute)
 {
     bool delayedResponse;
     assert(translation);
     Fault fault = TLB::translate(req, tc, translation,
-            write, false, delayedResponse, true);
+            write, execute, delayedResponse, true);
     if (!delayedResponse)
-        translation->finish(fault, req, tc, write);
+        translation->finish(fault, req, tc, write, execute);
-}
-
-Fault
-ITB::translateAtomic(RequestPtr req, ThreadContext *tc)
-{
-    bool delayedResponse;
-    return TLB::translate(req, tc, NULL, false,
-            true, delayedResponse, false);
-}
-
-void
-ITB::translateTiming(RequestPtr req, ThreadContext *tc,
-        Translation *translation)
-{
-    bool delayedResponse;
-    assert(translation);
-    Fault fault = TLB::translate(req, tc, translation,
-            false, true, delayedResponse, true);
-    if (!delayedResponse)
-        translation->finish(fault, req, tc, false);
 }
 
 #if FULL_SYSTEM
 
 Tick
-DTB::doMmuRegRead(ThreadContext *tc, Packet *pkt)
+TLB::doMmuRegRead(ThreadContext *tc, Packet *pkt)
 {
     return tc->getCpuPtr()->ticks(1);
 }
 
 Tick
-DTB::doMmuRegWrite(ThreadContext *tc, Packet *pkt)
+TLB::doMmuRegWrite(ThreadContext *tc, Packet *pkt)
 {
     return tc->getCpuPtr()->ticks(1);
 }
@@ -765,28 +746,10 @@ TLB::unserialize(Checkpoint *cp, const std::string &section)
 {
 }
 
-void
-DTB::serialize(std::ostream &os)
-{
-    TLB::serialize(os);
-}
-
-void
-DTB::unserialize(Checkpoint *cp, const std::string &section)
-{
-    TLB::unserialize(cp, section);
-}
-
 /* end namespace X86ISA */ }
 
-X86ISA::ITB *
+X86ISA::TLB *
-X86ITBParams::create()
+X86TLBParams::create()
 {
-    return new X86ISA::ITB(this);
+    return new X86ISA::TLB(this);
-}
-
-X86ISA::DTB *
-X86DTBParams::create()
-{
-    return new X86ISA::DTB(this);
 }

src/arch/x86/tlb.hh

@@ -67,8 +67,7 @@
 #include "config/full_system.hh"
 #include "mem/mem_object.hh"
 #include "mem/request.hh"
-#include "params/X86DTB.hh"
+#include "params/X86TLB.hh"
-#include "params/X86ITB.hh"
 #include "sim/faults.hh"
 #include "sim/tlb.hh"
 #include "sim/sim_object.hh"
@@ -82,8 +81,6 @@ namespace X86ISA
 
     static const unsigned StoreCheck = 1 << NUM_SEGMENTREGS;
 
-    class TLB;
-
     class TLB : public BaseTLB
     {
       protected:
@@ -91,14 +88,9 @@ namespace X86ISA
 
         typedef std::list<TlbEntry *> EntryList;
 
-        bool _allowNX;
         uint32_t configAddress;
 
       public:
-        bool allowNX() const
-        {
-            return _allowNX;
-        }
 
         typedef X86TLBParams Params;
         TLB(const Params *p);
@@ -140,45 +132,19 @@ namespace X86ISA
 
       public:
 
-        TlbEntry * insert(Addr vpn, TlbEntry &entry);
+        Fault translateAtomic(RequestPtr req, ThreadContext *tc,
-
+                bool write = false, bool execute = false);
-        // Checkpointing
-        virtual void serialize(std::ostream &os);
-        virtual void unserialize(Checkpoint *cp, const std::string &section);
-    };
-
-    class ITB : public TLB
-    {
-      public:
-        typedef X86ITBParams Params;
-        ITB(const Params *p) : TLB(p)
-        {
-            _allowNX = false;
-        }
-
-        Fault translateAtomic(RequestPtr req, ThreadContext *tc);
         void translateTiming(RequestPtr req, ThreadContext *tc,
-                Translation *translation);
+                Translation *translation,
+                bool write = false, bool execute = false);
 
-        friend class DTB;
-    };
-
-    class DTB : public TLB
-    {
-      public:
-        typedef X86DTBParams Params;
-        DTB(const Params *p) : TLB(p)
-        {
-            _allowNX = true;
-        }
-        Fault translateAtomic(RequestPtr req, ThreadContext *tc, bool write);
-        void translateTiming(RequestPtr req, ThreadContext *tc,
-                Translation *translation, bool write);
 #if FULL_SYSTEM
         Tick doMmuRegRead(ThreadContext *tc, Packet *pkt);
         Tick doMmuRegWrite(ThreadContext *tc, Packet *pkt);
 #endif
 
+        TlbEntry * insert(Addr vpn, TlbEntry &entry);
+
         // Checkpointing
         virtual void serialize(std::ostream &os);
         virtual void unserialize(Checkpoint *cp, const std::string &section);

src/cpu/BaseCPU.py

@@ -38,19 +38,19 @@ import sys
 default_tracer = ExeTracer()
 
 if build_env['TARGET_ISA'] == 'alpha':
-    from AlphaTLB import AlphaDTB, AlphaITB
+    from AlphaTLB import AlphaTLB
     if build_env['FULL_SYSTEM']:
         from AlphaInterrupts import AlphaInterrupts
 elif build_env['TARGET_ISA'] == 'sparc':
-    from SparcTLB import SparcDTB, SparcITB
+    from SparcTLB import SparcTLB
     if build_env['FULL_SYSTEM']:
         from SparcInterrupts import SparcInterrupts
 elif build_env['TARGET_ISA'] == 'x86':
-    from X86TLB import X86DTB, X86ITB
+    from X86TLB import X86TLB
     if build_env['FULL_SYSTEM']:
         from X86LocalApic import X86LocalApic
 elif build_env['TARGET_ISA'] == 'mips':
-    from MipsTLB import MipsTLB,MipsDTB, MipsITB, MipsUTB
+    from MipsTLB import MipsTLB
     if build_env['FULL_SYSTEM']:
         from MipsInterrupts import MipsInterrupts
 elif build_env['TARGET_ISA'] == 'arm':
@@ -83,29 +83,27 @@ class BaseCPU(MemObject):
         workload = VectorParam.Process("processes to run")
 
     if build_env['TARGET_ISA'] == 'sparc':
-        dtb = Param.SparcDTB(SparcDTB(), "Data TLB")
+        dtb = Param.SparcTLB(SparcTLB(), "Data TLB")
-        itb = Param.SparcITB(SparcITB(), "Instruction TLB")
+        itb = Param.SparcTLB(SparcTLB(), "Instruction TLB")
         if build_env['FULL_SYSTEM']:
             interrupts = Param.SparcInterrupts(
                 SparcInterrupts(), "Interrupt Controller")
     elif build_env['TARGET_ISA'] == 'alpha':
-        dtb = Param.AlphaDTB(AlphaDTB(), "Data TLB")
+        dtb = Param.AlphaTLB(AlphaTLB(size=64), "Data TLB")
-        itb = Param.AlphaITB(AlphaITB(), "Instruction TLB")
+        itb = Param.AlphaTLB(AlphaTLB(size=48), "Instruction TLB")
         if build_env['FULL_SYSTEM']:
             interrupts = Param.AlphaInterrupts(
                 AlphaInterrupts(), "Interrupt Controller")
     elif build_env['TARGET_ISA'] == 'x86':
-        dtb = Param.X86DTB(X86DTB(), "Data TLB")
+        dtb = Param.X86TLB(X86TLB(), "Data TLB")
-        itb = Param.X86ITB(X86ITB(), "Instruction TLB")
+        itb = Param.X86TLB(X86TLB(), "Instruction TLB")
         if build_env['FULL_SYSTEM']:
             _localApic = X86LocalApic(pio_addr=0x2000000000000000)
             interrupts = \
                 Param.X86LocalApic(_localApic, "Interrupt Controller")
     elif build_env['TARGET_ISA'] == 'mips':
-        UnifiedTLB = Param.Bool(True, "Is this a Unified TLB?")
+        dtb = Param.MipsTLB(MipsTLB(), "Data TLB")
-        dtb = Param.MipsDTB(MipsDTB(), "Data TLB")
+        itb = Param.MipsTLB(MipsTLB(), "Instruction TLB")
-        itb = Param.MipsITB(MipsITB(), "Instruction TLB")
-        tlb = Param.MipsUTB(MipsUTB(), "Unified TLB")
         if build_env['FULL_SYSTEM']:
             interrupts = Param.MipsInterrupts(
                     MipsInterrupts(), "Interrupt Controller")

src/cpu/checker/cpu.hh

@@ -49,8 +49,7 @@
 #if FULL_SYSTEM
 namespace TheISA
 {
-    class ITB;
+    class TLB;
-    class DTB;
 }
 class Processor;
 class PhysicalMemory;
@@ -130,8 +129,8 @@ class CheckerCPU : public BaseCPU
 
     ThreadContext *tc;
 
-    TheISA::ITB *itb;
+    TheISA::TLB *itb;
-    TheISA::DTB *dtb;
+    TheISA::TLB *dtb;
 
 #if FULL_SYSTEM
     Addr dbg_vtophys(Addr addr);

src/cpu/checker/thread_context.hh

@@ -84,9 +84,9 @@ class CheckerThreadContext : public ThreadContext
 
     int cpuId() { return actualTC->cpuId(); }
 
-    TheISA::ITB *getITBPtr() { return actualTC->getITBPtr(); }
+    TheISA::TLB *getITBPtr() { return actualTC->getITBPtr(); }
 
-    TheISA::DTB *getDTBPtr() { return actualTC->getDTBPtr(); }
+    TheISA::TLB *getDTBPtr() { return actualTC->getDTBPtr(); }
 
 #if FULL_SYSTEM
     System *getSystemPtr() { return actualTC->getSystemPtr(); }

src/cpu/inorder/cpu.hh

@@ -103,8 +103,8 @@ class InOrderCPU : public BaseCPU
 
     Params *cpu_params;
 
-    TheISA::ITB * itb;
+    TheISA::TLB * itb;
-    TheISA::DTB * dtb;
+    TheISA::TLB * dtb;
 
   public:
     enum Status {

src/cpu/inorder/resources/tlb_unit.cc

@@ -99,7 +99,7 @@ TLBUnit::execute(int slot_idx)
         {
             tlb_req->fault =
                 this->cpu->itb->translateAtomic(tlb_req->memReq,
-                        cpu->thread[tid]->getTC());
+                        cpu->thread[tid]->getTC(), false, true);
 
             if (tlb_req->fault != NoFault) {
                 DPRINTF(InOrderTLB, "[tid:%i]: %s encountered while translating "

src/cpu/inorder/thread_context.hh

@@ -65,10 +65,10 @@ class InOrderThreadContext : public ThreadContext
 
 
     /** Returns a pointer to the ITB. */
-    TheISA::ITB *getITBPtr() { return cpu->itb; }
+    TheISA::TLB *getITBPtr() { return cpu->itb; }
 
     /** Returns a pointer to the DTB. */
-    TheISA::DTB *getDTBPtr() { return cpu->dtb; }
+    TheISA::TLB *getDTBPtr() { return cpu->dtb; }
 
     System *getSystemPtr() { return cpu->system; }
 

src/cpu/o3/cpu.hh

@@ -106,8 +106,8 @@ class FullO3CPU : public BaseO3CPU
         SwitchedOut
     };
 
-    TheISA::ITB * itb;
+    TheISA::TLB * itb;
-    TheISA::DTB * dtb;
+    TheISA::TLB * dtb;
 
     /** Overall CPU status. */
     Status _status;

src/cpu/o3/fetch_impl.hh

@@ -601,7 +601,8 @@ DefaultFetch<Impl>::fetchCacheLine(Addr fetch_PC, Fault &ret_fault, unsigned tid
     memReq[tid] = mem_req;
 
     // Translate the instruction request.
-    fault = cpu->itb->translateAtomic(mem_req, cpu->thread[tid]->getTC());
+    fault = cpu->itb->translateAtomic(mem_req, cpu->thread[tid]->getTC(),
+            false, true);
 
     // In the case of faults, the fetch stage may need to stall and wait
     // for the ITB miss to be handled.

src/cpu/o3/thread_context.hh

@@ -67,10 +67,10 @@ class O3ThreadContext : public ThreadContext
     O3ThreadState<Impl> *thread;
 
     /** Returns a pointer to the ITB. */
-    TheISA::ITB *getITBPtr() { return cpu->itb; }
+    TheISA::TLB *getITBPtr() { return cpu->itb; }
 
     /** Returns a pointer to the DTB. */
-    TheISA::DTB *getDTBPtr() { return cpu->dtb; }
+    TheISA::TLB *getDTBPtr() { return cpu->dtb; }
 
     /** Returns a pointer to this CPU. */
     virtual BaseCPU *getCpuPtr() { return cpu; }

src/cpu/ozone/cpu.hh

@@ -53,8 +53,7 @@
 
 namespace TheISA
 {
-    class ITB;
+    class TLB;
-    class DTB;
 }
 class PhysicalMemory;
 class MemoryController;
@@ -116,9 +115,9 @@ class OzoneCPU : public BaseCPU
 
         BaseCPU *getCpuPtr();
 
-        TheISA::ITB *getITBPtr() { return cpu->itb; }
+        TheISA::TLB *getITBPtr() { return cpu->itb; }
 
-        TheISA::DTB * getDTBPtr() { return cpu->dtb; }
+        TheISA::TLB * getDTBPtr() { return cpu->dtb; }
 
 #if FULL_SYSTEM
         System *getSystemPtr() { return cpu->system; }
@@ -349,8 +348,8 @@ class OzoneCPU : public BaseCPU
 
     bool interval_stats;
 
-    TheISA::ITB *itb;
+    TheISA::TLB *itb;
-    TheISA::DTB *dtb;
+    TheISA::TLB *dtb;
     System *system;
     PhysicalMemory *physmem;
 #endif

src/cpu/ozone/front_end_impl.hh

@@ -480,7 +480,7 @@ FrontEnd<Impl>::fetchCacheLine()
                          PC, cpu->thread->contextId());
 
     // Translate the instruction request.
-    fault = cpu->itb->translateAtomic(memReq, thread);
+    fault = cpu->itb->translateAtomic(memReq, thread, false, true);
 
     // Now do the timing access to see whether or not the instruction
     // exists within the cache.

src/cpu/ozone/simple_params.hh

@@ -36,8 +36,7 @@
 //Forward declarations
 namespace TheISA
 {
-    class DTB;
+    class TLB;
-    class ITB;
 }
 class FUPool;
 class MemObject;
@@ -55,7 +54,7 @@ class SimpleParams : public BaseCPU::Params
 {
   public:
 
-    TheISA::ITB *itb; TheISA::DTB *dtb;
+    TheISA::TLB *itb; TheISA::TLB *dtb;
 #if !FULL_SYSTEM
     std::vector<Process *> workload;
 #endif // FULL_SYSTEM

src/cpu/simple/atomic.cc

@@ -609,7 +609,7 @@ AtomicSimpleCPU::tick()
         bool fromRom = isRomMicroPC(thread->readMicroPC());
         if (!fromRom && !curMacroStaticInst) {
             setupFetchRequest(&ifetch_req);
-            fault = thread->itb->translateAtomic(&ifetch_req, tc);
+            fault = thread->itb->translateAtomic(&ifetch_req, tc, false, true);
         }
 
         if (fault == NoFault) {

src/cpu/simple/timing.cc

@@ -672,7 +672,7 @@ TimingSimpleCPU::fetch()
         ifetch_req->setThreadContext(_cpuId, /* thread ID */ 0);
         setupFetchRequest(ifetch_req);
         thread->itb->translateTiming(ifetch_req, tc,
-                &fetchTranslation);
+                &fetchTranslation, false, true);
     } else {
         _status = IcacheWaitResponse;
         completeIfetch(NULL);

src/cpu/simple/timing.hh

@@ -106,7 +106,7 @@ class TimingSimpleCPU : public BaseSimpleCPU
         {}
 
         void finish(Fault fault, RequestPtr req,
-                ThreadContext *tc, bool write)
+                ThreadContext *tc, bool write, bool execute)
         {
             cpu->sendFetch(fault, req, tc);
         }
@@ -129,7 +129,7 @@ class TimingSimpleCPU : public BaseSimpleCPU
 
         void
         finish(Fault fault, RequestPtr req,
-                ThreadContext *tc, bool write)
+                ThreadContext *tc, bool write, bool execute)
         {
             cpu->sendData(fault, req, data, res, read);
             delete this;
@@ -173,7 +173,7 @@ class TimingSimpleCPU : public BaseSimpleCPU
 
         void
         finish(Fault fault, RequestPtr req,
-                ThreadContext *tc, bool write)
+                ThreadContext *tc, bool write, bool execute)
         {
             assert(state);
             assert(state->outstanding);

src/cpu/simple_thread.cc

@@ -61,7 +61,7 @@ using namespace std;
 // constructor
 #if FULL_SYSTEM
 SimpleThread::SimpleThread(BaseCPU *_cpu, int _thread_num, System *_sys,
-                           TheISA::ITB *_itb, TheISA::DTB *_dtb,
+                           TheISA::TLB *_itb, TheISA::TLB *_dtb,
                            bool use_kernel_stats)
     : ThreadState(_cpu, _thread_num), cpu(_cpu), system(_sys), itb(_itb),
       dtb(_dtb)
@@ -92,7 +92,7 @@ SimpleThread::SimpleThread(BaseCPU *_cpu, int _thread_num, System *_sys,
 }
 #else
 SimpleThread::SimpleThread(BaseCPU *_cpu, int _thread_num, Process *_process,
-                           TheISA::ITB *_itb, TheISA::DTB *_dtb, int _asid)
+                           TheISA::TLB *_itb, TheISA::TLB *_dtb, int _asid)
     : ThreadState(_cpu, _thread_num, _process, _asid),
       cpu(_cpu), itb(_itb), dtb(_dtb)
 {

src/cpu/simple_thread.hh

@@ -108,17 +108,17 @@ class SimpleThread : public ThreadState
 
     System *system;
 
-    TheISA::ITB *itb;
+    TheISA::TLB *itb;
-    TheISA::DTB *dtb;
+    TheISA::TLB *dtb;
 
     // constructor: initialize SimpleThread from given process structure
 #if FULL_SYSTEM
     SimpleThread(BaseCPU *_cpu, int _thread_num, System *_system,
-                 TheISA::ITB *_itb, TheISA::DTB *_dtb,
+                 TheISA::TLB *_itb, TheISA::TLB *_dtb,
                  bool use_kernel_stats = true);
 #else
     SimpleThread(BaseCPU *_cpu, int _thread_num, Process *_process,
-                 TheISA::ITB *_itb, TheISA::DTB *_dtb, int _asid);
+                 TheISA::TLB *_itb, TheISA::TLB *_dtb, int _asid);
 #endif
 
     SimpleThread();
@@ -181,9 +181,9 @@ class SimpleThread : public ThreadState
 
     BaseCPU *getCpuPtr() { return cpu; }
 
-    TheISA::ITB *getITBPtr() { return itb; }
+    TheISA::TLB *getITBPtr() { return itb; }
 
-    TheISA::DTB *getDTBPtr() { return dtb; }
+    TheISA::TLB *getDTBPtr() { return dtb; }
 
     System *getSystemPtr() { return system; }
 

src/cpu/thread_context.hh

@@ -44,8 +44,7 @@
 // DTB pointers.
 namespace TheISA
 {
-    class DTB;
+    class TLB;
-    class ITB;
 }
 class BaseCPU;
 class EndQuiesceEvent;
@@ -124,9 +123,9 @@ class ThreadContext
 
     virtual void setContextId(int id) = 0;
 
-    virtual TheISA::ITB *getITBPtr() = 0;
+    virtual TheISA::TLB *getITBPtr() = 0;
 
-    virtual TheISA::DTB *getDTBPtr() = 0;
+    virtual TheISA::TLB *getDTBPtr() = 0;
 
     virtual System *getSystemPtr() = 0;
 
@@ -306,9 +305,9 @@ class ProxyThreadContext : public ThreadContext
 
     void setContextId(int id) { actualTC->setContextId(id); }
 
-    TheISA::ITB *getITBPtr() { return actualTC->getITBPtr(); }
+    TheISA::TLB *getITBPtr() { return actualTC->getITBPtr(); }
 
-    TheISA::DTB *getDTBPtr() { return actualTC->getDTBPtr(); }
+    TheISA::TLB *getDTBPtr() { return actualTC->getDTBPtr(); }
 
     System *getSystemPtr() { return actualTC->getSystemPtr(); }
 

src/sim/tlb.cc

@@ -34,7 +34,7 @@
 #include "sim/tlb.hh"
 
 Fault
-GenericTLB::translateAtomic(RequestPtr req, ThreadContext * tc, bool)
+GenericTLB::translateAtomic(RequestPtr req, ThreadContext * tc, bool, bool)
 {
 #if FULL_SYSTEM
         panic("Generic translation shouldn't be used in full system mode.\n");
@@ -51,10 +51,11 @@ GenericTLB::translateAtomic(RequestPtr req, ThreadContext * tc, bool)
 
 void
 GenericTLB::translateTiming(RequestPtr req, ThreadContext *tc,
-        Translation *translation, bool write)
+        Translation *translation, bool write, bool execute)
 {
     assert(translation);
-    translation->finish(translateAtomic(req, tc, write), req, tc, write);
+    translation->finish(translateAtomic(req, tc, write, execute),
+            req, tc, write, execute);
 }
 
 void

src/sim/tlb.hh

@@ -60,7 +60,7 @@ class BaseTLB : public SimObject
          * function. Once it's called, the object is no longer valid.
          */
         virtual void finish(Fault fault, RequestPtr req,
-                ThreadContext *tc, bool write=false) = 0;
+                ThreadContext *tc, bool write=false, bool execute=false) = 0;
     };
 };
 
@@ -73,9 +73,10 @@ class GenericTLB : public BaseTLB
   public:
     void demapPage(Addr vaddr, uint64_t asn);
 
-    Fault translateAtomic(RequestPtr req, ThreadContext *tc, bool=false);
+    Fault translateAtomic(RequestPtr req, ThreadContext *tc,
+            bool=false, bool=false);
     void translateTiming(RequestPtr req, ThreadContext *tc,
-            Translation *translation, bool=false);
+            Translation *translation, bool=false, bool=false);
 };
 
 #endif // __ARCH_SPARC_TLB_HH__