Changes to untemplate StaticInst and StaticInstPtr, change the isa to a namespace...
authorGabe Black <gblack@eecs.umich.edu>
Sun, 19 Feb 2006 07:34:37 +0000 (02:34 -0500)
committerGabe Black <gblack@eecs.umich.edu>
Sun, 19 Feb 2006 07:34:37 +0000 (02:34 -0500)
arch/alpha/alpha_linux_process.cc:
    Added using directive for AlphaISA namespace
arch/alpha/alpha_memory.hh:
arch/alpha/isa/branch.isa:
cpu/pc_event.hh:
    Added typedefs for Addr
arch/alpha/alpha_tru64_process.cc:
arch/alpha/arguments.cc:
    Added using directive for AlphaISA
arch/alpha/ev5.hh:
    Added an include of arch/alpha/isa_traits.hh, and a using directive for the AlphaISA namespace.
arch/alpha/faults.hh:
    Added a typedef for the Addr type, and changed the formatting of the faults slightly.
arch/alpha/isa/main.isa:
    Untemplatized StaticInst, added a using for namespace AlphaISA to show up in decoder.cc and the exec.ccs, relocated makeNop to decoder.hh
arch/alpha/isa/mem.isa:
    Untemplatized StaticInst and StaticInstPtr
arch/alpha/isa/pal.isa:
cpu/base_dyn_inst.cc:
    Untemplatized StaticInstPtr
arch/alpha/isa_traits.hh:
    Changed variables to be externs instead of static since they are part of a namespace and not a class.
arch/alpha/stacktrace.cc:
    Untemplatized StaticInstPtr, and added a using directive for AlphaISA.
arch/alpha/stacktrace.hh:
    Added some typedefs for Addr and MachInst, and untemplatized StaticInstPtr
arch/alpha/vtophys.cc:
    Added a using directive for AlphaISA
arch/alpha/vtophys.hh:
    Added the AlphaISA namespace specifier where needed
arch/isa_parser.py:
    Changed the placement of the definition of the decodeInst function to be outside the namespaceInst namespace.
base/loader/object_file.hh:
cpu/o3/bpred_unit.hh:
    Added a typedef for Addr
base/loader/symtab.hh:
    Added a typedef for Addr, and added a TheISA to Addr in another typedef
base/remote_gdb.cc:
    Added a using namespace TheISA, and untemplatized StaticInstPtr
base/remote_gdb.hh:
    Added typedefs for Addr and MachInst
cpu/base.cc:
    Added TheISA specifier to some variables exported from the isa.
cpu/base.hh:
    Added a typedef for Addr, and TheISA to some variables from the ISA
cpu/base_dyn_inst.hh:
    Untemplatized StaticInstPtr, and added TheISA specifier to some variables from the ISA.
cpu/exec_context.hh:
    Added some typedefs for types from the isa, and added TheISA specifier to some variables from the isa
cpu/exetrace.hh:
    Added typedefs for some types from the ISA, and untemplatized StaticInstPtr
cpu/memtest/memtest.cc:
cpu/o3/btb.cc:
dev/baddev.cc:
dev/ide_ctrl.cc:
dev/ide_disk.cc:
dev/isa_fake.cc:
dev/ns_gige.cc:
dev/pciconfigall.cc:
dev/platform.cc:
dev/sinic.cc:
dev/uart8250.cc:
kern/freebsd/freebsd_system.cc:
kern/linux/linux_system.cc:
kern/system_events.cc:
kern/tru64/dump_mbuf.cc:
kern/tru64/tru64_events.cc:
sim/process.cc:
sim/pseudo_inst.cc:
sim/system.cc:
    Added using namespace TheISA
cpu/memtest/memtest.hh:
cpu/trace/opt_cpu.hh:
cpu/trace/reader/itx_reader.hh:
dev/ide_disk.hh:
dev/pcidev.hh:
dev/platform.hh:
dev/tsunami.hh:
sim/system.hh:
sim/vptr.hh:
    Added typedef for Addr
cpu/o3/2bit_local_pred.hh:
    Changed the include to use arch/isa_traits.hh instead of arch/alpha/isa_traits.hh. Added typedef for Addr
cpu/o3/alpha_cpu.hh:
    Added typedefs for Addr and IntReg
cpu/o3/alpha_cpu_impl.hh:
    Added this-> to setNextPC to fix a problem since it didn't depend on template parameters any more. Removed "typename" where it was no longer needed.
cpu/o3/alpha_dyn_inst.hh:
    Cleaned up some typedefs, and untemplatized StaticInst
cpu/o3/alpha_dyn_inst_impl.hh:
    untemplatized StaticInstPtr
cpu/o3/alpha_impl.hh:
    Fixed up a typedef of MachInst
cpu/o3/bpred_unit_impl.hh:
    Added a using TheISA::MachInst to a function
cpu/o3/btb.hh:
    Changed an include from arch/alpha/isa_traits.hh to arch/isa_traits.hh, and added a typedef for Addr
cpu/o3/commit.hh:
    Removed a typedef of Impl::ISA as ISA, since TheISA takes care of this now.
cpu/o3/cpu.cc:
    Cleaned up namespace issues
cpu/o3/cpu.hh:
    Cleaned up namespace usage
cpu/o3/decode.hh:
    Removed typedef of ISA, and changed it to TheISA
cpu/o3/fetch.hh:
    Fized up typedefs, and changed ISA to TheISA
cpu/o3/free_list.hh:
    Changed include of arch/alpha/isa_traits.hh to arch/isa_traits.hh
cpu/o3/iew.hh:
    Removed typedef of ISA
cpu/o3/iew_impl.hh:
    Added TheISA namespace specifier to MachInst
cpu/o3/ras.hh:
    Changed include from arch/alpha/isa_traits.hh to arch/isa_traits.hh, and added a typedef for Addr.
cpu/o3/regfile.hh:
    Changed ISA to TheISA, and added some typedefs for Addr, IntReg, FloatReg, and MiscRegFile
cpu/o3/rename.hh:
    Changed ISA to TheISA, and added a typedef for RegIndex
cpu/o3/rename_map.hh:
    Added an include for arch/isa_traits.hh, and a typedef for RegIndex
cpu/o3/rob.hh:
    Added a typedef for RegIndex
cpu/o3/store_set.hh:
cpu/o3/tournament_pred.hh:
    Changed an include of arch/alpha/isa_traits.hh to arch/isa_traits.hh, and added a typedef of Addr
cpu/ozone/cpu.hh:
    Changed ISA into TheISA, and untemplatized StaticInst
cpu/pc_event.cc:
    Added namespace specifier TheISA to Addr types
cpu/profile.hh:
kern/kernel_stats.hh:
    Added typedef for Addr, and untemplatized StaticInstPtr
cpu/simple/cpu.cc:
    Changed using directive from LittleEndianGuest to AlphaISA, which will contain both namespaces. Added TheISA where needed, and untemplatized StaticInst
cpu/simple/cpu.hh:
    Added a typedef for MachInst, and untemplatized StaticInst
cpu/static_inst.cc:
    Untemplatized StaticInst
cpu/static_inst.hh:
    Untemplatized StaticInst by using the TheISA namespace
dev/alpha_console.cc:
    Added using namespace AlphaISA
dev/simple_disk.hh:
    Added typedef for Addr and fixed up some formatting
dev/sinicreg.hh:
    Added TheISA namespace specifier where needed
dev/tsunami.cc:
dev/tsunami_io.cc:
dev/tsunami_pchip.cc:
    Added using namespace TheISA. It might be better for it to be AlphaISA
dev/tsunami_cchip.cc:
    Added typedef for TheISA. It might be better for it to be AlphaISA
kern/linux/aligned.hh:
sim/pseudo_inst.hh:
    Added TheISA namespace specifier to Addr
kern/linux/linux_threadinfo.hh:
    Added typedef for Addr, and TheISA namespace specifier to StackPointerReg
kern/tru64/mbuf.hh:
    Added TheISA to Addr type in structs
sim/process.hh:
    Added typedefs of Addr, RegFile, and MachInst
sim/syscall_emul.cc:
    Added using namespace TheISA, and a cast of VMPageSize to the int type
sim/syscall_emul.hh:
    Added typecast for Addr, and TheISA namespace specifier for where needed

--HG--
extra : convert_revision : 91d4f6ca33a73b21c1f1771d74bfdea3b80eff45

101 files changed:
arch/alpha/alpha_linux_process.cc
arch/alpha/alpha_memory.hh
arch/alpha/alpha_tru64_process.cc
arch/alpha/arguments.cc
arch/alpha/ev5.hh
arch/alpha/faults.hh
arch/alpha/isa/branch.isa
arch/alpha/isa/main.isa
arch/alpha/isa/mem.isa
arch/alpha/isa/pal.isa
arch/alpha/isa_traits.hh
arch/alpha/stacktrace.cc
arch/alpha/stacktrace.hh
arch/alpha/vtophys.cc
arch/alpha/vtophys.hh
arch/isa_parser.py
base/loader/object_file.hh
base/loader/symtab.hh
base/remote_gdb.cc
base/remote_gdb.hh
cpu/base.cc
cpu/base.hh
cpu/base_dyn_inst.cc
cpu/base_dyn_inst.hh
cpu/exec_context.hh
cpu/exetrace.hh
cpu/memtest/memtest.cc
cpu/memtest/memtest.hh
cpu/o3/2bit_local_pred.hh
cpu/o3/alpha_cpu.hh
cpu/o3/alpha_cpu_impl.hh
cpu/o3/alpha_dyn_inst.hh
cpu/o3/alpha_dyn_inst_impl.hh
cpu/o3/alpha_impl.hh
cpu/o3/bpred_unit.hh
cpu/o3/bpred_unit_impl.hh
cpu/o3/btb.cc
cpu/o3/btb.hh
cpu/o3/commit.hh
cpu/o3/cpu.cc
cpu/o3/cpu.hh
cpu/o3/decode.hh
cpu/o3/fetch.hh
cpu/o3/free_list.hh
cpu/o3/iew.hh
cpu/o3/iew_impl.hh
cpu/o3/ras.hh
cpu/o3/regfile.hh
cpu/o3/rename.hh
cpu/o3/rename_map.hh
cpu/o3/rob.hh
cpu/o3/store_set.hh
cpu/o3/tournament_pred.hh
cpu/ozone/cpu.hh
cpu/pc_event.cc
cpu/pc_event.hh
cpu/profile.hh
cpu/simple/cpu.cc
cpu/simple/cpu.hh
cpu/static_inst.cc
cpu/static_inst.hh
cpu/trace/opt_cpu.hh
cpu/trace/reader/itx_reader.hh
dev/alpha_console.cc
dev/baddev.cc
dev/ide_ctrl.cc
dev/ide_disk.cc
dev/ide_disk.hh
dev/isa_fake.cc
dev/ns_gige.cc
dev/pciconfigall.cc
dev/pcidev.hh
dev/platform.cc
dev/platform.hh
dev/simple_disk.hh
dev/sinic.cc
dev/sinicreg.hh
dev/tsunami.cc
dev/tsunami.hh
dev/tsunami_cchip.cc
dev/tsunami_io.cc
dev/tsunami_pchip.cc
dev/uart8250.cc
kern/freebsd/freebsd_system.cc
kern/kernel_stats.hh
kern/linux/aligned.hh
kern/linux/linux_system.cc
kern/linux/linux_threadinfo.hh
kern/system_events.cc
kern/tru64/dump_mbuf.cc
kern/tru64/mbuf.hh
kern/tru64/tru64_events.cc
sim/process.cc
sim/process.hh
sim/pseudo_inst.cc
sim/pseudo_inst.hh
sim/syscall_emul.cc
sim/syscall_emul.hh
sim/system.cc
sim/system.hh
sim/vptr.hh

index fb5e32e63e9601c0b81572077fc91f37261a5c4f..af4df7c30422138fc40cd06336f28bfe39e59e91 100644 (file)
@@ -52,6 +52,7 @@
 #include "base/trace.hh"
 
 using namespace std;
+using namespace AlphaISA;
 
 ///
 /// This class encapsulates the types, structures, constants,
index 849063f596fb2f7991bbdbae937212edc74c52f3..b39a1ef26953975aaeb6470140b153574823f576 100644 (file)
@@ -42,6 +42,7 @@ class ExecContext;
 class AlphaTLB : public SimObject
 {
   protected:
+    typedef TheISA::Addr Addr;
     typedef std::multimap<Addr, int> PageTable;
     PageTable lookupTable;     // Quick lookup into page table
 
@@ -82,6 +83,7 @@ class AlphaTLB : public SimObject
 class AlphaITB : public AlphaTLB
 {
   protected:
+    typedef TheISA::Addr Addr;
     mutable Stats::Scalar<> hits;
     mutable Stats::Scalar<> misses;
     mutable Stats::Scalar<> acv;
index 5c24adad91c8e0fd9fb7a3e4af77f21b6da8d0b1..49e672203d426027f34c0fd8c1b936eeae660236 100644 (file)
@@ -55,6 +55,7 @@
 #include "sim/syscall_emul.hh"
 
 using namespace std;
+using namespace AlphaISA;
 
 typedef struct stat global_stat;
 typedef struct statfs global_statfs;
index a340a2053cf44d6e03fe42381730b40ce7e08682..4e8190cbc9ed6e3242ff4c42e23483e8bb18dd23 100644 (file)
@@ -31,6 +31,8 @@
 #include "cpu/exec_context.hh"
 #include "mem/functional/physical.hh"
 
+using namespace AlphaISA;
+
 AlphaArguments::Data::~Data()
 {
     while (!data.empty()) {
index 5173b364fb9894ffe98a6d71ae0bd0df74085c2c..7c8465cfbb3fd9cdd5750b6d013f308852e662a9 100644 (file)
 #define __ARCH_ALPHA_EV5_HH__
 
 #include "config/alpha_tlaser.hh"
+#include "arch/alpha/isa_traits.hh"
 
 namespace EV5 {
 
+//It seems like a safe assumption EV5 only applies to alpha
+using namespace AlphaISA;
+
 #if ALPHA_TLASER
 const uint64_t AsnMask = ULL(0x7f);
 #else
index 2bb929a1e67ce66b5e6f7cf72ca77fbafbac2b53..8c281593af1513cacb0b7c4ee2932c937efc7837 100644 (file)
 
 class AlphaFault : public Fault
 {
-public:
-        AlphaFault(char * newName, int newId, Addr newVect) : Fault(newName, newId), vect(newVect) {;}
-        TheISA::Addr vect;
+  protected:
+    typedef TheISA::Addr Addr;
+  public:
+    AlphaFault(char * newName, int newId, Addr newVect) :
+        Fault(newName, newId), vect(newVect)
+    {;}
+    Addr vect;
 };
 
 extern class ResetFaultType : public AlphaFault
 {
 public:
-        ResetFaultType(char * newName, int newId, Addr newVect) : AlphaFault(newName, newId, newVect) {;}
+        ResetFaultType(char * newName, int newId, Addr newVect) :
+            AlphaFault(newName, newId, newVect)
+        {;}
 } * ResetFault;
 
 extern class ArithmeticFaultType : public AlphaFault
index e9c790c53b1d902132bb9e20af1684b3359a391a..cc6fd1a09ed7463bdb90e5ac729f8a4f698dca26 100644 (file)
@@ -39,6 +39,8 @@ output header {{
      */
     class PCDependentDisassembly : public AlphaStaticInst
     {
+      protected:
+        typedef TheISA::Addr Addr;
       protected:
         /// Cached program counter from last disassembly
         mutable Addr cachedPC;
@@ -64,6 +66,7 @@ output header {{
     class Branch : public PCDependentDisassembly
     {
       protected:
+        typedef TheISA::Addr Addr;
         /// Displacement to target address (signed).
         int32_t disp;
 
@@ -87,6 +90,7 @@ output header {{
     class Jump : public PCDependentDisassembly
     {
       protected:
+        typedef TheISA::Addr Addr;
 
         /// Displacement to target address (signed).
         int32_t disp;
@@ -205,8 +209,8 @@ output decoder {{
 
 def template JumpOrBranchDecode {{
     return (RA == 31)
-        ? (StaticInst<AlphaISA> *)new %(class_name)s(machInst)
-        : (StaticInst<AlphaISA> *)new %(class_name)sAndLink(machInst);
+        ? (StaticInst *)new %(class_name)s(machInst)
+        : (StaticInst *)new %(class_name)sAndLink(machInst);
 }};
 
 def format CondBranch(code) {{
index 42fb294040a857c9d40847818bd3e1fb5be4e7d3..862b2b95ef21c07de71ac4401baeafa71c358299 100644 (file)
@@ -45,6 +45,8 @@ output decoder {{
 #include "cpu/exec_context.hh"  // for Jump::branchTarget()
 
 #include <math.h>
+
+using namespace AlphaISA;
 }};
 
 output exec {{
@@ -58,6 +60,8 @@ output exec {{
 #include "cpu/base.hh"
 #include "cpu/exetrace.hh"
 #include "sim/sim_exit.hh"
+
+using namespace AlphaISA;
 }};
 
 ////////////////////////////////////////////////////////////////////
@@ -179,7 +183,7 @@ output header {{
     /**
      * Base class for all Alpha static instructions.
      */
-    class AlphaStaticInst : public StaticInst<AlphaISA>
+    class AlphaStaticInst : public StaticInst
     {
       protected:
 
@@ -196,7 +200,7 @@ output header {{
         /// Constructor.
         AlphaStaticInst(const char *mnem, MachInst _machInst,
                         OpClass __opClass)
-            : StaticInst<AlphaISA>(mnem, _machInst, __opClass)
+            : StaticInst(mnem, _machInst, __opClass)
         {
         }
 
@@ -352,6 +356,17 @@ output header {{
 
         %(BasicExecDeclare)s
     };
+
+    /// Helper function for decoding nops.  Substitute Nop object
+    /// for original inst passed in as arg (and delete latter).
+    static inline
+    AlphaStaticInst *
+    makeNop(AlphaStaticInst *inst)
+    {
+        AlphaStaticInst *nop = new Nop(inst->disassemble(0), inst->machInst);
+        delete inst;
+        return nop;
+    }
 }};
 
 output decoder {{
@@ -364,17 +379,6 @@ output decoder {{
         return csprintf("%-10s (%s)", "nop", originalDisassembly);
 #endif
     }
-
-    /// Helper function for decoding nops.  Substitute Nop object
-    /// for original inst passed in as arg (and delete latter).
-    inline
-    AlphaStaticInst *
-    makeNop(AlphaStaticInst *inst)
-    {
-        AlphaStaticInst *nop = new Nop(inst->disassemble(0), inst->machInst);
-        delete inst;
-        return nop;
-    }
 }};
 
 output exec {{
index 0b79bc3765845872ac12af5198d771a98a3f7e02..c72806263b704d78f8bf3bdefaeee9d670ee5d0c 100644 (file)
@@ -37,14 +37,14 @@ output header {{
         /// Memory request flags.  See mem_req_base.hh.
         unsigned memAccessFlags;
         /// Pointer to EAComp object.
-        const StaticInstPtr<AlphaISA> eaCompPtr;
+        const StaticInstPtr eaCompPtr;
         /// Pointer to MemAcc object.
-        const StaticInstPtr<AlphaISA> memAccPtr;
+        const StaticInstPtr memAccPtr;
 
         /// Constructor
         Memory(const char *mnem, MachInst _machInst, OpClass __opClass,
-               StaticInstPtr<AlphaISA> _eaCompPtr = nullStaticInstPtr,
-               StaticInstPtr<AlphaISA> _memAccPtr = nullStaticInstPtr)
+               StaticInstPtr _eaCompPtr = nullStaticInstPtr,
+               StaticInstPtr _memAccPtr = nullStaticInstPtr)
             : AlphaStaticInst(mnem, _machInst, __opClass),
               memAccessFlags(0), eaCompPtr(_eaCompPtr), memAccPtr(_memAccPtr)
         {
@@ -55,8 +55,8 @@ output header {{
 
       public:
 
-        const StaticInstPtr<AlphaISA> &eaCompInst() const { return eaCompPtr; }
-        const StaticInstPtr<AlphaISA> &memAccInst() const { return memAccPtr; }
+        const StaticInstPtr &eaCompInst() const { return eaCompPtr; }
+        const StaticInstPtr &memAccInst() const { return memAccPtr; }
     };
 
     /**
@@ -71,8 +71,8 @@ output header {{
 
         /// Constructor.
         MemoryDisp32(const char *mnem, MachInst _machInst, OpClass __opClass,
-                     StaticInstPtr<AlphaISA> _eaCompPtr = nullStaticInstPtr,
-                     StaticInstPtr<AlphaISA> _memAccPtr = nullStaticInstPtr)
+                     StaticInstPtr _eaCompPtr = nullStaticInstPtr,
+                     StaticInstPtr _memAccPtr = nullStaticInstPtr)
             : Memory(mnem, _machInst, __opClass, _eaCompPtr, _memAccPtr),
               disp(MEMDISP)
         {
@@ -90,8 +90,8 @@ output header {{
       protected:
         /// Constructor
         MemoryNoDisp(const char *mnem, MachInst _machInst, OpClass __opClass,
-                     StaticInstPtr<AlphaISA> _eaCompPtr = nullStaticInstPtr,
-                     StaticInstPtr<AlphaISA> _memAccPtr = nullStaticInstPtr)
+                     StaticInstPtr _eaCompPtr = nullStaticInstPtr,
+                     StaticInstPtr _memAccPtr = nullStaticInstPtr)
             : Memory(mnem, _machInst, __opClass, _eaCompPtr, _memAccPtr)
         {
         }
index b68a7c19fcfdc83abec5a98a2d5050a0834bd79b..49e5bff12fc7bc399964f4c2336868187f44c371 100644 (file)
@@ -149,8 +149,8 @@ output header {{
 
         /// Constructor
         HwLoadStore(const char *mnem, MachInst _machInst, OpClass __opClass,
-                    StaticInstPtr<AlphaISA> _eaCompPtr = nullStaticInstPtr,
-                    StaticInstPtr<AlphaISA> _memAccPtr = nullStaticInstPtr);
+                    StaticInstPtr _eaCompPtr = nullStaticInstPtr,
+                    StaticInstPtr _memAccPtr = nullStaticInstPtr);
 
         std::string
         generateDisassembly(Addr pc, const SymbolTable *symtab) const;
@@ -162,8 +162,8 @@ output decoder {{
     inline
     HwLoadStore::HwLoadStore(const char *mnem, MachInst _machInst,
                              OpClass __opClass,
-                             StaticInstPtr<AlphaISA> _eaCompPtr,
-                             StaticInstPtr<AlphaISA> _memAccPtr)
+                             StaticInstPtr _eaCompPtr,
+                             StaticInstPtr _memAccPtr)
         : Memory(mnem, _machInst, __opClass, _eaCompPtr, _memAccPtr),
         disp(HW_LDST_DISP)
     {
index a6e34acbb59760f82dded3a646c02d9d9fc5ad73..2da37b2e01a43a9e90df0e844a3a8defee32d542 100644 (file)
@@ -44,17 +44,16 @@ class Checkpoint;
 
 #define TARGET_ALPHA
 
-template <class ISA> class StaticInst;
-template <class ISA> class StaticInstPtr;
+class StaticInst;
+class StaticInstPtr;
 
 namespace EV5 {
 int DTB_ASN_ASN(uint64_t reg);
 int ITB_ASN_ASN(uint64_t reg);
 }
 
-class AlphaISA
+namespace AlphaISA
 {
-  public:
 
     typedef uint32_t MachInst;
     typedef uint64_t Addr;
@@ -133,10 +132,10 @@ class AlphaISA
         Addr           lock_addr;      // lock address for LL/SC
     } MiscRegFile;
 
-static const Addr PageShift = 13;
-static const Addr PageBytes = ULL(1) << PageShift;
-static const Addr PageMask = ~(PageBytes - 1);
-static const Addr PageOffset = PageBytes - 1;
+extern const Addr PageShift;
+extern const Addr PageBytes;
+extern const Addr PageMask;
+extern const Addr PageOffset;
 
 #if FULL_SYSTEM
 
@@ -184,10 +183,10 @@ static const Addr PageOffset = PageBytes - 1;
         void unserialize(Checkpoint *cp, const std::string &section);
     };
 
-    static StaticInstPtr<AlphaISA> decodeInst(MachInst);
+    StaticInstPtr decodeInst(MachInst);
 
     // return a no-op instruction... used for instruction fetch faults
-    static const MachInst NoopMachInst;
+    extern const MachInst NoopMachInst;
 
     enum annotes {
         ANNOTE_NONE = 0,
@@ -242,10 +241,10 @@ static const Addr PageOffset = PageBytes - 1;
 
     // Machine operations
 
-    static void saveMachineReg(AnyReg &savereg, const RegFile &reg_file,
+    void saveMachineReg(AnyReg &savereg, const RegFile &reg_file,
                                int regnum);
 
-    static void restoreMachineReg(RegFile &regs, const AnyReg &reg,
+    void restoreMachineReg(RegFile &regs, const AnyReg &reg,
                                   int regnum);
 
 #if 0
@@ -263,41 +262,41 @@ static const Addr PageOffset = PageBytes - 1;
      * @param xc The execution context.
      */
     template <class XC>
-    static void zeroRegisters(XC *xc);
+    void zeroRegisters(XC *xc);
+
+
+//typedef AlphaISA TheISA;
+
+//typedef TheISA::MachInst MachInst;
+//typedef TheISA::Addr Addr;
+//typedef TheISA::RegIndex RegIndex;
+//typedef TheISA::IntReg IntReg;
+//typedef TheISA::IntRegFile IntRegFile;
+//typedef TheISA::FloatReg FloatReg;
+//typedef TheISA::FloatRegFile FloatRegFile;
+//typedef TheISA::MiscReg MiscReg;
+//typedef TheISA::MiscRegFile MiscRegFile;
+//typedef TheISA::AnyReg AnyReg;
+//typedef TheISA::RegFile RegFile;
+
+//const int NumIntRegs   = TheISA::NumIntRegs;
+//const int NumFloatRegs = TheISA::NumFloatRegs;
+//const int NumMiscRegs  = TheISA::NumMiscRegs;
+//const int TotalNumRegs = TheISA::TotalNumRegs;
+//const int VMPageSize   = TheISA::VMPageSize;
+//const int LogVMPageSize   = TheISA::LogVMPageSize;
+//const int ZeroReg = TheISA::ZeroReg;
+//const int StackPointerReg = TheISA::StackPointerReg;
+//const int GlobalPointerReg = TheISA::GlobalPointerReg;
+//const int ReturnAddressReg = TheISA::ReturnAddressReg;
+//const int ReturnValueReg = TheISA::ReturnValueReg;
+//const int ArgumentReg0 = TheISA::ArgumentReg0;
+//const int ArgumentReg1 = TheISA::ArgumentReg1;
+//const int ArgumentReg2 = TheISA::ArgumentReg2;
+//const int BranchPredAddrShiftAmt = TheISA::BranchPredAddrShiftAmt;
+const Addr MaxAddr = (Addr)-1;
 };
 
-
-typedef AlphaISA TheISA;
-
-typedef TheISA::MachInst MachInst;
-typedef TheISA::Addr Addr;
-typedef TheISA::RegIndex RegIndex;
-typedef TheISA::IntReg IntReg;
-typedef TheISA::IntRegFile IntRegFile;
-typedef TheISA::FloatReg FloatReg;
-typedef TheISA::FloatRegFile FloatRegFile;
-typedef TheISA::MiscReg MiscReg;
-typedef TheISA::MiscRegFile MiscRegFile;
-typedef TheISA::AnyReg AnyReg;
-typedef TheISA::RegFile RegFile;
-
-const int NumIntRegs   = TheISA::NumIntRegs;
-const int NumFloatRegs = TheISA::NumFloatRegs;
-const int NumMiscRegs  = TheISA::NumMiscRegs;
-const int TotalNumRegs = TheISA::TotalNumRegs;
-const int VMPageSize   = TheISA::VMPageSize;
-const int LogVMPageSize   = TheISA::LogVMPageSize;
-const int ZeroReg = TheISA::ZeroReg;
-const int StackPointerReg = TheISA::StackPointerReg;
-const int GlobalPointerReg = TheISA::GlobalPointerReg;
-const int ReturnAddressReg = TheISA::ReturnAddressReg;
-const int ReturnValueReg = TheISA::ReturnValueReg;
-const int ArgumentReg0 = TheISA::ArgumentReg0;
-const int ArgumentReg1 = TheISA::ArgumentReg1;
-const int ArgumentReg2 = TheISA::ArgumentReg2;
-const int BranchPredAddrShiftAmt = TheISA::BranchPredAddrShiftAmt;
-const int MaxAddr = (Addr)-1;
-
 #if !FULL_SYSTEM
 class SyscallReturn {
         public:
@@ -336,9 +335,9 @@ class SyscallReturn {
 
 
 #if FULL_SYSTEM
-typedef TheISA::InternalProcReg InternalProcReg;
-const int NumInternalProcRegs  = TheISA::NumInternalProcRegs;
-const int NumInterruptLevels = TheISA::NumInterruptLevels;
+//typedef TheISA::InternalProcReg InternalProcReg;
+//const int NumInternalProcRegs  = TheISA::NumInternalProcRegs;
+//const int NumInterruptLevels = TheISA::NumInterruptLevels;
 
 #include "arch/alpha/ev5.hh"
 #endif
index 5a8df3d353e0434c9bceccb872b03dff89901149..30ed07d9dfe71fe4e0ebca96f2560f3811d787f3 100644 (file)
@@ -37,6 +37,7 @@
 #include "cpu/exec_context.hh"
 
 using namespace std;
+using namespace AlphaISA;
 
 ProcessInfo::ProcessInfo(ExecContext *_xc)
     : xc(_xc)
@@ -108,7 +109,7 @@ StackTrace::StackTrace()
 {
 }
 
-StackTrace::StackTrace(ExecContext *_xc, StaticInstPtr<TheISA> inst)
+StackTrace::StackTrace(ExecContext *_xc, StaticInstPtr inst)
     : xc(0), stack(64)
 {
     trace(_xc, inst);
index 244e574b6261c310a94a469d3fb891a1f408d8e7..211909060fafbeae699d20987fd9dada14b05d11 100644 (file)
@@ -37,6 +37,8 @@ class StackTrace;
 
 class ProcessInfo
 {
+  protected:
+    typedef TheISA::Addr Addr;
   private:
     ExecContext *xc;
 
@@ -56,6 +58,9 @@ class ProcessInfo
 
 class StackTrace
 {
+  protected:
+    typedef TheISA::Addr Addr;
+    typedef TheISA::MachInst MachInst;
   private:
     ExecContext *xc;
     std::vector<Addr> stack;
@@ -70,7 +75,7 @@ class StackTrace
 
   public:
     StackTrace();
-    StackTrace(ExecContext *xc, StaticInstPtr<TheISA> inst);
+    StackTrace(ExecContext *xc, StaticInstPtr inst);
     ~StackTrace();
 
     void clear()
@@ -80,7 +85,7 @@ class StackTrace
     }
 
     bool valid() const { return xc != NULL; }
-    bool trace(ExecContext *xc, StaticInstPtr<TheISA> inst);
+    bool trace(ExecContext *xc, StaticInstPtr inst);
 
   public:
     const std::vector<Addr> &getstack() const { return stack; }
@@ -102,7 +107,7 @@ class StackTrace
 };
 
 inline bool
-StackTrace::trace(ExecContext *xc, StaticInstPtr<TheISA> inst)
+StackTrace::trace(ExecContext *xc, StaticInstPtr inst)
 {
     if (!inst->isCall() && !inst->isReturn())
         return false;
index 27014164c30a1edd47ba883fa40c70b2c24a3ad0..3ffa4bd14bb941b6337c148d37769445e8b33eeb 100644 (file)
@@ -34,6 +34,7 @@
 #include "mem/functional/physical.hh"
 
 using namespace std;
+using namespace AlphaISA;
 
 AlphaISA::PageTableEntry
 kernel_pte_lookup(PhysicalMemory *pmem, Addr ptbr, AlphaISA::VAddr vaddr)
index 95430ce772994299bb25f37d7a52dfacb7ad1ce0..988f050ba16bb6f4764de999fe31f110b6b86320 100644 (file)
@@ -35,16 +35,16 @@ class ExecContext;
 class PhysicalMemory;
 
 AlphaISA::PageTableEntry
-kernel_pte_lookup(PhysicalMemory *pmem, Addr ptbr, AlphaISA::VAddr vaddr);
+kernel_pte_lookup(PhysicalMemory *pmem, AlphaISA::Addr ptbr, AlphaISA::VAddr vaddr);
 
-Addr vtophys(PhysicalMemory *xc, Addr vaddr);
-Addr vtophys(ExecContext *xc, Addr vaddr);
-uint8_t *vtomem(ExecContext *xc, Addr vaddr, size_t len);
-uint8_t *ptomem(ExecContext *xc, Addr paddr, size_t len);
+AlphaISA::Addr vtophys(PhysicalMemory *xc, AlphaISA::Addr vaddr);
+AlphaISA::Addr vtophys(ExecContext *xc, AlphaISA::Addr vaddr);
+uint8_t *vtomem(ExecContext *xc, AlphaISA::Addr vaddr, size_t len);
+uint8_t *ptomem(ExecContext *xc, AlphaISA::Addr paddr, size_t len);
 
-void CopyOut(ExecContext *xc, void *dst, Addr src, size_t len);
-void CopyIn(ExecContext *xc, Addr dst, void *src, size_t len);
-void CopyString(ExecContext *xc, char *dst, Addr vaddr, size_t maxlen);
+void CopyOut(ExecContext *xc, void *dst, AlphaISA::Addr src, size_t len);
+void CopyIn(ExecContext *xc, AlphaISA::Addr dst, void *src, size_t len);
+void CopyString(ExecContext *xc, char *dst, AlphaISA::Addr vaddr, size_t maxlen);
 
 #endif // __ARCH_ALPHA_VTOPHYS_H__
 
index 96d3e84382e8f3d5d88759afc9d2ae4f6c420623..3fbb5276b2c5ad9e80121972b49eb40784d766fe 100755 (executable)
@@ -224,7 +224,7 @@ def p_specification(t):
     namespace = isa_name + "Inst"
     # wrap the decode block as a function definition
     t[4].wrap_decode_block('''
-StaticInstPtr<%(isa_name)s>
+StaticInstPtr
 %(isa_name)s::decodeInst(%(isa_name)s::MachInst machInst)
 {
     using namespace %(namespace)s;
@@ -1690,6 +1690,8 @@ namespace %(namespace)s {
 %(namespace_output)s
 
 } // namespace %(namespace)s
+
+%(decode_function)s
 '''
 
 
@@ -1769,13 +1771,15 @@ def parse_isa_desc(isa_desc_file, output_dir, include_path):
     includes = '#include "base/bitfield.hh" // for bitfield support'
     global_output = global_code.header_output
     namespace_output = namespace_code.header_output
+    decode_function = ''
     update_if_needed(output_dir + '/decoder.hh', file_template % vars())
 
     # generate decoder.cc
     includes = '#include "%s/decoder.hh"' % include_path
     global_output = global_code.decoder_output
     namespace_output = namespace_code.decoder_output
-    namespace_output += namespace_code.decode_block
+    # namespace_output += namespace_code.decode_block
+    decode_function = namespace_code.decode_block
     update_if_needed(output_dir + '/decoder.cc', file_template % vars())
 
     # generate per-cpu exec files
@@ -1784,6 +1788,7 @@ def parse_isa_desc(isa_desc_file, output_dir, include_path):
         includes += cpu.includes
         global_output = global_code.exec_output[cpu.name]
         namespace_output = namespace_code.exec_output[cpu.name]
+        decode_function = ''
         update_if_needed(output_dir + '/' + cpu.filename,
                           file_template % vars())
 
index 3c8659e184dc6bde0efd198856e664111b5dd6a2..e90f93847666e0754c6ad3e8c62067511b1fc9fe 100644 (file)
@@ -37,6 +37,7 @@ class SymbolTable;
 class ObjectFile
 {
   public:
+    typedef TheISA::Addr Addr;
 
     enum Arch {
         UnknownArch,
index ebcda1345c1bf80ad418fa348f0665f750d7f414..38b4cdee21a0c0acd8b3274bad9780dfdef4cac3 100644 (file)
@@ -37,8 +37,9 @@
 class Checkpoint;
 class SymbolTable
 {
+    typedef TheISA::Addr Addr;
   public:
-    typedef std::map<Addr, std::string> ATable;
+    typedef std::map<TheISA::Addr, std::string> ATable;
     typedef std::map<std::string, Addr> STable;
 
   private:
index 67d745d437305fe84c896c68ed5e863b8952c3b8..17ec21fed5286084c29a0698d9015b59332dd586 100644 (file)
 #include "targetarch/vtophys.hh"
 
 using namespace std;
+using namespace TheISA;
 
 #ifndef NDEBUG
 vector<RemoteGDB *> debuggers;
@@ -494,7 +495,7 @@ RemoteGDB::setSingleStep()
     // User was stopped at pc, e.g. the instruction at pc was not
     // executed.
     MachInst inst = read<MachInst>(pc);
-    StaticInstPtr<TheISA> si(inst);
+    StaticInstPtr si(inst);
     if (si->hasBranchTarget(pc, context, bpc)) {
         // Don't bother setting a breakpoint on the taken branch if it
         // is the same as the next pc
index 652a58317d91b79665895b8f7984d6ddcab648cc..126d5f6f80444087e6048e4bca35eb8f94cbcb77 100644 (file)
@@ -43,6 +43,9 @@ class PhysicalMemory;
 class GDBListener;
 class RemoteGDB
 {
+  protected:
+    typedef TheISA::Addr Addr;
+    typedef TheISA::MachInst MachInst;
   private:
     friend void debugger();
     friend class GDBListener;
index 8b94b85332a7c2177ac3b750bc87adf22a9f9ad8..5a7ecf152686af934836360331029498b380eaa1 100644 (file)
@@ -250,7 +250,7 @@ BaseCPU::takeOverFrom(BaseCPU *oldCPU)
     }
 
 #if FULL_SYSTEM
-    for (int i = 0; i < NumInterruptLevels; ++i)
+    for (int i = 0; i < TheISA::NumInterruptLevels; ++i)
         interrupts[i] = oldCPU->interrupts[i];
     intstatus = oldCPU->intstatus;
 
@@ -285,7 +285,7 @@ BaseCPU::post_interrupt(int int_num, int index)
 {
     DPRINTF(Interrupt, "Interrupt %d:%d posted\n", int_num, index);
 
-    if (int_num < 0 || int_num >= NumInterruptLevels)
+    if (int_num < 0 || int_num >= TheISA::NumInterruptLevels)
         panic("int_num out of bounds\n");
 
     if (index < 0 || index >= sizeof(uint64_t) * 8)
@@ -301,7 +301,7 @@ BaseCPU::clear_interrupt(int int_num, int index)
 {
     DPRINTF(Interrupt, "Interrupt %d:%d cleared\n", int_num, index);
 
-    if (int_num < 0 || int_num >= NumInterruptLevels)
+    if (int_num < 0 || int_num >= TheISA::NumInterruptLevels)
         panic("int_num out of bounds\n");
 
     if (index < 0 || index >= sizeof(uint64_t) * 8)
@@ -325,14 +325,14 @@ BaseCPU::clear_interrupts()
 void
 BaseCPU::serialize(std::ostream &os)
 {
-    SERIALIZE_ARRAY(interrupts, NumInterruptLevels);
+    SERIALIZE_ARRAY(interrupts, TheISA::NumInterruptLevels);
     SERIALIZE_SCALAR(intstatus);
 }
 
 void
 BaseCPU::unserialize(Checkpoint *cp, const std::string &section)
 {
-    UNSERIALIZE_ARRAY(interrupts, NumInterruptLevels);
+    UNSERIALIZE_ARRAY(interrupts, TheISA::NumInterruptLevels);
     UNSERIALIZE_SCALAR(intstatus);
 }
 
index 2bd1210d8cc6bba752c1d245a7397822f601324d..ab52e7b81d61742ffb2ca6c3037d10cd584d2236 100644 (file)
@@ -48,6 +48,7 @@ class ExecContext;
 class BaseCPU : public SimObject
 {
   protected:
+    typedef TheISA::Addr Addr;
     // CPU's clock period in terms of the number of ticks of curTime.
     Tick clock;
 
@@ -58,7 +59,7 @@ class BaseCPU : public SimObject
 
 #if FULL_SYSTEM
   protected:
-    uint64_t interrupts[NumInterruptLevels];
+    uint64_t interrupts[TheISA::NumInterruptLevels];
     uint64_t intstatus;
 
   public:
@@ -68,7 +69,7 @@ class BaseCPU : public SimObject
     bool checkInterrupts;
 
     bool check_interrupt(int int_num) const {
-        if (int_num > NumInterruptLevels)
+        if (int_num > TheISA::NumInterruptLevels)
             panic("int_num out of bounds\n");
 
         return interrupts[int_num] != 0;
index 59a12f2d063ba1185afbd5797e502c4782602ee0..9901c90afba62db27773ca75a963f78949c873df 100644 (file)
@@ -79,7 +79,7 @@ BaseDynInst<Impl>::BaseDynInst(MachInst machInst, Addr inst_PC,
 }
 
 template <class Impl>
-BaseDynInst<Impl>::BaseDynInst(StaticInstPtr<ISA> &_staticInst)
+BaseDynInst<Impl>::BaseDynInst(StaticInstPtr &_staticInst)
     : staticInst(_staticInst), traceData(NULL)
 {
     initVars();
index 2c91db99ce57864343442ff2e15e05583d343ca5..dd429fc9152772eb5573ffaf0fc7ceb4740c9d1c 100644 (file)
@@ -51,7 +51,6 @@
  */
 
 // Forward declaration.
-template <class ISA>
 class StaticInstPtr;
 
 template <class Impl>
@@ -61,25 +60,22 @@ class BaseDynInst : public FastAlloc, public RefCounted
     // Typedef for the CPU.
     typedef typename Impl::FullCPU FullCPU;
 
-    //Typedef to get the ISA.
-    typedef typename Impl::ISA ISA;
-
     /// Binary machine instruction type.
-    typedef typename ISA::MachInst MachInst;
+    typedef TheISA::MachInst MachInst;
     /// Memory address type.
-    typedef typename ISA::Addr    Addr;
+    typedef TheISA::Addr Addr;
     /// Logical register index type.
-    typedef typename ISA::RegIndex RegIndex;
+    typedef TheISA::RegIndex RegIndex;
     /// Integer register index type.
-    typedef typename ISA::IntReg   IntReg;
+    typedef TheISA::IntReg IntReg;
 
     enum {
-        MaxInstSrcRegs = ISA::MaxInstSrcRegs,  //< Max source regs
-        MaxInstDestRegs = ISA::MaxInstDestRegs,        //< Max dest regs
+        MaxInstSrcRegs = TheISA::MaxInstSrcRegs,        //< Max source regs
+        MaxInstDestRegs = TheISA::MaxInstDestRegs,      //< Max dest regs
     };
 
     /** The static inst used by this dyn inst. */
-    StaticInstPtr<ISA> staticInst;
+    StaticInstPtr staticInst;
 
     ////////////////////////////////////////////
     //
@@ -214,7 +210,7 @@ class BaseDynInst : public FastAlloc, public RefCounted
                 FullCPU *cpu);
 
     /** BaseDynInst constructor given a static inst pointer. */
-    BaseDynInst(StaticInstPtr<ISA> &_staticInst);
+    BaseDynInst(StaticInstPtr &_staticInst);
 
     /** BaseDynInst destructor. */
     ~BaseDynInst();
index 7e195af2373e4fa8ee30910fc3345d461df31d9d..7e905e7d35aa9f3601e526b98aced36907b6fff0 100644 (file)
@@ -35,6 +35,7 @@
 #include "sim/host.hh"
 #include "sim/serialize.hh"
 #include "arch/isa_traits.hh"
+//#include "arch/isa_registers.hh"
 #include "sim/byteswap.hh"
 
 // forward declaration: see functional_memory.hh
@@ -66,6 +67,11 @@ namespace Kernel { class Binning; class Statistics; }
 
 class ExecContext
 {
+  protected:
+    typedef TheISA::RegFile RegFile;
+    typedef TheISA::Addr Addr;
+    typedef TheISA::MachInst MachInst;
+    typedef TheISA::MiscRegFile MiscRegFile;
   public:
     enum Status
     {
@@ -431,15 +437,15 @@ class ExecContext
     void trap(Fault * fault);
 
 #if !FULL_SYSTEM
-    IntReg getSyscallArg(int i)
+    TheISA::IntReg getSyscallArg(int i)
     {
-        return regs.intRegFile[ArgumentReg0 + i];
+        return regs.intRegFile[TheISA::ArgumentReg0 + i];
     }
 
     // used to shift args for indirect syscall
-    void setSyscallArg(int i, IntReg val)
+    void setSyscallArg(int i, TheISA::IntReg val)
     {
-        regs.intRegFile[ArgumentReg0 + i] = val;
+        regs.intRegFile[TheISA::ArgumentReg0 + i] = val;
     }
 
     void setSyscallReturn(SyscallReturn return_value)
@@ -451,11 +457,11 @@ class ExecContext
         if (return_value.successful()) {
             // no error
             regs.intRegFile[RegA3] = 0;
-            regs.intRegFile[ReturnValueReg] = return_value.value();
+            regs.intRegFile[TheISA::ReturnValueReg] = return_value.value();
         } else {
             // got an error, return details
-            regs.intRegFile[RegA3] = (IntReg) -1;
-            regs.intRegFile[ReturnValueReg] = -return_value.value();
+            regs.intRegFile[RegA3] = (TheISA::IntReg) -1;
+            regs.intRegFile[TheISA::ReturnValueReg] = -return_value.value();
         }
     }
 
index 48d8966d8d44bbfe846ff4c02680d533b07695b7..d37c48ddd9564716552cd757c6c9308fd2300144 100644 (file)
@@ -46,13 +46,15 @@ namespace Trace {
 class InstRecord : public Record
 {
   protected:
+    typedef TheISA::Addr Addr;
+    typedef TheISA::IntRegFile IntRegFile;
 
     // The following fields are initialized by the constructor and
     // thus guaranteed to be valid.
     BaseCPU *cpu;
     // need to make this ref-counted so it doesn't go away before we
     // dump the record
-    StaticInstPtr<TheISA> staticInst;
+    StaticInstPtr staticInst;
     Addr PC;
     bool misspeculating;
     unsigned thread;
@@ -92,7 +94,7 @@ class InstRecord : public Record
 
   public:
     InstRecord(Tick _cycle, BaseCPU *_cpu,
-               const StaticInstPtr<TheISA> &_staticInst,
+               const StaticInstPtr &_staticInst,
                Addr _pc, bool spec, int _thread)
         : Record(_cycle), cpu(_cpu), staticInst(_staticInst), PC(_pc),
           misspeculating(spec), thread(_thread)
@@ -169,8 +171,8 @@ InstRecord::setRegs(const IntRegFile &regs)
 inline
 InstRecord *
 getInstRecord(Tick cycle, ExecContext *xc, BaseCPU *cpu,
-              const StaticInstPtr<TheISA> staticInst,
-              Addr pc, int thread = 0)
+              const StaticInstPtr staticInst,
+              TheISA::Addr pc, int thread = 0)
 {
     if (DTRACE(InstExec) &&
         (InstRecord::traceMisspec() || !xc->misspeculating())) {
index 27f790fac6939fff8ed7f98ee8d24a15bc1e8660..5a402458726cac56a847f301f86698ed026ace69 100644 (file)
@@ -44,6 +44,7 @@
 #include "sim/stats.hh"
 
 using namespace std;
+using namespace TheISA;
 
 int TESTER_ALLOCATOR=0;
 
index 7abcf017a7ea00918d640fdbb7762fcb041bd58c..76a89ff2ced3bb3a7f0e509bee409d7ada1ad4fb 100644 (file)
@@ -42,6 +42,8 @@
 class ExecContext;
 class MemTest : public SimObject
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
 
     MemTest(const std::string &name,
index a97ce455ccafb957cdf8fecac26916771f9d93ec..78efe1e4362c71f8ffc47e54baff1a80752a9aae 100644 (file)
 #define __CPU_O3_CPU_2BIT_LOCAL_PRED_HH__
 
 // For Addr type.
-#include "arch/alpha/isa_traits.hh"
+#include "arch/isa_traits.hh"
 #include "cpu/o3/sat_counter.hh"
 
 class DefaultBP
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     /**
      * Default branch predictor constructor.
index 606f9fa0a33696298d8010a257e3d0c9b0b31cda..bf3556b8e66b8cd5ea4488151af14bed6b67e9a4 100644 (file)
 template <class Impl>
 class AlphaFullCPU : public FullO3CPU<Impl>
 {
+  protected:
+    typedef AlphaISA::Addr Addr;
+    typedef TheISA::IntReg IntReg;
   public:
-    typedef typename Impl::ISA AlphaISA;
     typedef typename Impl::Params Params;
 
   public:
index 408676331b0cc1da872e4126e8579d84d299eaba..6736cf9bcb94128e18a950ec23567c32176bfe67 100644 (file)
@@ -282,7 +282,7 @@ AlphaFullCPU<Impl>::hwrei()
     if (!inPalMode())
         return UnimplementedOpcodeFault;
 
-    setNextPC(ipr[AlphaISA::IPR_EXC_ADDR]);
+    this->setNextPC(ipr[AlphaISA::IPR_EXC_ADDR]);
 
 //    kernelStats.hwrei();
 
@@ -337,7 +337,7 @@ AlphaFullCPU<Impl>::trap(Fault * fault)
     if (fault == ArithmeticFault)
         panic("Arithmetic traps are unimplemented!");
 
-    typename AlphaISA::InternalProcReg *ipr = getIpr();
+    AlphaISA::InternalProcReg *ipr = getIpr();
 
     // exception restart address - Get the commit PC
     if (fault != InterruptFault || !inPalMode(PC))
index 77dcbaf74174fdc846de84b67bd874b8556cf6c9..22be2aae5e19f937eda88cb3112314fd7bed6433 100644 (file)
@@ -48,21 +48,18 @@ class AlphaDynInst : public BaseDynInst<Impl>
     /** Typedef for the CPU. */
     typedef typename Impl::FullCPU FullCPU;
 
-    /** Typedef to get the ISA. */
-    typedef typename Impl::ISA ISA;
-
     /** Binary machine instruction type. */
-    typedef typename ISA::MachInst MachInst;
+    typedef TheISA::MachInst MachInst;
     /** Memory address type. */
-    typedef typename ISA::Addr    Addr;
+    typedef TheISA::Addr          Addr;
     /** Logical register index type. */
-    typedef typename ISA::RegIndex RegIndex;
+    typedef TheISA::RegIndex RegIndex;
     /** Integer register index type. */
-    typedef typename ISA::IntReg   IntReg;
+    typedef TheISA::IntReg   IntReg;
 
     enum {
-        MaxInstSrcRegs = ISA::MaxInstSrcRegs,  //< Max source regs
-        MaxInstDestRegs = ISA::MaxInstDestRegs,        //< Max dest regs
+        MaxInstSrcRegs = TheISA::MaxInstSrcRegs,       //< Max source regs
+        MaxInstDestRegs = TheISA::MaxInstDestRegs,     //< Max dest regs
     };
 
   public:
@@ -71,7 +68,7 @@ class AlphaDynInst : public BaseDynInst<Impl>
                  FullCPU *cpu);
 
     /** BaseDynInst constructor given a static inst pointer. */
-    AlphaDynInst(StaticInstPtr<AlphaISA> &_staticInst);
+    AlphaDynInst(StaticInstPtr &_staticInst);
 
     /** Executes the instruction.*/
     Fault * execute()
@@ -130,22 +127,22 @@ class AlphaDynInst : public BaseDynInst<Impl>
     // storage (which is pretty hard to imagine they would have reason
     // to do).
 
-    uint64_t readIntReg(const StaticInst<ISA> *si, int idx)
+    uint64_t readIntReg(const StaticInst *si, int idx)
     {
         return this->cpu->readIntReg(_srcRegIdx[idx]);
     }
 
-    float readFloatRegSingle(const StaticInst<ISA> *si, int idx)
+    float readFloatRegSingle(const StaticInst *si, int idx)
     {
         return this->cpu->readFloatRegSingle(_srcRegIdx[idx]);
     }
 
-    double readFloatRegDouble(const StaticInst<ISA> *si, int idx)
+    double readFloatRegDouble(const StaticInst *si, int idx)
     {
         return this->cpu->readFloatRegDouble(_srcRegIdx[idx]);
     }
 
-    uint64_t readFloatRegInt(const StaticInst<ISA> *si, int idx)
+    uint64_t readFloatRegInt(const StaticInst *si, int idx)
     {
         return this->cpu->readFloatRegInt(_srcRegIdx[idx]);
     }
@@ -153,25 +150,25 @@ class AlphaDynInst : public BaseDynInst<Impl>
     /** @todo: Make results into arrays so they can handle multiple dest
      *  registers.
      */
-    void setIntReg(const StaticInst<ISA> *si, int idx, uint64_t val)
+    void setIntReg(const StaticInst *si, int idx, uint64_t val)
     {
         this->cpu->setIntReg(_destRegIdx[idx], val);
         this->instResult.integer = val;
     }
 
-    void setFloatRegSingle(const StaticInst<ISA> *si, int idx, float val)
+    void setFloatRegSingle(const StaticInst *si, int idx, float val)
     {
         this->cpu->setFloatRegSingle(_destRegIdx[idx], val);
         this->instResult.fp = val;
     }
 
-    void setFloatRegDouble(const StaticInst<ISA> *si, int idx, double val)
+    void setFloatRegDouble(const StaticInst *si, int idx, double val)
     {
         this->cpu->setFloatRegDouble(_destRegIdx[idx], val);
         this->instResult.dbl = val;
     }
 
-    void setFloatRegInt(const StaticInst<ISA> *si, int idx, uint64_t val)
+    void setFloatRegInt(const StaticInst *si, int idx, uint64_t val)
     {
         this->cpu->setFloatRegInt(_destRegIdx[idx], val);
         this->instResult.integer = val;
index b20af48cde0b8841f22c5d86f6f278baabee2586..9f9df3da11e7aa86fd832fe0195eb32b14172c2e 100644 (file)
@@ -50,7 +50,7 @@ AlphaDynInst<Impl>::AlphaDynInst(MachInst inst, Addr PC, Addr Pred_PC,
 }
 
 template <class Impl>
-AlphaDynInst<Impl>::AlphaDynInst(StaticInstPtr<AlphaISA> &_staticInst)
+AlphaDynInst<Impl>::AlphaDynInst(StaticInstPtr &_staticInst)
     : BaseDynInst<Impl>(_staticInst)
 {
     // Make sure to have the renamed register entries set to the same
index 6c11560413df2efd4bde5a4fd65f5df9af00487f..5e39fcb37ed3cfe7d17c0a266e8152a6ec1b503b 100644 (file)
@@ -51,11 +51,8 @@ class AlphaFullCPU;
  */
 struct AlphaSimpleImpl
 {
-    /** The ISA to be used. */
-    typedef AlphaISA ISA;
-
     /** The type of MachInst. */
-    typedef ISA::MachInst MachInst;
+    typedef TheISA::MachInst MachInst;
 
     /** The CPU policy to be used (ie fetch, decode, etc.). */
     typedef SimpleCPUPolicy<AlphaSimpleImpl> CPUPol;
index 0a77b83dccd6a7410794e02baadd8dd7830ff569..c874f9e04b407aa2bf1f5ccec88ea40ac2fa1daa 100644 (file)
@@ -53,6 +53,8 @@
 template<class Impl>
 class TwobitBPredUnit
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     typedef typename Impl::Params Params;
     typedef typename Impl::DynInstPtr DynInstPtr;
index 9cb2e04902c83377b085b48a85ad9b5e618d4528..8d16a0cdf0b8d2bc7a061c7dd99922eb7a6dc7dc 100644 (file)
@@ -98,6 +98,8 @@ TwobitBPredUnit<Impl>::predict(DynInstPtr &inst, Addr &PC)
     // Save off record of branch stuff so the RAS can be fixed
     // up once it's done.
 
+    using TheISA::MachInst;
+
     bool pred_taken = false;
     Addr target;
 
index 7671e61e28f8d631fc171c9146d753f26cc9d136..2d39c385619dd425c593de3ad7e40d7388ac2a48 100644 (file)
@@ -30,6 +30,8 @@
 #include "base/trace.hh"
 #include "cpu/o3/btb.hh"
 
+using namespace TheISA;
+
 DefaultBTB::DefaultBTB(unsigned _numEntries,
                        unsigned _tagBits,
                        unsigned _instShiftAmt)
index a4ddfecb4ddd26d88f7bea8df373964c9aff3a6b..f443ddbaf65a3bc84522ca35f1c7802856771476 100644 (file)
 #define __CPU_O3_CPU_BTB_HH__
 
 // For Addr type.
-#include "arch/alpha/isa_traits.hh"
+#include "arch/isa_traits.hh"
 
 class DefaultBTB
 {
+  protected:
+    typedef TheISA::Addr Addr;
   private:
     struct BTBEntry
     {
index 6ddc8d6b98b80d18726df930358ab6754a350de3..580c1a3168994281c6994d0766d691f1e70a6c6e 100644 (file)
@@ -52,7 +52,6 @@ class SimpleCommit
 {
   public:
     // Typedefs from the Impl.
-    typedef typename Impl::ISA ISA;
     typedef typename Impl::FullCPU FullCPU;
     typedef typename Impl::DynInstPtr DynInstPtr;
     typedef typename Impl::Params Params;
index adc7b6bbc28fde8746ac6f04f23054044189ce67..ffa157fbbe70c6b58689869e1ddccbbbaaac228c 100644 (file)
@@ -84,14 +84,14 @@ FullO3CPU<Impl>::FullO3CPU(Params &params)
 
       regFile(params.numPhysIntRegs, params.numPhysFloatRegs),
 
-      freeList(Impl::ISA::NumIntRegs, params.numPhysIntRegs,
-               Impl::ISA::NumFloatRegs, params.numPhysFloatRegs),
+      freeList(TheISA::NumIntRegs, params.numPhysIntRegs,
+               TheISA::NumFloatRegs, params.numPhysFloatRegs),
 
-      renameMap(Impl::ISA::NumIntRegs, params.numPhysIntRegs,
-                Impl::ISA::NumFloatRegs, params.numPhysFloatRegs,
-                Impl::ISA::NumMiscRegs,
-                Impl::ISA::ZeroReg,
-                Impl::ISA::ZeroReg + Impl::ISA::NumIntRegs),
+      renameMap(TheISA::NumIntRegs, params.numPhysIntRegs,
+                TheISA::NumFloatRegs, params.numPhysFloatRegs,
+                TheISA::NumMiscRegs,
+                TheISA::ZeroReg,
+                TheISA::ZeroReg + TheISA::NumIntRegs),
 
       rob(params.numROBEntries, params.squashWidth),
 
@@ -254,13 +254,13 @@ FullO3CPU<Impl>::init()
         ExecContext *src_xc = thread[0];
 #endif
         // First loop through the integer registers.
-        for (int i = 0; i < Impl::ISA::NumIntRegs; ++i)
+        for (int i = 0; i < TheISA::NumIntRegs; ++i)
         {
             regFile.intRegFile[i] = src_xc->regs.intRegFile[i];
         }
 
         // Then loop through the floating point registers.
-        for (int i = 0; i < Impl::ISA::NumFloatRegs; ++i)
+        for (int i = 0; i < TheISA::NumFloatRegs; ++i)
         {
             regFile.floatRegFile[i].d = src_xc->regs.floatRegFile.d[i];
             regFile.floatRegFile[i].q = src_xc->regs.floatRegFile.q[i];
index 75dca505688d855dae55c087a35bc94cd5782f6c..321d61dce6d700fcd90111ebb156cfb0c7c0a010 100644 (file)
@@ -78,7 +78,6 @@ class FullO3CPU : public BaseFullCPU
 {
   public:
     //Put typedefs from the Impl here.
-    typedef typename Impl::ISA ISA;
     typedef typename Impl::CPUPol CPUPolicy;
     typedef typename Impl::Params Params;
     typedef typename Impl::DynInstPtr DynInstPtr;
@@ -153,11 +152,11 @@ class FullO3CPU : public BaseFullCPU
 
     /** Get instruction asid. */
     int getInstAsid()
-    { return ITB_ASN_ASN(regFile.getIpr()[ISA::IPR_ITB_ASN]); }
+    { return ITB_ASN_ASN(regFile.getIpr()[TheISA::IPR_ITB_ASN]); }
 
     /** Get data asid. */
     int getDataAsid()
-    { return DTB_ASN_ASN(regFile.getIpr()[ISA::IPR_DTB_ASN]); }
+    { return DTB_ASN_ASN(regFile.getIpr()[TheISA::IPR_DTB_ASN]); }
 #else
     bool validInstAddr(Addr addr)
     { return thread[0]->validInstAddr(addr); }
index 42313d83a55d446541fc1ab777f1ca62ec8edf65..bae9a701585361e26a716e10dd321671e9f39ba6 100644 (file)
@@ -39,7 +39,6 @@ class SimpleDecode
 {
   private:
     // Typedefs from the Impl.
-    typedef typename Impl::ISA ISA;
     typedef typename Impl::FullCPU FullCPU;
     typedef typename Impl::DynInstPtr DynInstPtr;
     typedef typename Impl::Params Params;
@@ -51,7 +50,7 @@ class SimpleDecode
     typedef typename CPUPol::TimeStruct TimeStruct;
 
     // Typedefs from the ISA.
-    typedef typename ISA::Addr Addr;
+    typedef TheISA::Addr Addr;
 
   public:
     // The only time decode will become blocked is if dispatch becomes
index 5443d274e73abb1efc291309f3a1f505145e758e..e4d374c1da62ec3d5d20d6eddca1380522df3701 100644 (file)
@@ -49,7 +49,6 @@ class SimpleFetch
 {
   public:
     /** Typedefs from Impl. */
-    typedef typename Impl::ISA ISA;
     typedef typename Impl::CPUPol CPUPol;
     typedef typename Impl::DynInst DynInst;
     typedef typename Impl::DynInstPtr DynInstPtr;
@@ -61,7 +60,8 @@ class SimpleFetch
     typedef typename CPUPol::TimeStruct TimeStruct;
 
     /** Typedefs from ISA. */
-    typedef typename ISA::MachInst MachInst;
+    typedef TheISA::MachInst MachInst;
+    typedef TheISA::Addr Addr;
 
   public:
     enum Status {
@@ -141,7 +141,7 @@ class SimpleFetch
     // We fold in the PISA 64- to 32-bit conversion here as well.
     Addr icacheBlockAlignPC(Addr addr)
     {
-        addr = ISA::realPCToFetchPC(addr);
+        addr = TheISA::realPCToFetchPC(addr);
         return (addr & ~(cacheBlkMask));
     }
 
index 733d142fc91c3497b5b1cfb7258cf1b103ac09b5..0b85dba1e08b5e4bbc81712bf38baa29183a3042 100644 (file)
@@ -32,7 +32,7 @@
 #include <iostream>
 #include <queue>
 
-#include "arch/alpha/isa_traits.hh"
+#include "arch/isa_traits.hh"
 #include "base/trace.hh"
 #include "base/traceflags.hh"
 #include "cpu/o3/comm.hh"
index af23c6f45a2ef78c576a4a3793206dd9a20ad9fb..1e370d4e6aa7993b2dc1d5b33626b3e08a5dca51 100644 (file)
@@ -45,7 +45,6 @@ class SimpleIEW
 {
   private:
     //Typedefs from Impl
-    typedef typename Impl::ISA ISA;
     typedef typename Impl::CPUPol CPUPol;
     typedef typename Impl::DynInstPtr DynInstPtr;
     typedef typename Impl::FullCPU FullCPU;
index b8a2b4dc9606aef0bb29c5da548b0cc91f47050a..85217dd10bb54eff4712efc297519a99456a480c 100644 (file)
@@ -256,7 +256,7 @@ SimpleIEW<Impl>::squashDueToBranch(DynInstPtr &inst)
     toCommit->branchMispredict = true;
     // Prediction was incorrect, so send back inverse.
     toCommit->branchTaken = inst->readNextPC() !=
-        (inst->readPC() + sizeof(MachInst));
+        (inst->readPC() + sizeof(TheISA::MachInst));
 }
 
 template<class Impl>
index bbc4162a678c0c77dc3269b9cf6b6fa3555b0a14..fd7f5fe1c826df62e82d5888e1cc08d7050a40f9 100644 (file)
 #define __CPU_O3_CPU_RAS_HH__
 
 // For Addr type.
-#include "arch/alpha/isa_traits.hh"
+#include "arch/isa_traits.hh"
 
 class ReturnAddrStack
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     ReturnAddrStack(unsigned numEntries);
 
index 5aafd54954873dc2c5a330e048fd0e83412b42b1..655a3cad9ab0ba806f069061b813c688886ea5d8 100644 (file)
@@ -52,6 +52,11 @@ using namespace EV5;
 template <class Impl>
 class PhysRegFile
 {
+  protected:
+    typedef TheISA::Addr Addr;
+    typedef TheISA::IntReg IntReg;
+    typedef TheISA::FloatReg FloatReg;
+    typedef TheISA::MiscRegFile MiscRegFile;
     //Note that most of the definitions of the IntReg, FloatReg, etc. exist
     //within the Impl/ISA class and not within this PhysRegFile class.
 
@@ -62,7 +67,6 @@ class PhysRegFile
     //Will make these registers public for now, but they probably should
     //be private eventually with some accessor functions.
   public:
-    typedef typename Impl::ISA ISA;
     typedef typename Impl::FullCPU FullCPU;
 
     PhysRegFile(unsigned _numPhysicalIntRegs,
@@ -281,73 +285,73 @@ PhysRegFile<Impl>::readIpr(int idx, Fault * &fault)
     uint64_t retval = 0;    // return value, default 0
 
     switch (idx) {
-      case ISA::IPR_PALtemp0:
-      case ISA::IPR_PALtemp1:
-      case ISA::IPR_PALtemp2:
-      case ISA::IPR_PALtemp3:
-      case ISA::IPR_PALtemp4:
-      case ISA::IPR_PALtemp5:
-      case ISA::IPR_PALtemp6:
-      case ISA::IPR_PALtemp7:
-      case ISA::IPR_PALtemp8:
-      case ISA::IPR_PALtemp9:
-      case ISA::IPR_PALtemp10:
-      case ISA::IPR_PALtemp11:
-      case ISA::IPR_PALtemp12:
-      case ISA::IPR_PALtemp13:
-      case ISA::IPR_PALtemp14:
-      case ISA::IPR_PALtemp15:
-      case ISA::IPR_PALtemp16:
-      case ISA::IPR_PALtemp17:
-      case ISA::IPR_PALtemp18:
-      case ISA::IPR_PALtemp19:
-      case ISA::IPR_PALtemp20:
-      case ISA::IPR_PALtemp21:
-      case ISA::IPR_PALtemp22:
-      case ISA::IPR_PALtemp23:
-      case ISA::IPR_PAL_BASE:
-
-      case ISA::IPR_IVPTBR:
-      case ISA::IPR_DC_MODE:
-      case ISA::IPR_MAF_MODE:
-      case ISA::IPR_ISR:
-      case ISA::IPR_EXC_ADDR:
-      case ISA::IPR_IC_PERR_STAT:
-      case ISA::IPR_DC_PERR_STAT:
-      case ISA::IPR_MCSR:
-      case ISA::IPR_ASTRR:
-      case ISA::IPR_ASTER:
-      case ISA::IPR_SIRR:
-      case ISA::IPR_ICSR:
-      case ISA::IPR_ICM:
-      case ISA::IPR_DTB_CM:
-      case ISA::IPR_IPLR:
-      case ISA::IPR_INTID:
-      case ISA::IPR_PMCTR:
+      case TheISA::IPR_PALtemp0:
+      case TheISA::IPR_PALtemp1:
+      case TheISA::IPR_PALtemp2:
+      case TheISA::IPR_PALtemp3:
+      case TheISA::IPR_PALtemp4:
+      case TheISA::IPR_PALtemp5:
+      case TheISA::IPR_PALtemp6:
+      case TheISA::IPR_PALtemp7:
+      case TheISA::IPR_PALtemp8:
+      case TheISA::IPR_PALtemp9:
+      case TheISA::IPR_PALtemp10:
+      case TheISA::IPR_PALtemp11:
+      case TheISA::IPR_PALtemp12:
+      case TheISA::IPR_PALtemp13:
+      case TheISA::IPR_PALtemp14:
+      case TheISA::IPR_PALtemp15:
+      case TheISA::IPR_PALtemp16:
+      case TheISA::IPR_PALtemp17:
+      case TheISA::IPR_PALtemp18:
+      case TheISA::IPR_PALtemp19:
+      case TheISA::IPR_PALtemp20:
+      case TheISA::IPR_PALtemp21:
+      case TheISA::IPR_PALtemp22:
+      case TheISA::IPR_PALtemp23:
+      case TheISA::IPR_PAL_BASE:
+
+      case TheISA::IPR_IVPTBR:
+      case TheISA::IPR_DC_MODE:
+      case TheISA::IPR_MAF_MODE:
+      case TheISA::IPR_ISR:
+      case TheISA::IPR_EXC_ADDR:
+      case TheISA::IPR_IC_PERR_STAT:
+      case TheISA::IPR_DC_PERR_STAT:
+      case TheISA::IPR_MCSR:
+      case TheISA::IPR_ASTRR:
+      case TheISA::IPR_ASTER:
+      case TheISA::IPR_SIRR:
+      case TheISA::IPR_ICSR:
+      case TheISA::IPR_ICM:
+      case TheISA::IPR_DTB_CM:
+      case TheISA::IPR_IPLR:
+      case TheISA::IPR_INTID:
+      case TheISA::IPR_PMCTR:
         // no side-effect
         retval = ipr[idx];
         break;
 
-      case ISA::IPR_CC:
+      case TheISA::IPR_CC:
         retval |= ipr[idx] & ULL(0xffffffff00000000);
         retval |= curTick  & ULL(0x00000000ffffffff);
         break;
 
-      case ISA::IPR_VA:
+      case TheISA::IPR_VA:
         retval = ipr[idx];
         break;
 
-      case ISA::IPR_VA_FORM:
-      case ISA::IPR_MM_STAT:
-      case ISA::IPR_IFAULT_VA_FORM:
-      case ISA::IPR_EXC_MASK:
-      case ISA::IPR_EXC_SUM:
+      case TheISA::IPR_VA_FORM:
+      case TheISA::IPR_MM_STAT:
+      case TheISA::IPR_IFAULT_VA_FORM:
+      case TheISA::IPR_EXC_MASK:
+      case TheISA::IPR_EXC_SUM:
         retval = ipr[idx];
         break;
 
-      case ISA::IPR_DTB_PTE:
+      case TheISA::IPR_DTB_PTE:
         {
-            typename ISA::PTE &pte = cpu->dtb->index(1);
+            TheISA::PTE &pte = cpu->dtb->index(1);
 
             retval |= ((u_int64_t)pte.ppn & ULL(0x7ffffff)) << 32;
             retval |= ((u_int64_t)pte.xre & ULL(0xf)) << 8;
@@ -360,15 +364,15 @@ PhysRegFile<Impl>::readIpr(int idx, Fault * &fault)
         break;
 
         // write only registers
-      case ISA::IPR_HWINT_CLR:
-      case ISA::IPR_SL_XMIT:
-      case ISA::IPR_DC_FLUSH:
-      case ISA::IPR_IC_FLUSH:
-      case ISA::IPR_ALT_MODE:
-      case ISA::IPR_DTB_IA:
-      case ISA::IPR_DTB_IAP:
-      case ISA::IPR_ITB_IA:
-      case ISA::IPR_ITB_IAP:
+      case TheISA::IPR_HWINT_CLR:
+      case TheISA::IPR_SL_XMIT:
+      case TheISA::IPR_DC_FLUSH:
+      case TheISA::IPR_IC_FLUSH:
+      case TheISA::IPR_ALT_MODE:
+      case TheISA::IPR_DTB_IA:
+      case TheISA::IPR_DTB_IAP:
+      case TheISA::IPR_ITB_IA:
+      case TheISA::IPR_ITB_IAP:
         fault = UnimplementedOpcodeFault;
         break;
 
@@ -390,195 +394,195 @@ PhysRegFile<Impl>::setIpr(int idx, uint64_t val)
     uint64_t old;
 
     switch (idx) {
-      case ISA::IPR_PALtemp0:
-      case ISA::IPR_PALtemp1:
-      case ISA::IPR_PALtemp2:
-      case ISA::IPR_PALtemp3:
-      case ISA::IPR_PALtemp4:
-      case ISA::IPR_PALtemp5:
-      case ISA::IPR_PALtemp6:
-      case ISA::IPR_PALtemp7:
-      case ISA::IPR_PALtemp8:
-      case ISA::IPR_PALtemp9:
-      case ISA::IPR_PALtemp10:
-      case ISA::IPR_PALtemp11:
-      case ISA::IPR_PALtemp12:
-      case ISA::IPR_PALtemp13:
-      case ISA::IPR_PALtemp14:
-      case ISA::IPR_PALtemp15:
-      case ISA::IPR_PALtemp16:
-      case ISA::IPR_PALtemp17:
-      case ISA::IPR_PALtemp18:
-      case ISA::IPR_PALtemp19:
-      case ISA::IPR_PALtemp20:
-      case ISA::IPR_PALtemp21:
-      case ISA::IPR_PALtemp22:
-      case ISA::IPR_PAL_BASE:
-      case ISA::IPR_IC_PERR_STAT:
-      case ISA::IPR_DC_PERR_STAT:
-      case ISA::IPR_PMCTR:
+      case TheISA::IPR_PALtemp0:
+      case TheISA::IPR_PALtemp1:
+      case TheISA::IPR_PALtemp2:
+      case TheISA::IPR_PALtemp3:
+      case TheISA::IPR_PALtemp4:
+      case TheISA::IPR_PALtemp5:
+      case TheISA::IPR_PALtemp6:
+      case TheISA::IPR_PALtemp7:
+      case TheISA::IPR_PALtemp8:
+      case TheISA::IPR_PALtemp9:
+      case TheISA::IPR_PALtemp10:
+      case TheISA::IPR_PALtemp11:
+      case TheISA::IPR_PALtemp12:
+      case TheISA::IPR_PALtemp13:
+      case TheISA::IPR_PALtemp14:
+      case TheISA::IPR_PALtemp15:
+      case TheISA::IPR_PALtemp16:
+      case TheISA::IPR_PALtemp17:
+      case TheISA::IPR_PALtemp18:
+      case TheISA::IPR_PALtemp19:
+      case TheISA::IPR_PALtemp20:
+      case TheISA::IPR_PALtemp21:
+      case TheISA::IPR_PALtemp22:
+      case TheISA::IPR_PAL_BASE:
+      case TheISA::IPR_IC_PERR_STAT:
+      case TheISA::IPR_DC_PERR_STAT:
+      case TheISA::IPR_PMCTR:
         // write entire quad w/ no side-effect
         ipr[idx] = val;
         break;
 
-      case ISA::IPR_CC_CTL:
+      case TheISA::IPR_CC_CTL:
         // This IPR resets the cycle counter.  We assume this only
         // happens once... let's verify that.
         assert(ipr[idx] == 0);
         ipr[idx] = 1;
         break;
 
-      case ISA::IPR_CC:
+      case TheISA::IPR_CC:
         // This IPR only writes the upper 64 bits.  It's ok to write
         // all 64 here since we mask out the lower 32 in rpcc (see
         // isa_desc).
         ipr[idx] = val;
         break;
 
-      case ISA::IPR_PALtemp23:
+      case TheISA::IPR_PALtemp23:
         // write entire quad w/ no side-effect
         old = ipr[idx];
         ipr[idx] = val;
         break;
 
-      case ISA::IPR_DTB_PTE:
+      case TheISA::IPR_DTB_PTE:
         // write entire quad w/ no side-effect, tag is forthcoming
         ipr[idx] = val;
         break;
 
-      case ISA::IPR_EXC_ADDR:
+      case TheISA::IPR_EXC_ADDR:
         // second least significant bit in PC is always zero
         ipr[idx] = val & ~2;
         break;
 
-      case ISA::IPR_ASTRR:
-      case ISA::IPR_ASTER:
+      case TheISA::IPR_ASTRR:
+      case TheISA::IPR_ASTER:
         // only write least significant four bits - privilege mask
         ipr[idx] = val & 0xf;
         break;
 
-      case ISA::IPR_IPLR:
+      case TheISA::IPR_IPLR:
         // only write least significant five bits - interrupt level
         ipr[idx] = val & 0x1f;
         break;
 
-      case ISA::IPR_DTB_CM:
+      case TheISA::IPR_DTB_CM:
 
-      case ISA::IPR_ICM:
+      case TheISA::IPR_ICM:
         // only write two mode bits - processor mode
         ipr[idx] = val & 0x18;
         break;
 
-      case ISA::IPR_ALT_MODE:
+      case TheISA::IPR_ALT_MODE:
         // only write two mode bits - processor mode
         ipr[idx] = val & 0x18;
         break;
 
-      case ISA::IPR_MCSR:
+      case TheISA::IPR_MCSR:
         // more here after optimization...
         ipr[idx] = val;
         break;
 
-      case ISA::IPR_SIRR:
+      case TheISA::IPR_SIRR:
         // only write software interrupt mask
         ipr[idx] = val & 0x7fff0;
         break;
 
-      case ISA::IPR_ICSR:
+      case TheISA::IPR_ICSR:
         ipr[idx] = val & ULL(0xffffff0300);
         break;
 
-      case ISA::IPR_IVPTBR:
-      case ISA::IPR_MVPTBR:
+      case TheISA::IPR_IVPTBR:
+      case TheISA::IPR_MVPTBR:
         ipr[idx] = val & ULL(0xffffffffc0000000);
         break;
 
-      case ISA::IPR_DC_TEST_CTL:
+      case TheISA::IPR_DC_TEST_CTL:
         ipr[idx] = val & 0x1ffb;
         break;
 
-      case ISA::IPR_DC_MODE:
-      case ISA::IPR_MAF_MODE:
+      case TheISA::IPR_DC_MODE:
+      case TheISA::IPR_MAF_MODE:
         ipr[idx] = val & 0x3f;
         break;
 
-      case ISA::IPR_ITB_ASN:
+      case TheISA::IPR_ITB_ASN:
         ipr[idx] = val & 0x7f0;
         break;
 
-      case ISA::IPR_DTB_ASN:
+      case TheISA::IPR_DTB_ASN:
         ipr[idx] = val & ULL(0xfe00000000000000);
         break;
 
-      case ISA::IPR_EXC_SUM:
-      case ISA::IPR_EXC_MASK:
+      case TheISA::IPR_EXC_SUM:
+      case TheISA::IPR_EXC_MASK:
         // any write to this register clears it
         ipr[idx] = 0;
         break;
 
-      case ISA::IPR_INTID:
-      case ISA::IPR_SL_RCV:
-      case ISA::IPR_MM_STAT:
-      case ISA::IPR_ITB_PTE_TEMP:
-      case ISA::IPR_DTB_PTE_TEMP:
+      case TheISA::IPR_INTID:
+      case TheISA::IPR_SL_RCV:
+      case TheISA::IPR_MM_STAT:
+      case TheISA::IPR_ITB_PTE_TEMP:
+      case TheISA::IPR_DTB_PTE_TEMP:
         // read-only registers
         return UnimplementedOpcodeFault;
 
-      case ISA::IPR_HWINT_CLR:
-      case ISA::IPR_SL_XMIT:
-      case ISA::IPR_DC_FLUSH:
-      case ISA::IPR_IC_FLUSH:
+      case TheISA::IPR_HWINT_CLR:
+      case TheISA::IPR_SL_XMIT:
+      case TheISA::IPR_DC_FLUSH:
+      case TheISA::IPR_IC_FLUSH:
         // the following are write only
         ipr[idx] = val;
         break;
 
-      case ISA::IPR_DTB_IA:
+      case TheISA::IPR_DTB_IA:
         // really a control write
         ipr[idx] = 0;
 
         cpu->dtb->flushAll();
         break;
 
-      case ISA::IPR_DTB_IAP:
+      case TheISA::IPR_DTB_IAP:
         // really a control write
         ipr[idx] = 0;
 
         cpu->dtb->flushProcesses();
         break;
 
-      case ISA::IPR_DTB_IS:
+      case TheISA::IPR_DTB_IS:
         // really a control write
         ipr[idx] = val;
 
-        cpu->dtb->flushAddr(val, DTB_ASN_ASN(ipr[ISA::IPR_DTB_ASN]));
+        cpu->dtb->flushAddr(val, DTB_ASN_ASN(ipr[TheISA::IPR_DTB_ASN]));
         break;
 
-      case ISA::IPR_DTB_TAG: {
-          struct ISA::PTE pte;
+      case TheISA::IPR_DTB_TAG: {
+          struct TheISA::PTE pte;
 
           // FIXME: granularity hints NYI...
-          if (DTB_PTE_GH(ipr[ISA::IPR_DTB_PTE]) != 0)
+          if (DTB_PTE_GH(ipr[TheISA::IPR_DTB_PTE]) != 0)
               panic("PTE GH field != 0");
 
           // write entire quad
           ipr[idx] = val;
 
           // construct PTE for new entry
-          pte.ppn = DTB_PTE_PPN(ipr[ISA::IPR_DTB_PTE]);
-          pte.xre = DTB_PTE_XRE(ipr[ISA::IPR_DTB_PTE]);
-          pte.xwe = DTB_PTE_XWE(ipr[ISA::IPR_DTB_PTE]);
-          pte.fonr = DTB_PTE_FONR(ipr[ISA::IPR_DTB_PTE]);
-          pte.fonw = DTB_PTE_FONW(ipr[ISA::IPR_DTB_PTE]);
-          pte.asma = DTB_PTE_ASMA(ipr[ISA::IPR_DTB_PTE]);
-          pte.asn = DTB_ASN_ASN(ipr[ISA::IPR_DTB_ASN]);
+          pte.ppn = DTB_PTE_PPN(ipr[TheISA::IPR_DTB_PTE]);
+          pte.xre = DTB_PTE_XRE(ipr[TheISA::IPR_DTB_PTE]);
+          pte.xwe = DTB_PTE_XWE(ipr[TheISA::IPR_DTB_PTE]);
+          pte.fonr = DTB_PTE_FONR(ipr[TheISA::IPR_DTB_PTE]);
+          pte.fonw = DTB_PTE_FONW(ipr[TheISA::IPR_DTB_PTE]);
+          pte.asma = DTB_PTE_ASMA(ipr[TheISA::IPR_DTB_PTE]);
+          pte.asn = DTB_ASN_ASN(ipr[TheISA::IPR_DTB_ASN]);
 
           // insert new TAG/PTE value into data TLB
           cpu->dtb->insert(val, pte);
       }
         break;
 
-      case ISA::IPR_ITB_PTE: {
-          struct ISA::PTE pte;
+      case TheISA::IPR_ITB_PTE: {
+          struct TheISA::PTE pte;
 
           // FIXME: granularity hints NYI...
           if (ITB_PTE_GH(val) != 0)
@@ -594,32 +598,32 @@ PhysRegFile<Impl>::setIpr(int idx, uint64_t val)
           pte.fonr = ITB_PTE_FONR(val);
           pte.fonw = ITB_PTE_FONW(val);
           pte.asma = ITB_PTE_ASMA(val);
-          pte.asn = ITB_ASN_ASN(ipr[ISA::IPR_ITB_ASN]);
+          pte.asn = ITB_ASN_ASN(ipr[TheISA::IPR_ITB_ASN]);
 
           // insert new TAG/PTE value into data TLB
-          cpu->itb->insert(ipr[ISA::IPR_ITB_TAG], pte);
+          cpu->itb->insert(ipr[TheISA::IPR_ITB_TAG], pte);
       }
         break;
 
-      case ISA::IPR_ITB_IA:
+      case TheISA::IPR_ITB_IA:
         // really a control write
         ipr[idx] = 0;
 
         cpu->itb->flushAll();
         break;
 
-      case ISA::IPR_ITB_IAP:
+      case TheISA::IPR_ITB_IAP:
         // really a control write
         ipr[idx] = 0;
 
         cpu->itb->flushProcesses();
         break;
 
-      case ISA::IPR_ITB_IS:
+      case TheISA::IPR_ITB_IS:
         // really a control write
         ipr[idx] = val;
 
-        cpu->itb->flushAddr(val, ITB_ASN_ASN(ipr[ISA::IPR_ITB_ASN]));
+        cpu->itb->flushAddr(val, ITB_ASN_ASN(ipr[TheISA::IPR_ITB_ASN]));
         break;
 
       default:
index a17ec7311409eaed6341d94dd1907e0629041cc9..9781480b6e7bba27dfdb055b3ea04dceca6c0a75 100644 (file)
@@ -46,7 +46,6 @@ class SimpleRename
 {
   public:
     // Typedefs from the Impl.
-    typedef typename Impl::ISA ISA;
     typedef typename Impl::CPUPol CPUPol;
     typedef typename Impl::DynInstPtr DynInstPtr;
     typedef typename Impl::FullCPU FullCPU;
@@ -62,7 +61,8 @@ class SimpleRename
     typedef typename CPUPol::RenameMap RenameMap;
 
     // Typedefs from the ISA.
-    typedef typename ISA::Addr Addr;
+    typedef TheISA::Addr Addr;
+    typedef TheISA::RegIndex RegIndex;
 
   public:
     // Rename will block if ROB becomes full or issue queue becomes full,
index c44c7a1eaeb24fc4a8c5f070e459efd0dd4c46c2..57be4a64a82fc6b5e35d77a50c62566c037d7c25 100644 (file)
 #include <vector>
 
 #include "cpu/o3/free_list.hh"
+//For RegIndex
+#include "arch/isa_traits.hh"
 
 class SimpleRenameMap
 {
+  protected:
+    typedef TheISA::RegIndex RegIndex;
   public:
     /**
      * Pair of a logical register and a physical register.  Tells the
index 29ec48007800dd3f86cf8d72e3ceca6eeb0494d5..1185564ade732f1e5463eedf334ad92f3aca5c45 100644 (file)
@@ -47,6 +47,8 @@
 template <class Impl>
 class ROB
 {
+  protected:
+    typedef TheISA::RegIndex RegIndex;
   public:
     //Typedefs from the Impl.
     typedef typename Impl::FullCPU FullCPU;
index bcd590384b23848e3b4c583025b26d667c17c3d6..c67d30fcb2ca738b0923ec83dcb6b7a157f61c03 100644 (file)
 
 #include <vector>
 
-#include "arch/alpha/isa_traits.hh"
+#include "arch/isa_traits.hh"
 #include "cpu/inst_seq.hh"
 
 class StoreSet
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     typedef unsigned SSID;
 
index 58ea1a7d9cdaea329eaf5c78bdfe5179c1308f33..6cfd24cfbdc3ff459d7fb4c9d7540d72ebc0f149 100644 (file)
 #define __CPU_O3_CPU_TOURNAMENT_PRED_HH__
 
 // For Addr type.
-#include "arch/alpha/isa_traits.hh"
+#include "arch/isa_traits.hh"
 #include "cpu/o3/sat_counter.hh"
 
 class TournamentBP
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     /**
      * Default branch predictor constructor.
index 21fe05b6a1cd6ae97c6762dcc0dddf9ed0be1229..7976632d9ee40675a61780506934ace4d14d5b3f 100644 (file)
@@ -77,7 +77,6 @@ class OoOCPU : public BaseCPU
   private:
     typedef typename Impl::DynInst DynInst;
     typedef typename Impl::DynInstPtr DynInstPtr;
-    typedef typename Impl::ISA ISA;
 
   public:
     // main simulation loop (one cycle)
@@ -378,12 +377,12 @@ class OoOCPU : public BaseCPU
   private:
     InstSeqNum globalSeqNum;
 
-    DynInstPtr renameTable[ISA::TotalNumRegs];
-    DynInstPtr commitTable[ISA::TotalNumRegs];
+    DynInstPtr renameTable[TheISA::TotalNumRegs];
+    DynInstPtr commitTable[TheISA::TotalNumRegs];
 
     // Might need a table of the shadow registers as well.
 #if FULL_SYSTEM
-    DynInstPtr palShadowTable[ISA::NumIntRegs];
+    DynInstPtr palShadowTable[TheISA::NumIntRegs];
 #endif
 
   public:
@@ -402,47 +401,47 @@ class OoOCPU : public BaseCPU
     // rename table of DynInsts.  Also these likely shouldn't be called very
     // often, other than when adding things into the xc during say a syscall.
 
-    uint64_t readIntReg(StaticInst<TheISA> *si, int idx)
+    uint64_t readIntReg(StaticInst *si, int idx)
     {
         return xc->readIntReg(si->srcRegIdx(idx));
     }
 
-    float readFloatRegSingle(StaticInst<TheISA> *si, int idx)
+    float readFloatRegSingle(StaticInst *si, int idx)
     {
         int reg_idx = si->srcRegIdx(idx) - TheISA::FP_Base_DepTag;
         return xc->readFloatRegSingle(reg_idx);
     }
 
-    double readFloatRegDouble(StaticInst<TheISA> *si, int idx)
+    double readFloatRegDouble(StaticInst *si, int idx)
     {
         int reg_idx = si->srcRegIdx(idx) - TheISA::FP_Base_DepTag;
         return xc->readFloatRegDouble(reg_idx);
     }
 
-    uint64_t readFloatRegInt(StaticInst<TheISA> *si, int idx)
+    uint64_t readFloatRegInt(StaticInst *si, int idx)
     {
         int reg_idx = si->srcRegIdx(idx) - TheISA::FP_Base_DepTag;
         return xc->readFloatRegInt(reg_idx);
     }
 
-    void setIntReg(StaticInst<TheISA> *si, int idx, uint64_t val)
+    void setIntReg(StaticInst *si, int idx, uint64_t val)
     {
         xc->setIntReg(si->destRegIdx(idx), val);
     }
 
-    void setFloatRegSingle(StaticInst<TheISA> *si, int idx, float val)
+    void setFloatRegSingle(StaticInst *si, int idx, float val)
     {
         int reg_idx = si->destRegIdx(idx) - TheISA::FP_Base_DepTag;
         xc->setFloatRegSingle(reg_idx, val);
     }
 
-    void setFloatRegDouble(StaticInst<TheISA> *si, int idx, double val)
+    void setFloatRegDouble(StaticInst *si, int idx, double val)
     {
         int reg_idx = si->destRegIdx(idx) - TheISA::FP_Base_DepTag;
         xc->setFloatRegDouble(reg_idx, val);
     }
 
-    void setFloatRegInt(StaticInst<TheISA> *si, int idx, uint64_t val)
+    void setFloatRegInt(StaticInst *si, int idx, uint64_t val)
     {
         int reg_idx = si->destRegIdx(idx) - TheISA::FP_Base_DepTag;
         xc->setFloatRegInt(reg_idx, val);
@@ -479,7 +478,7 @@ class OoOCPU : public BaseCPU
     // We fold in the PISA 64- to 32-bit conversion here as well.
     Addr icacheBlockAlignPC(Addr addr)
     {
-        addr = ISA::realPCToFetchPC(addr);
+        addr = TheISA::realPCToFetchPC(addr);
         return (addr & ~(cacheBlkMask));
     }
 
index 83fbc3e2d776eeb4e961a29ea829ab17def42a48..7a294866d4b77bb8cb6c5b461c39caff59fb2e18 100644 (file)
@@ -136,14 +136,14 @@ BreakPCEvent::process(ExecContext *xc)
 #if FULL_SYSTEM
 extern "C"
 void
-sched_break_pc_sys(System *sys, Addr addr)
+sched_break_pc_sys(System *sys, TheISA::Addr addr)
 {
     new BreakPCEvent(&sys->pcEventQueue, "debug break", addr, true);
 }
 
 extern "C"
 void
-sched_break_pc(Addr addr)
+sched_break_pc(TheISA::Addr addr)
 {
      for (vector<System *>::iterator sysi = System::systemList.begin();
           sysi != System::systemList.end(); ++sysi) {
index 7fa3902ccd272ad017a892f3d3409f7ba6981730..3033a3cfdf6155863efaea189b3b0838ed2783cf 100644 (file)
@@ -39,6 +39,7 @@ class PCEventQueue;
 class PCEvent
 {
   protected:
+    typedef TheISA::Addr Addr;
     static const Addr badpc = MemReq::inval_addr;
 
   protected:
@@ -64,6 +65,7 @@ class PCEvent
 class PCEventQueue
 {
   protected:
+    typedef TheISA::Addr Addr;
     typedef PCEvent * record_t;
     class MapCompare {
       public:
@@ -132,6 +134,7 @@ PCEvent::remove()
 class BreakPCEvent : public PCEvent
 {
   protected:
+    typedef TheISA::Addr Addr;
     bool remove;
 
   public:
index 58cd7e79fa14ef5d09084df37f65abaecd17c20e..b55f87a6ad5ea48741d3631b74f257d8c7bfb883 100644 (file)
@@ -37,6 +37,8 @@
 
 class ProfileNode
 {
+  protected:
+    typedef TheISA::Addr Addr;
   private:
     friend class FunctionProfile;
 
@@ -57,6 +59,8 @@ class ProfileNode
 class Callback;
 class FunctionProfile
 {
+  public:
+    typedef TheISA::Addr Addr;
   private:
     Callback *reset;
     const SymbolTable *symtab;
@@ -68,7 +72,7 @@ class FunctionProfile
     FunctionProfile(const SymbolTable *symtab);
     ~FunctionProfile();
 
-    ProfileNode *consume(ExecContext *xc, StaticInstPtr<TheISA> inst);
+    ProfileNode *consume(ExecContext *xc, StaticInstPtr inst);
     ProfileNode *consume(const std::vector<Addr> &stack);
     void clear();
     void dump(ExecContext *xc, std::ostream &out) const;
@@ -76,7 +80,7 @@ class FunctionProfile
 };
 
 inline ProfileNode *
-FunctionProfile::consume(ExecContext *xc, StaticInstPtr<TheISA> inst)
+FunctionProfile::consume(ExecContext *xc, StaticInstPtr inst)
 {
     if (!trace.trace(xc, inst))
         return NULL;
index 6aff94abd1de21070c8786f1678a357be99941ff..c3f256de99cbe254740381abbcedf535fdb7a773 100644 (file)
@@ -76,7 +76,7 @@
 
 using namespace std;
 //The SimpleCPU does alpha only
-using namespace LittleEndianGuest;
+using namespace AlphaISA;
 
 
 SimpleCPU::TickEvent::TickEvent(SimpleCPU *c, int w)
@@ -125,7 +125,7 @@ SimpleCPU::SimpleCPU(Params *p)
     xc = new ExecContext(this, 0, p->system, p->itb, p->dtb, p->mem);
 
     // initialize CPU, including PC
-    TheISA::initCPU(&xc->regs);
+    initCPU(&xc->regs);
 #else
     xc = new ExecContext(this, /* thread_num */ 0, p->process, /* asid */ 0);
 #endif // !FULL_SYSTEM
@@ -323,7 +323,7 @@ SimpleCPU::copySrcTranslate(Addr src)
 
     // Make sure block doesn't span page
     if (no_warn &&
-        (src & TheISA::PageMask) != ((src + blk_size) & TheISA::PageMask) &&
+        (src & PageMask) != ((src + blk_size) & PageMask) &&
         (src >> 40) != 0xfffffc) {
         warn("Copied block source spans pages %x.", src);
         no_warn = false;
@@ -359,7 +359,7 @@ SimpleCPU::copy(Addr dest)
 
     // Make sure block doesn't span page
     if (no_warn &&
-        (dest & TheISA::PageMask) != ((dest + blk_size) & TheISA::PageMask) &&
+        (dest & PageMask) != ((dest + blk_size) & PageMask) &&
         (dest >> 40) != 0xfffffc) {
         no_warn = false;
         warn("Copied block destination spans pages %x. ", dest);
@@ -648,20 +648,20 @@ SimpleCPU::tick()
         checkInterrupts = false;
         IntReg *ipr = xc->regs.ipr;
 
-        if (xc->regs.ipr[TheISA::IPR_SIRR]) {
-            for (int i = TheISA::INTLEVEL_SOFTWARE_MIN;
-                 i < TheISA::INTLEVEL_SOFTWARE_MAX; i++) {
-                if (ipr[TheISA::IPR_SIRR] & (ULL(1) << i)) {
+        if (xc->regs.ipr[IPR_SIRR]) {
+            for (int i = INTLEVEL_SOFTWARE_MIN;
+                 i < INTLEVEL_SOFTWARE_MAX; i++) {
+                if (ipr[IPR_SIRR] & (ULL(1) << i)) {
                     // See table 4-19 of 21164 hardware reference
-                    ipl = (i - TheISA::INTLEVEL_SOFTWARE_MIN) + 1;
+                    ipl = (i - INTLEVEL_SOFTWARE_MIN) + 1;
                     summary |= (ULL(1) << i);
                 }
             }
         }
 
         uint64_t interrupts = xc->cpu->intr_status();
-        for (int i = TheISA::INTLEVEL_EXTERNAL_MIN;
-            i < TheISA::INTLEVEL_EXTERNAL_MAX; i++) {
+        for (int i = INTLEVEL_EXTERNAL_MIN;
+            i < INTLEVEL_EXTERNAL_MAX; i++) {
             if (interrupts & (ULL(1) << i)) {
                 // See table 4-19 of 21164 hardware reference
                 ipl = i;
@@ -669,16 +669,16 @@ SimpleCPU::tick()
             }
         }
 
-        if (ipr[TheISA::IPR_ASTRR])
+        if (ipr[IPR_ASTRR])
             panic("asynchronous traps not implemented\n");
 
-        if (ipl && ipl > xc->regs.ipr[TheISA::IPR_IPLR]) {
-            ipr[TheISA::IPR_ISR] = summary;
-            ipr[TheISA::IPR_INTID] = ipl;
+        if (ipl && ipl > xc->regs.ipr[IPR_IPLR]) {
+            ipr[IPR_ISR] = summary;
+            ipr[IPR_INTID] = ipl;
             xc->ev5_trap(InterruptFault);
 
             DPRINTF(Flow, "Interrupt! IPLR=%d ipl=%d summary=%x\n",
-                    ipr[TheISA::IPR_IPLR], ipl, summary);
+                    ipr[IPR_IPLR], ipl, summary);
         }
     }
 #endif
@@ -749,7 +749,7 @@ SimpleCPU::tick()
 
         // decode the instruction
         inst = gtoh(inst);
-        curStaticInst = StaticInst<TheISA>::decode(inst);
+        curStaticInst = StaticInst::decode(inst);
 
         traceData = Trace::getInstRecord(curTick, xc, this, curStaticInst,
                                          xc->regs.pc);
index e7a4471177103ec24697cf09eb555d83dd6ae8e9..8a390072675e47705bca5b62c834463a9189920b 100644 (file)
@@ -63,6 +63,8 @@ namespace Trace {
 
 class SimpleCPU : public BaseCPU
 {
+  protected:
+    typedef TheISA::MachInst MachInst;
   public:
     // main simulation loop (one cycle)
     void tick();
@@ -172,7 +174,7 @@ class SimpleCPU : public BaseCPU
     // the next switchover
     Sampler *sampler;
 
-    StaticInstPtr<TheISA> curStaticInst;
+    StaticInstPtr curStaticInst;
 
     class CacheCompletionEvent : public Event
     {
@@ -269,47 +271,47 @@ class SimpleCPU : public BaseCPU
     // storage (which is pretty hard to imagine they would have reason
     // to do).
 
-    uint64_t readIntReg(const StaticInst<TheISA> *si, int idx)
+    uint64_t readIntReg(const StaticInst *si, int idx)
     {
         return xc->readIntReg(si->srcRegIdx(idx));
     }
 
-    float readFloatRegSingle(const StaticInst<TheISA> *si, int idx)
+    float readFloatRegSingle(const StaticInst *si, int idx)
     {
         int reg_idx = si->srcRegIdx(idx) - TheISA::FP_Base_DepTag;
         return xc->readFloatRegSingle(reg_idx);
     }
 
-    double readFloatRegDouble(const StaticInst<TheISA> *si, int idx)
+    double readFloatRegDouble(const StaticInst *si, int idx)
     {
         int reg_idx = si->srcRegIdx(idx) - TheISA::FP_Base_DepTag;
         return xc->readFloatRegDouble(reg_idx);
     }
 
-    uint64_t readFloatRegInt(const StaticInst<TheISA> *si, int idx)
+    uint64_t readFloatRegInt(const StaticInst *si, int idx)
     {
         int reg_idx = si->srcRegIdx(idx) - TheISA::FP_Base_DepTag;
         return xc->readFloatRegInt(reg_idx);
     }
 
-    void setIntReg(const StaticInst<TheISA> *si, int idx, uint64_t val)
+    void setIntReg(const StaticInst *si, int idx, uint64_t val)
     {
         xc->setIntReg(si->destRegIdx(idx), val);
     }
 
-    void setFloatRegSingle(const StaticInst<TheISA> *si, int idx, float val)
+    void setFloatRegSingle(const StaticInst *si, int idx, float val)
     {
         int reg_idx = si->destRegIdx(idx) - TheISA::FP_Base_DepTag;
         xc->setFloatRegSingle(reg_idx, val);
     }
 
-    void setFloatRegDouble(const StaticInst<TheISA> *si, int idx, double val)
+    void setFloatRegDouble(const StaticInst *si, int idx, double val)
     {
         int reg_idx = si->destRegIdx(idx) - TheISA::FP_Base_DepTag;
         xc->setFloatRegDouble(reg_idx, val);
     }
 
-    void setFloatRegInt(const StaticInst<TheISA> *si, int idx, uint64_t val)
+    void setFloatRegInt(const StaticInst *si, int idx, uint64_t val)
     {
         int reg_idx = si->destRegIdx(idx) - TheISA::FP_Base_DepTag;
         xc->setFloatRegInt(reg_idx, val);
index 54bd9914eff169a83fc444ec430b99f674579c03..c307dc6fcf912fcb5ac67fa8fb1d87b9dcb652aa 100644 (file)
 #include "cpu/static_inst.hh"
 #include "sim/root.hh"
 
-template <class ISA>
-StaticInstPtr<ISA> StaticInst<ISA>::nullStaticInstPtr;
-
-template <class ISA>
-typename StaticInst<ISA>::DecodeCache StaticInst<ISA>::decodeCache;
+StaticInstPtr StaticInst::nullStaticInstPtr;
 
 // Define the decode cache hash map.
-template StaticInst<AlphaISA>::DecodeCache
-StaticInst<AlphaISA>::decodeCache;
+StaticInst::DecodeCache StaticInst::decodeCache;
 
-template <class ISA>
 void
-StaticInst<ISA>::dumpDecodeCacheStats()
+StaticInst::dumpDecodeCacheStats()
 {
     using namespace std;
 
@@ -62,13 +56,8 @@ StaticInst<ISA>::dumpDecodeCacheStats()
     }
 }
 
-
-template StaticInstPtr<AlphaISA>
-StaticInst<AlphaISA>::nullStaticInstPtr;
-
-template <class ISA>
 bool
-StaticInst<ISA>::hasBranchTarget(Addr pc, ExecContext *xc, Addr &tgt) const
+StaticInst::hasBranchTarget(Addr pc, ExecContext *xc, Addr &tgt) const
 {
     if (isDirectCtrl()) {
         tgt = branchTarget(pc);
@@ -83,6 +72,3 @@ StaticInst<ISA>::hasBranchTarget(Addr pc, ExecContext *xc, Addr &tgt) const
     return false;
 }
 
-
-// force instantiation of template function(s) above
-template class StaticInst<AlphaISA>;
index 24997eadc5316d3c84d665e04acda4f9af71fa80..6be30cd3140d617914bf290f8fb02192ef509475 100644 (file)
@@ -208,7 +208,6 @@ class StaticInstBase : public RefCounted
 
 
 // forward declaration
-template <class ISA>
 class StaticInstPtr;
 
 /**
@@ -218,21 +217,20 @@ class StaticInstPtr;
  * that are generic across all ISAs but that differ in details
  * according to the specific ISA being used.
  */
-template <class ISA>
 class StaticInst : public StaticInstBase
 {
   public:
 
     /// Binary machine instruction type.
-    typedef typename ISA::MachInst MachInst;
+    typedef TheISA::MachInst MachInst;
     /// Memory address type.
-    typedef typename ISA::Addr    Addr;
+    typedef TheISA::Addr          Addr;
     /// Logical register index type.
-    typedef typename ISA::RegIndex RegIndex;
+    typedef TheISA::RegIndex RegIndex;
 
     enum {
-        MaxInstSrcRegs = ISA::MaxInstSrcRegs,  //< Max source regs
-        MaxInstDestRegs = ISA::MaxInstDestRegs,        //< Max dest regs
+        MaxInstSrcRegs = TheISA::MaxInstSrcRegs,       //< Max source regs
+        MaxInstDestRegs = TheISA::MaxInstDestRegs,     //< Max dest regs
     };
 
 
@@ -247,7 +245,7 @@ class StaticInst : public StaticInstBase
     /// Pointer to a statically allocated "null" instruction object.
     /// Used to give eaCompInst() and memAccInst() something to return
     /// when called on non-memory instructions.
-    static StaticInstPtr<ISA> nullStaticInstPtr;
+    static StaticInstPtr nullStaticInstPtr;
 
     /**
      * Memory references only: returns "fake" instruction representing
@@ -256,7 +254,7 @@ class StaticInst : public StaticInstBase
      * just the EA computation.
      */
     virtual const
-    StaticInstPtr<ISA> &eaCompInst() const { return nullStaticInstPtr; }
+    StaticInstPtr &eaCompInst() const { return nullStaticInstPtr; }
 
     /**
      * Memory references only: returns "fake" instruction representing
@@ -265,7 +263,7 @@ class StaticInst : public StaticInstBase
      * just the memory access (not the EA computation).
      */
     virtual const
-    StaticInstPtr<ISA> &memAccInst() const { return nullStaticInstPtr; }
+    StaticInstPtr &memAccInst() const { return nullStaticInstPtr; }
 
     /// The binary machine instruction.
     const MachInst machInst;
@@ -364,7 +362,7 @@ class StaticInst : public StaticInstBase
     /// Decoded instruction cache type.
     /// For now we're using a generic hash_map; this seems to work
     /// pretty well.
-    typedef m5::hash_map<MachInst, StaticInstPtr<ISA> > DecodeCache;
+    typedef m5::hash_map<MachInst, StaticInstPtr> DecodeCache;
 
     /// A cache of decoded instruction objects.
     static DecodeCache decodeCache;
@@ -378,63 +376,40 @@ class StaticInst : public StaticInstBase
     /// Decode a machine instruction.
     /// @param mach_inst The binary instruction to decode.
     /// @retval A pointer to the corresponding StaticInst object.
-    static
-    StaticInstPtr<ISA> decode(MachInst mach_inst)
-    {
-#ifdef DECODE_CACHE_HASH_STATS
-        // Simple stats on decode hash_map.  Turns out the default
-        // hash function is as good as anything I could come up with.
-        const int dump_every_n = 10000000;
-        static int decodes_til_dump = dump_every_n;
-
-        if (--decodes_til_dump == 0) {
-            dumpDecodeCacheStats();
-            decodes_til_dump = dump_every_n;
-        }
-#endif
-
-        typename DecodeCache::iterator iter = decodeCache.find(mach_inst);
-        if (iter != decodeCache.end()) {
-            return iter->second;
-        }
-
-        StaticInstPtr<ISA> si = ISA::decodeInst(mach_inst);
-        decodeCache[mach_inst] = si;
-        return si;
-    }
+    //This is defined as inline below.
+    static StaticInstPtr decode(MachInst mach_inst);
 };
 
 typedef RefCountingPtr<StaticInstBase> StaticInstBasePtr;
 
 /// Reference-counted pointer to a StaticInst object.
-/// This type should be used instead of "StaticInst<ISA> *" so that
+/// This type should be used instead of "StaticInst *" so that
 /// StaticInst objects can be properly reference-counted.
-template <class ISA>
-class StaticInstPtr : public RefCountingPtr<StaticInst<ISA> >
+class StaticInstPtr : public RefCountingPtr<StaticInst>
 {
   public:
     /// Constructor.
     StaticInstPtr()
-        : RefCountingPtr<StaticInst<ISA> >()
+        : RefCountingPtr<StaticInst>()
     {
     }
 
-    /// Conversion from "StaticInst<ISA> *".
-    StaticInstPtr(StaticInst<ISA> *p)
-        : RefCountingPtr<StaticInst<ISA> >(p)
+    /// Conversion from "StaticInst *".
+    StaticInstPtr(StaticInst *p)
+        : RefCountingPtr<StaticInst>(p)
     {
     }
 
     /// Copy constructor.
     StaticInstPtr(const StaticInstPtr &r)
-        : RefCountingPtr<StaticInst<ISA> >(r)
+        : RefCountingPtr<StaticInst>(r)
     {
     }
 
     /// Construct directly from machine instruction.
-    /// Calls StaticInst<ISA>::decode().
-    StaticInstPtr(typename ISA::MachInst mach_inst)
-        : RefCountingPtr<StaticInst<ISA> >(StaticInst<ISA>::decode(mach_inst))
+    /// Calls StaticInst::decode().
+    StaticInstPtr(TheISA::MachInst mach_inst)
+        : RefCountingPtr<StaticInst>(StaticInst::decode(mach_inst))
     {
     }
 
@@ -445,4 +420,29 @@ class StaticInstPtr : public RefCountingPtr<StaticInst<ISA> >
     }
 };
 
+inline StaticInstPtr
+StaticInst::decode(StaticInst::MachInst mach_inst)
+{
+#ifdef DECODE_CACHE_HASH_STATS
+    // Simple stats on decode hash_map.  Turns out the default
+    // hash function is as good as anything I could come up with.
+    const int dump_every_n = 10000000;
+    static int decodes_til_dump = dump_every_n;
+
+    if (--decodes_til_dump == 0) {
+        dumpDecodeCacheStats();
+        decodes_til_dump = dump_every_n;
+    }
+#endif
+
+    DecodeCache::iterator iter = decodeCache.find(mach_inst);
+    if (iter != decodeCache.end()) {
+        return iter->second;
+    }
+
+    StaticInstPtr si = TheISA::decodeInst(mach_inst);
+    decodeCache[mach_inst] = si;
+    return si;
+}
+
 #endif // __CPU_STATIC_INST_HH__
index f8169173346314b2764fc37c54660666da527bde..704dc09fa29fb901191ab998a68757f69e0fd754 100644 (file)
@@ -49,6 +49,8 @@ class MemTraceReader;
  */
 class OptCPU : public SimObject
 {
+  protected:
+    typedef TheISA::Addr Addr;
   private:
     typedef int RefIndex;
 
index faec73138d14131dfeb996fa7c724f50ad2ccd88..e402b2d5202acd325b5ac15b2d1e744c15802e23 100644 (file)
@@ -46,6 +46,9 @@
  */
 class ITXReader : public MemTraceReader
 {
+  protected:
+    typedef TheISA::Addr Addr;
+  private:
     /** Trace file. */
     FILE *trace;
 
index 38fbbdef0a58cb612d061b1413774198acf1bb8e..a7ef8f64155299d0d0bf605e3504049430b3fbd1 100644 (file)
@@ -53,6 +53,7 @@
 #include "sim/system.hh"
 
 using namespace std;
+using namespace AlphaISA;
 
 AlphaConsole::AlphaConsole(const string &name, SimConsole *cons, SimpleDisk *d,
                            System *s, BaseCPU *c, Platform *p,
index b6ca919e4aeecefea917ef30a0c538e6da42ed89..62871e348e7ed030524ac285b8bc7d1ee0b00ea3 100644 (file)
@@ -46,6 +46,7 @@
 #include "sim/system.hh"
 
 using namespace std;
+using namespace TheISA;
 
 BadDevice::BadDevice(const string &name, Addr a, MemoryController *mmu,
                      HierParams *hier, Bus *pio_bus, const string &devicename)
index a5cb0dfd805a6f1683d9c0f84c15a0000f234744..18c988b81d7a1eb3426faac6129a8756777a2d6c 100644 (file)
@@ -48,6 +48,7 @@
 #include "sim/sim_object.hh"
 
 using namespace std;
+using namespace TheISA;
 
 ////
 // Initialization and destruction
index 9d8bb8825b050ff60a4c103b56a26b86426e2a05..41400c59042c2dc562c948d265ac9cd3fdb6eeb6 100644 (file)
@@ -53,6 +53,7 @@
 #include "arch/isa_traits.hh"
 
 using namespace std;
+using namespace TheISA;
 
 IdeDisk::IdeDisk(const string &name, DiskImage *img, PhysicalMemory *phys,
                  int id, Tick delay)
index a656ca464ef8c14ae52a5480fa0ecc9800ffbf60..32888c81cd2693a59cc0dd245254c81b5153a82d 100644 (file)
@@ -187,6 +187,8 @@ class IdeController;
  */
 class IdeDisk : public SimObject
 {
+  protected:
+    typedef TheISA::Addr Addr;
   protected:
     /** The IDE controller for this disk. */
     IdeController *ctrl;
index 93c9eedbf9fc7c027b4cf1e8903f0f067f188405..117c9e5ad9743d45e2629c2313d4e390703d0bc7 100644 (file)
@@ -45,6 +45,7 @@
 #include "sim/system.hh"
 
 using namespace std;
+using namespace TheISA;
 
 IsaFake::IsaFake(const string &name, Addr a, MemoryController *mmu,
                          HierParams *hier, Bus *pio_bus, Addr size)
index c2861543854be2646d33db31e83e27fc351cc5dd..07bf178fc4b8ea4bb87cb168af026b4c333e2c3e 100644 (file)
@@ -84,6 +84,7 @@ const char *NsDmaState[] =
 
 using namespace std;
 using namespace Net;
+using namespace TheISA;
 
 ///////////////////////////////////////////////////////////////////////
 //
index 1175172c4f3e397169fdee33cc760b002317f92f..c581e15618df119bf33da07412f9095e5d601da5 100644 (file)
@@ -47,6 +47,7 @@
 #include "sim/system.hh"
 
 using namespace std;
+using namespace TheISA;
 
 PciConfigAll::PciConfigAll(const string &name,
                            Addr a, MemoryController *mmu,
index c8d9685c1dea0951ffa848a5ca681421324fce2a..a100bf746c3bb8809ed887020e5ec53787846b42 100644 (file)
@@ -53,6 +53,8 @@ class MemoryController;
  */
 class PciConfigData : public SimObject
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     /**
      * Constructor to initialize the devices config space to 0.
index 58f94db7b4c85a35aab3acdc647876477b195791..5b667b12c0e6889a70644a7f0153916f01850280 100644 (file)
@@ -31,6 +31,7 @@
 #include "sim/sim_exit.hh"
 
 using namespace std;
+using namespace TheISA;
 
 Platform::Platform(const string &name, IntrControl *intctrl, PciConfigAll *pci)
     : SimObject(name), intrctrl(intctrl), pciconfig(pci)
index 1ee64545467ef08fd3daa18d24a9d5b59f57b366..87810250a595df727de115e791c1808d0bf5f888 100644 (file)
@@ -44,6 +44,8 @@ class Uart;
 
 class Platform : public SimObject
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     /** Pointer to the interrupt controller */
     IntrControl *intrctrl;
index 6560e15c21f54f615868b4eb350bc3182bcb4ba0..f68d5bfff54c3284de63f06ebd031c6dd3583d63 100644 (file)
@@ -44,19 +44,21 @@ class PhysicalMemory;
  */
 class SimpleDisk : public SimObject
 {
-public:
-  typedef uint64_t baddr_t;
+  protected:
+    typedef TheISA::Addr Addr;
+  public:
+    typedef uint64_t baddr_t;
 
-protected:
-  PhysicalMemory  *physmem;
-  DiskImage *image;
+  protected:
+    PhysicalMemory  *physmem;
+    DiskImage *image;
 
-public:
-  SimpleDisk(const std::string &name, PhysicalMemory *pmem, DiskImage *img);
-  ~SimpleDisk();
+  public:
+    SimpleDisk(const std::string &name, PhysicalMemory *pmem, DiskImage *img);
+    ~SimpleDisk();
 
-  void read(Addr addr, baddr_t block, int count) const;
-  void write(Addr addr, baddr_t block, int count);
+    void read(Addr addr, baddr_t block, int count) const;
+    void write(Addr addr, baddr_t block, int count);
 };
 
 #endif // __DEV_SIMPLE_DISK_HH__
index e79f80678dab0d3b52358b1c0cdf46cd440cb60a..829d58d32c2e91a6facec4b8d0e4c18d9d836309 100644 (file)
@@ -50,6 +50,7 @@
 #include "targetarch/vtophys.hh"
 
 using namespace Net;
+using namespace TheISA;
 
 namespace Sinic {
 
index b7008b4e15204e296bc88141cf3bdb36ef6593f6..343db6303bfe77f46c7598a623ef2019ef1c3e06 100644 (file)
@@ -165,7 +165,7 @@ struct Info
 /* namespace Regs */ }
 
 inline const Regs::Info&
-regInfo(Addr daddr)
+regInfo(TheISA::Addr daddr)
 {
     static Regs::Info invalid = { 0, false, false, false, false, "invalid" };
     static Regs::Info info [] = {
@@ -201,7 +201,7 @@ regInfo(Addr daddr)
 }
 
 inline bool
-regValid(Addr daddr)
+regValid(TheISA::Addr daddr)
 {
     if (daddr > Regs::Size)
         return false;
index 760848a006cced3f4332e5d0cd805c6a1509682a..58fc7434e0679c57fb59356bf8e41aa53369b06e 100644 (file)
@@ -46,6 +46,8 @@
 #include "sim/system.hh"
 
 using namespace std;
+//Should this be AlphaISA?
+using namespace TheISA;
 
 Tsunami::Tsunami(const string &name, System *s, IntrControl *ic,
                  PciConfigAll *pci)
index 7fd91d5b269ab5b7f289329e971338401fe61103..79b561ed75e0658d13a5c3c3535533450d6bd103 100644 (file)
@@ -55,6 +55,8 @@ class System;
 
 class Tsunami : public Platform
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     /** Max number of CPUs in a Tsunami */
     static const int Max_CPUs = 64;
index 4cda9ec360d18144d2b34e1e9c65d688f3e52e0a..10c08a7a21f9dae2ce9aabf86f922cb7f667ea56 100644 (file)
@@ -47,6 +47,8 @@
 #include "sim/system.hh"
 
 using namespace std;
+//Should this be AlphaISA?
+using namespace TheISA;
 
 TsunamiCChip::TsunamiCChip(const string &name, Tsunami *t, Addr a,
                            MemoryController *mmu, HierParams *hier,
index 0d0d27570133362933cd9deba032b641bc76332b..e90bb5abcce5752cc89c9a16f6a1dcdb6365562e 100644 (file)
@@ -50,6 +50,8 @@
 #include "mem/functional/memory_control.hh"
 
 using namespace std;
+//Should this be AlphaISA?
+using namespace TheISA;
 
 TsunamiIO::RTC::RTC(const string &name, Tsunami* t, Tick i)
     : _name(name), event(t, i), addr(0)
index a4c04a79fe68a12ef6cb4eed9c6938be64de7b4b..706daf9dc395bb9a7d51fd229881bea80bc73d2e 100644 (file)
@@ -47,6 +47,8 @@
 #include "sim/system.hh"
 
 using namespace std;
+//Should this be AlphaISA?
+using namespace TheISA;
 
 TsunamiPChip::TsunamiPChip(const string &name, Tsunami *t, Addr a,
                            MemoryController *mmu, HierParams *hier,
index a2e782189cb193ead7bceeee0a0ba2f52cf6419f..99355e28a0638078fa55ff1cba67d22bf597824d 100644 (file)
@@ -46,6 +46,7 @@
 #include "sim/builder.hh"
 
 using namespace std;
+using namespace TheISA;
 
 Uart8250::IntrEvent::IntrEvent(Uart8250 *u, int bit)
     : Event(&mainEventQueue), uart(u)
index dbf60a3fc89d14b868c26f54f1d5ad53e577d0a3..cead8caaf67257efc214e2d9de2998361a83003d 100644 (file)
@@ -46,6 +46,7 @@
 #define TIMER_FREQUENCY 1193180
 
 using namespace std;
+using namespace TheISA;
 
 FreebsdSystem::FreebsdSystem(Params *p)
     : System(p)
index 98cc044ac482c3a19dcef0e3756a6c4a8a971824..e4d5ec01157eb18cf0e15624f3ff8a7fc5767bef 100644 (file)
@@ -50,6 +50,8 @@ extern const char *modestr[];
 
 class Binning
 {
+  protected:
+    typedef TheISA::Addr Addr;
   private:
     std::string myname;
     System *system;
@@ -106,7 +108,7 @@ class Binning
 
     cpu_mode themode;
     void palSwapContext(ExecContext *xc);
-    void execute(ExecContext *xc, StaticInstPtr<TheISA> inst);
+    void execute(ExecContext *xc, StaticInstPtr inst);
     void call(ExecContext *xc, Stats::MainBin *myBin);
     void changeMode(cpu_mode mode);
 
@@ -124,6 +126,9 @@ class Binning
 
 class Statistics : public Serializable
 {
+  protected:
+    typedef TheISA::Addr Addr;
+  private:
     friend class Binning;
 
   private:
index 18d1b43c064691fd459e64056aeb49f28bdf9cab..137f65076f150224095af033e5f3cd5c265ef4fb 100644 (file)
@@ -37,7 +37,7 @@
 #if __GNUC__ == 3 && __GNUC_MINOR__  != 3
 typedef uint64_t uint64_ta __attribute__ ((aligned (8))) ;
 typedef int64_t int64_ta __attribute__ ((aligned (8))) ;
-typedef Addr Addr_a __attribute__ ((aligned (8))) ;
+typedef TheISA::Addr Addr_a __attribute__ ((aligned (8))) ;
 #else
 #define uint64_ta uint64_t __attribute__ ((aligned (8)))
 #define int64_ta int64_t __attribute__ ((aligned (8)))
index 26a4c0d3e39786dc1df79bfd75cffd99b7785698..c5a9e184ad9947ab456cd584e8bd458dface82b2 100644 (file)
@@ -50,6 +50,7 @@
 #include "targetarch/vtophys.hh"
 
 using namespace std;
+using namespace TheISA;
 
 LinuxSystem::LinuxSystem(Params *p)
     : System(p)
index 9bab1dc49e99ad8f1f4c61bbc426c5888e98bf57..f20188360af4f70bfbd8188d53c18914cb35815b 100644 (file)
@@ -37,6 +37,8 @@ namespace Linux {
 
 class ThreadInfo
 {
+  protected:
+    typedef TheISA::Addr Addr;
   private:
     ExecContext *xc;
 
@@ -53,7 +55,7 @@ class ThreadInfo
          * thread_info struct. So we can get the address by masking off
          * the lower 14 bits.
          */
-        current = xc->regs.intRegFile[StackPointerReg] & ~0x3fff;
+        current = xc->regs.intRegFile[TheISA::StackPointerReg] & ~0x3fff;
         return VPtr<thread_info>(xc, current);
     }
 
index ba3c9274a7d15c95c647386404680d3510a3c9d1..55595b9b6503519629c2f3f2c7408728b1a52915 100644 (file)
@@ -29,6 +29,8 @@
 #include "encumbered/cpu/full/cpu.hh"
 #include "kern/kernel_stats.hh"
 
+using namespace TheISA;
+
 void
 SkipFuncEvent::process(ExecContext *xc)
 {
index 85cb4de9612d7bf30dcd460391cbcbe5750fbf2a..efdaed62d576d04b9ea84ed9f9450bc85d101f61 100644 (file)
@@ -38,6 +38,8 @@
 #include "arch/isa_traits.hh"
 #include "targetarch/vtophys.hh"
 
+using namespace TheISA;
+
 namespace tru64 {
 
 void
index 93424858f2abeae88df73779681d7b15bc2abb30..7b84b5e10bf008087f98a7e7f0bd884c5225f1d0 100644 (file)
 namespace tru64 {
 
 struct m_hdr {
-    Addr       mh_next;        // 0x00
-    Addr       mh_nextpkt;     // 0x08
-    Addr       mh_data;        // 0x10
+    TheISA::Addr       mh_next;        // 0x00
+    TheISA::Addr       mh_nextpkt;     // 0x08
+    TheISA::Addr       mh_data;        // 0x10
     int32_t    mh_len;         // 0x18
     int32_t    mh_type;        // 0x1C
     int32_t    mh_flags;       // 0x20
     int32_t    mh_pad0;        // 0x24
-    Addr       mh_foo[4];      // 0x28, 0x30, 0x38, 0x40
+    TheISA::Addr       mh_foo[4];      // 0x28, 0x30, 0x38, 0x40
 };
 
 struct pkthdr {
     int32_t    len;
     int32_t    protocolSum;
-    Addr       rcvif;
+    TheISA::Addr       rcvif;
 };
 
 struct m_ext {
-    Addr       ext_buf;        // 0x00
-    Addr       ext_free;       // 0x08
+    TheISA::Addr       ext_buf;        // 0x00
+    TheISA::Addr       ext_free;       // 0x08
     uint32_t   ext_size;       // 0x10
     uint32_t   ext_pad0;       // 0x14
-    Addr       ext_arg;        // 0x18
+    TheISA::Addr       ext_arg;        // 0x18
     struct     ext_refq {
-        Addr   forw, back;     // 0x20, 0x28
+        TheISA::Addr   forw, back;     // 0x20, 0x28
     } ext_ref;
-    Addr       uiomove_f;      // 0x30
+    TheISA::Addr       uiomove_f;      // 0x30
     int32_t    protocolSum;    // 0x38
     int32_t    bytesSummed;    // 0x3C
-    Addr       checksum;       // 0x40
+    TheISA::Addr       checksum;       // 0x40
 };
 
 struct mbuf {
index d769aab0f3d575683a6b2451dffcbb8e96debb3e..2fe6a2dc44c7a3b01cd0c6315f7f942e3203c977 100644 (file)
@@ -36,6 +36,8 @@
 #include "targetarch/arguments.hh"
 #include "arch/isa_traits.hh"
 
+using namespace TheISA;
+
 //void SkipFuncEvent::process(ExecContext *xc);
 
 void
index 59d122b48f0f010172e91488ce39347968b48df1..b2f3046fb27a7c1bdf323379c4a5613ded0a641e 100644 (file)
@@ -53,6 +53,7 @@
 #endif
 
 using namespace std;
+using namespace TheISA;
 
 //
 // The purpose of this code is to fake the loader & syscall mechanism
index 43fafd9d7b4d29914eb05326ef08766da8e0f202..f5b713e3cda5d5435f274583098334d5dc514f37 100644 (file)
@@ -50,6 +50,10 @@ class ExecContext;
 class FunctionalMemory;
 class Process : public SimObject
 {
+  protected:
+    typedef TheISA::Addr Addr;
+    typedef TheISA::RegFile RegFile;
+    typedef TheISA::MachInst MachInst;
   public:
 
     // have we initialized an execution context from this process?  If
index 11ab55f5329038cc353a56ccf721b0e3a2e85485..58ea8266f0bd23d899af9bd6670ea01263589d9f 100644 (file)
@@ -53,6 +53,7 @@ using namespace std;
 extern Sampler *SampCPU;
 
 using namespace Stats;
+using namespace TheISA;
 
 namespace AlphaPseudo
 {
index 3857f205063070ccc3741bcbbee3890be4c7407f..07bdd709147c4f4475279da9d25b2b0cb419389a 100644 (file)
@@ -52,8 +52,8 @@ namespace AlphaPseudo
     void dumpstats(ExecContext *xc, Tick delay, Tick period);
     void dumpresetstats(ExecContext *xc, Tick delay, Tick period);
     void m5checkpoint(ExecContext *xc, Tick delay, Tick period);
-    uint64_t readfile(ExecContext *xc, Addr vaddr, uint64_t len, uint64_t offset);
+    uint64_t readfile(ExecContext *xc, TheISA::Addr vaddr, uint64_t len, uint64_t offset);
     void debugbreak(ExecContext *xc);
     void switchcpu(ExecContext *xc);
-    void addsymbol(ExecContext *xc, Addr addr, Addr symbolAddr);
+    void addsymbol(ExecContext *xc, TheISA::Addr addr, TheISA::Addr symbolAddr);
 }
index 0fac43fc5d38c88e73ff30c554085236a855d03e..68001b0d1923a395228e8c490bb01bfafad8b7dc 100644 (file)
@@ -40,6 +40,7 @@
 #include "sim/sim_events.hh"
 
 using namespace std;
+using namespace TheISA;
 
 void
 SyscallDesc::doSyscall(int callnum, Process *process, ExecContext *xc)
@@ -89,7 +90,7 @@ exitFunc(SyscallDesc *desc, int callnum, Process *process,
 SyscallReturn
 getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 {
-    return VMPageSize;
+    return (int)VMPageSize;
 }
 
 
index 739cd20e5575ce5013c41ac8852132fcc11483a6..bc22c5c4c6d95c0654a2af20cba6c8838ea1e598 100644 (file)
@@ -90,6 +90,9 @@ class SyscallDesc {
 
 class BaseBufferArg {
 
+  protected:
+    typedef TheISA::Addr Addr;
+
   public:
 
     BaseBufferArg(Addr _addr, int _size) : addr(_addr), size(_size)
@@ -636,7 +639,7 @@ template <class OS>
 SyscallReturn
 mmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 {
-    Addr start = xc->getSyscallArg(0);
+    TheISA::Addr start = xc->getSyscallArg(0);
     uint64_t length = xc->getSyscallArg(1);
     // int prot = xc->getSyscallArg(2);
     int flags = xc->getSyscallArg(3);
@@ -646,7 +649,7 @@ mmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
     if (start == 0) {
         // user didn't give an address... pick one from our "mmap region"
         start = p->mmap_end;
-        p->mmap_end += roundUp(length, VMPageSize);
+        p->mmap_end += roundUp(length, TheISA::VMPageSize);
         if (p->nxm_start != 0) {
             //If we have an nxm space, make sure we haven't colided
             assert(p->mmap_end < p->nxm_start);
index 990145826b88fc45e7f99a874acbf168ea30e6c6..ebeb5b244169ebc8222bf6b25427d6c5d895669c 100644 (file)
@@ -41,6 +41,7 @@
 #include "base/trace.hh"
 
 using namespace std;
+using namespace TheISA;
 
 vector<System *> System::systemList;
 
index aa697c040459cc1e87cc6cc6d1a8b62abe348d26..4bf33a1707bc6a96197108c54a6aad285347f0b4 100644 (file)
@@ -50,6 +50,8 @@ namespace Kernel { class Binning; }
 
 class System : public SimObject
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     MemoryController *memctrl;
     PhysicalMemory *physmem;
index 7ec43602d70a95e1bdf6f03ca82e68588421d471..1baa006101f0282a20daa5a1cc746ee29a65cb73 100644 (file)
@@ -37,6 +37,8 @@ class ExecContext;
 template <class T>
 class VPtr
 {
+  protected:
+    typedef TheISA::Addr Addr;
   public:
     typedef T Type;