Implemented SPARC fault classes.

arch/sparc/faults.cc:
arch/sparc/faults.hh:
    Implemented the SPARC fault classes. The invoke method still needs to be written, but this depends on the misc regfile.

--HG--
extra : convert_revision : bc9d2785600cee5ea1cba72e563ca5d1a20f37fd

arch/sparc/faults.cc

@@ -26,90 +26,206 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "arch/alpha/faults.hh"
+#include "arch/sparc/faults.hh"
 #include "cpu/exec_context.hh"
 #include "cpu/base.hh"
 #include "base/trace.hh"
-#include "kern/kernel_stats.hh"
 
-namespace AlphaISA
+namespace SparcISA
 {
 
-FaultName MachineCheckFault::_name = "mchk";
+FaultName     InternalProcessorError::_name = "intprocerr";
-FaultVect MachineCheckFault::_vect = 0x0401;
+TrapType      InternalProcessorError::_trapType = 0x029;
-FaultStat MachineCheckFault::_stat;
+FaultPriority InternalProcessorError::_priority = 4;
+FaultStat     InternalProcessorError::_count;
 
-FaultName AlignmentFault::_name = "unalign";
+FaultName     MemAddressNotAligned::_name = "unalign";
-FaultVect AlignmentFault::_vect = 0x0301;
+TrapType      MemAddressNotAligned::_trapType = 0x034;
-FaultStat AlignmentFault::_stat;
+FaultPriority MemAddressNotAligned::_priority = 10;
+FaultStat     MemAddressNotAligned::_count;
 
-FaultName ResetFault::_name = "reset";
+FaultName     PowerOnReset::_name = "pow_reset";
-FaultVect ResetFault::_vect = 0x0001;
+TrapType      PowerOnReset::_trapType = 0x001;
-FaultStat ResetFault::_stat;
+FaultPriority PowerOnReset::_priority = 0;
+FaultStat     PowerOnReset::_count;
 
-FaultName ArithmeticFault::_name = "arith";
+FaultName     WatchDogReset::_name = "watch_dog_reset";
-FaultVect ArithmeticFault::_vect = 0x0501;
+TrapType      WatchDogReset::_trapType = 0x002;
-FaultStat ArithmeticFault::_stat;
+FaultPriority WatchDogReset::_priority = 1;
+FaultStat     WatchDogReset::_count;
 
-FaultName InterruptFault::_name = "interrupt";
+FaultName     ExternallyInitiatedReset::_name = "extern_reset";
-FaultVect InterruptFault::_vect = 0x0101;
+TrapType      ExternallyInitiatedReset::_trapType = 0x003;
-FaultStat InterruptFault::_stat;
+FaultPriority ExternallyInitiatedReset::_priority = 1;
+FaultStat     ExternallyInitiatedReset::_count;
 
-FaultName NDtbMissFault::_name = "dtb_miss_single";
+FaultName     SoftwareInitiatedReset::_name = "software_reset";
-FaultVect NDtbMissFault::_vect = 0x0201;
+TrapType      SoftwareInitiatedReset::_trapType = 0x004;
-FaultStat NDtbMissFault::_stat;
+FaultPriority SoftwareInitiatedReset::_priority = 1;
+FaultStat     SoftwareInitiatedReset::_count;
 
-FaultName PDtbMissFault::_name = "dtb_miss_double";
+FaultName     REDStateException::_name = "red_counte";
-FaultVect PDtbMissFault::_vect = 0x0281;
+TrapType      REDStateException::_trapType = 0x005;
-FaultStat PDtbMissFault::_stat;
+FaultPriority REDStateException::_priority = 1;
+FaultStat     REDStateException::_count;
 
-FaultName DtbPageFault::_name = "dfault";
+FaultName     InstructionAccessException::_name = "inst_access";
-FaultVect DtbPageFault::_vect = 0x0381;
+TrapType      InstructionAccessException::_trapType = 0x008;
-FaultStat DtbPageFault::_stat;
+FaultPriority InstructionAccessException::_priority = 5;
+FaultStat     InstructionAccessException::_count;
 
-FaultName DtbAcvFault::_name = "dfault";
+FaultName     InstructionAccessMMUMiss::_name = "inst_mmu";
-FaultVect DtbAcvFault::_vect = 0x0381;
+TrapType      InstructionAccessMMUMiss::_trapType = 0x009;
-FaultStat DtbAcvFault::_stat;
+FaultPriority InstructionAccessMMUMiss::_priority = 2;
+FaultStat     InstructionAccessMMUMiss::_count;
 
-FaultName ItbMissFault::_name = "itbmiss";
+FaultName     InstructionAccessError::_name = "inst_error";
-FaultVect ItbMissFault::_vect = 0x0181;
+TrapType      InstructionAccessError::_trapType = 0x00A;
-FaultStat ItbMissFault::_stat;
+FaultPriority InstructionAccessError::_priority = 3;
+FaultStat     InstructionAccessError::_count;
 
-FaultName ItbPageFault::_name = "itbmiss";
+FaultName     IllegalInstruction::_name = "illegal_inst";
-FaultVect ItbPageFault::_vect = 0x0181;
+TrapType      IllegalInstruction::_trapType = 0x010;
-FaultStat ItbPageFault::_stat;
+FaultPriority IllegalInstruction::_priority = 7;
+FaultStat     IllegalInstruction::_count;
 
-FaultName ItbAcvFault::_name = "iaccvio";
+FaultName     PrivelegedOpcode::_name = "priv_opcode";
-FaultVect ItbAcvFault::_vect = 0x0081;
+TrapType      PrivelegedOpcode::_trapType = 0x011;
-FaultStat ItbAcvFault::_stat;
+FaultPriority PrivelegedOpcode::_priority = 6;
+FaultStat     PrivelegedOpcode::_count;
 
-FaultName UnimplementedOpcodeFault::_name = "opdec";
+FaultName     UnimplementedLDD::_name = "unimp_ldd";
-FaultVect UnimplementedOpcodeFault::_vect = 0x0481;
+TrapType      UnimplementedLDD::_trapType = 0x012;
-FaultStat UnimplementedOpcodeFault::_stat;
+FaultPriority UnimplementedLDD::_priority = 6;
+FaultStat     UnimplementedLDD::_count;
 
-FaultName FloatEnableFault::_name = "fen";
+FaultName     UnimplementedSTD::_name = "unimp_std";
-FaultVect FloatEnableFault::_vect = 0x0581;
+TrapType      UnimplementedSTD::_trapType = 0x013;
-FaultStat FloatEnableFault::_stat;
+FaultPriority UnimplementedSTD::_priority = 6;
+FaultStat     UnimplementedSTD::_count;
+
+FaultName     FpDisabled::_name = "fp_disabled";
+TrapType      FpDisabled::_trapType = 0x020;
+FaultPriority FpDisabled::_priority = 8;
+FaultStat     FpDisabled::_count;
+
+FaultName     FpExceptionIEEE754::_name = "fp_754";
+TrapType      FpExceptionIEEE754::_trapType = 0x021;
+FaultPriority FpExceptionIEEE754::_priority = 11;
+FaultStat     FpExceptionIEEE754::_count;
+
+FaultName     FpExceptionOther::_name = "fp_other";
+TrapType      FpExceptionOther::_trapType = 0x022;
+FaultPriority FpExceptionOther::_priority = 11;
+FaultStat     FpExceptionOther::_count;
+
+FaultName     TagOverflow::_name = "tag_overflow";
+TrapType      TagOverflow::_trapType = 0x023;
+FaultPriority TagOverflow::_priority = 14;
+FaultStat     TagOverflow::_count;
+
+FaultName     DivisionByZero::_name = "div_by_zero";
+TrapType      DivisionByZero::_trapType = 0x028;
+FaultPriority DivisionByZero::_priority = 15;
+FaultStat     DivisionByZero::_count;
+
+FaultName     DataAccessException::_name = "data_access";
+TrapType      DataAccessException::_trapType = 0x030;
+FaultPriority DataAccessException::_priority = 12;
+FaultStat     DataAccessException::_count;
+
+FaultName     DataAccessMMUMiss::_name = "data_mmu";
+TrapType      DataAccessMMUMiss::_trapType = 0x031;
+FaultPriority DataAccessMMUMiss::_priority = 12;
+FaultStat     DataAccessMMUMiss::_count;
+
+FaultName     DataAccessError::_name = "data_error";
+TrapType      DataAccessError::_trapType = 0x032;
+FaultPriority DataAccessError::_priority = 12;
+FaultStat     DataAccessError::_count;
+
+FaultName     DataAccessProtection::_name = "data_protection";
+TrapType      DataAccessProtection::_trapType = 0x033;
+FaultPriority DataAccessProtection::_priority = 12;
+FaultStat     DataAccessProtection::_count;
+
+FaultName     LDDFMemAddressNotAligned::_name = "unalign_lddf";
+TrapType      LDDFMemAddressNotAligned::_trapType = 0x035;
+FaultPriority LDDFMemAddressNotAligned::_priority = 10;
+FaultStat     LDDFMemAddressNotAligned::_count;
+
+FaultName     STDFMemAddressNotAligned::_name = "unalign_stdf";
+TrapType      STDFMemAddressNotAligned::_trapType = 0x036;
+FaultPriority STDFMemAddressNotAligned::_priority = 10;
+FaultStat     STDFMemAddressNotAligned::_count;
+
+FaultName     PrivelegedAction::_name = "priv_action";
+TrapType      PrivelegedAction::_trapType = 0x037;
+FaultPriority PrivelegedAction::_priority = 11;
+FaultStat     PrivelegedAction::_count;
+
+FaultName     LDQFMemAddressNotAligned::_name = "unalign_ldqf";
+TrapType      LDQFMemAddressNotAligned::_trapType = 0x038;
+FaultPriority LDQFMemAddressNotAligned::_priority = 10;
+FaultStat     LDQFMemAddressNotAligned::_count;
+
+FaultName     STQFMemAddressNotAligned::_name = "unalign_stqf";
+TrapType      STQFMemAddressNotAligned::_trapType = 0x039;
+FaultPriority STQFMemAddressNotAligned::_priority = 10;
+FaultStat     STQFMemAddressNotAligned::_count;
+
+FaultName     AsyncDataError::_name = "async_data";
+TrapType      AsyncDataError::_trapType = 0x040;
+FaultPriority AsyncDataError::_priority = 2;
+FaultStat     AsyncDataError::_count;
+
+//The enumerated faults
+
+FaultName     CleanWindow::_name = "clean_win";
+TrapType      CleanWindow::_baseTrapType = 0x024;
+FaultPriority CleanWindow::_priority = 10;
+FaultStat     CleanWindow::_count;
+
+FaultName     InterruptLevelN::_name = "interrupt_n";
+TrapType      InterruptLevelN::_baseTrapType = 0x041;
+FaultStat     InterruptLevelN::_count;
+
+FaultName     SpillNNormal::_name = "spill_n_normal";
+TrapType      SpillNNormal::_baseTrapType = 0x080;
+FaultPriority SpillNNormal::_priority = 9;
+FaultStat     SpillNNormal::_count;
+
+FaultName     SpillNOther::_name = "spill_n_other";
+TrapType      SpillNOther::_baseTrapType = 0x0A0;
+FaultPriority SpillNOther::_priority = 9;
+FaultStat     SpillNOther::_count;
+
+FaultName     FillNNormal::_name = "fill_n_normal";
+TrapType      FillNNormal::_baseTrapType = 0x0C0;
+FaultPriority FillNNormal::_priority = 9;
+FaultStat     FillNNormal::_count;
+
+FaultName     FillNOther::_name = "fill_n_other";
+TrapType      FillNOther::_baseTrapType = 0x0E0;
+FaultPriority FillNOther::_priority = 9;
+FaultStat     FillNOther::_count;
+
+FaultName     TrapInstruction::_name = "trap_inst_n";
+TrapType      TrapInstruction::_baseTrapType = 0x100;
+FaultPriority TrapInstruction::_priority = 16;
+FaultStat     TrapInstruction::_count;
 
-FaultName PalFault::_name = "pal";
-FaultVect PalFault::_vect = 0x2001;
-FaultStat PalFault::_stat;
 
-FaultName IntegerOverflowFault::_name = "intover";
-FaultVect IntegerOverflowFault::_vect = 0x0501;
-FaultStat IntegerOverflowFault::_stat;
 
 #if FULL_SYSTEM
 
-void AlphaFault::invoke(ExecContext * xc)
+void SparcFault::invoke(ExecContext * xc)
 {
-    DPRINTF(Fault, "Fault %s at PC: %#x\n", name(), xc->regs.pc);
+    FaultBase::invoke(xc);
-    xc->cpu->recordEvent(csprintf("Fault %s", name()));
+    countStat()++;
 
-    assert(!xc->misspeculating());
+    //Use the SPARC trap state machine
-    xc->kernelStats->fault(this);
+    /*// exception restart address
-
-    // exception restart address
     if (setRestartAddress() || !xc->inPalMode())
         xc->setMiscReg(AlphaISA::IPR_EXC_ADDR, xc->regs.pc);
 
@@ -123,48 +239,10 @@ void AlphaFault::invoke(ExecContext * xc)
         AlphaISA::swap_palshadow(&(xc->regs), true);
 
     xc->regs.pc = xc->readMiscReg(AlphaISA::IPR_PAL_BASE) + vect();
-    xc->regs.npc = xc->regs.pc + sizeof(MachInst);
+    xc->regs.npc = xc->regs.pc + sizeof(MachInst);*/
 }
 
-void ArithmeticFault::invoke(ExecContext * xc)
-{
-    DPRINTF(Fault, "Fault %s at PC: %#x\n", name(), xc->regs.pc);
-    xc->cpu->recordEvent(csprintf("Fault %s", name()));
-
-    assert(!xc->misspeculating());
-    xc->kernelStats->fault(this);
-
-    panic("Arithmetic traps are unimplemented!");
-}
-
-
-/*void ArithmeticFault::invoke(ExecContext * xc)
-{
-    panic("Arithmetic traps are unimplemented!");
-}*/
-
 #endif
 
-} // namespace AlphaISA
+} // namespace SparcISA
 
-/*Fault * ListOfFaults[] = {
-        (Fault *)&NoFault,
-        (Fault *)&ResetFault,
-        (Fault *)&MachineCheckFault,
-        (Fault *)&ArithmeticFault,
-        (Fault *)&InterruptFault,
-        (Fault *)&NDtbMissFault,
-        (Fault *)&PDtbMissFault,
-        (Fault *)&AlignmentFault,
-        (Fault *)&DtbPageFault,
-        (Fault *)&DtbAcvFault,
-        (Fault *)&ItbMissFault,
-        (Fault *)&ItbPageFault,
-        (Fault *)&ItbAcvFault,
-        (Fault *)&UnimplementedOpcodeFault,
-        (Fault *)&FloatEnableFault,
-        (Fault *)&PalFault,
-        (Fault *)&IntegerOverflowFault,
-        };
-
-int NumFaults = sizeof(ListOfFaults) / sizeof(Fault *);*/

arch/sparc/faults.hh

@@ -33,236 +33,555 @@
 
 // The design of the "name" and "vect" functions is in sim/faults.hh
 
-namespace AlphaISA
+namespace SparcISA
 {
 
-typedef const Addr FaultVect;
+typedef const uint32_t TrapType;
+typedef const uint32_t FaultPriority;
 
-class AlphaFault : public virtual FaultBase
+class SparcFault : public FaultBase
 {
-  protected:
-    virtual bool skipFaultingInstruction() {return false;}
-    virtual bool setRestartAddress() {return true;}
   public:
 #if FULL_SYSTEM
     void invoke(ExecContext * xc);
 #endif
-    virtual FaultVect vect() = 0;
+    virtual TrapType trapType() = 0;
+    virtual FaultPriority priority() = 0;
+    virtual FaultStat & countStat() = 0;
 };
 
-class MachineCheckFault : public AlphaFault
+class InternalProcessorError : public SparcFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _trapType;
-    static FaultStat _stat;
+    static FaultPriority _priority;
+    static FaultStat _count;
   public:
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    TrapType trapType() {return _trapType;}
-    FaultStat & stat() {return _stat;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
     bool isMachineCheckFault() {return true;}
 };
 
-class AlignmentFault : public AlphaFault
+class MemAddressNotAligned : public SparcFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _trapType;
-    static FaultStat _stat;
+    static FaultPriority _priority;
+    static FaultStat _count;
   public:
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    TrapType trapType() {return _trapType;}
-    FaultStat & stat() {return _stat;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
     bool isAlignmentFault() {return true;}
 };
 
 static inline Fault genMachineCheckFault()
 {
-    return new MachineCheckFault;
+    return new InternalProcessorError;
 }
 
 static inline Fault genAlignmentFault()
 {
-    return new AlignmentFault;
+    return new MemAddressNotAligned;
 }
 
-class ResetFault : public AlphaFault
+class PowerOnReset : public SparcFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _trapType;
-    static FaultStat _stat;
+    static FaultPriority _priority;
+    static FaultStat _count;
   public:
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    TrapType trapType() {return _trapType;}
-    FaultStat & stat() {return _stat;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
 };
 
-class ArithmeticFault : public AlphaFault
+class WatchDogReset : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class ExternallyInitiatedReset : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class SoftwareInitiatedReset : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class REDStateException : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class InstructionAccessException : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class InstructionAccessMMUMiss : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class InstructionAccessError : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class IllegalInstruction : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class PrivelegedOpcode : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class UnimplementedLDD : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class UnimplementedSTD : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class FpDisabled : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class FpExceptionIEEE754 : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class FpExceptionOther : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class TagOverflow : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class DivisionByZero : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class DataAccessException : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class DataAccessMMUMiss : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class DataAccessError : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class DataAccessProtection : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class LDDFMemAddressNotAligned : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class STDFMemAddressNotAligned : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class PrivelegedAction : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class LDQFMemAddressNotAligned : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class STQFMemAddressNotAligned : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class AsyncDataError : public SparcFault
+{
+  private:
+    static FaultName _name;
+    static TrapType _trapType;
+    static FaultPriority _priority;
+    static FaultStat _count;
+  public:
+    FaultName name() {return _name;}
+    TrapType trapType() {return _trapType;}
+    FaultPriority priority() {return _priority;}
+    FaultStat & countStat() {return _count;}
+};
+
+class EnumeratedFault : public SparcFault
 {
   protected:
-    bool skipFaultingInstruction() {return true;}
+    uint32_t _n;
-  private:
+    virtual TrapType baseTrapType() = 0;
-    static FaultName _name;
-    static FaultVect _vect;
-    static FaultStat _stat;
   public:
-    FaultName name() {return _name;}
+    EnumeratedFault(uint32_t n) : SparcFault() {_n = n;}
-    FaultVect vect() {return _vect;}
+    TrapType trapType() {return baseTrapType() + _n;}
-    FaultStat & stat() {return _stat;}
-#if FULL_SYSTEM
-    void invoke(ExecContext * xc);
-#endif
 };
 
-class InterruptFault : public AlphaFault
+class CleanWindow : public EnumeratedFault
-{
-  protected:
-    bool setRestartAddress() {return false;}
-  private:
-    static FaultName _name;
-    static FaultVect _vect;
-    static FaultStat _stat;
-  public:
-    FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
-    FaultStat & stat() {return _stat;}
-};
-
-class NDtbMissFault : public AlphaFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _baseTrapType;
-    static FaultStat _stat;
+    static FaultPriority _priority;
+    static FaultStat _count;
+    TrapType baseTrapType() {return _baseTrapType;}
   public:
+    CleanWindow(uint32_t n) : EnumeratedFault(n) {;}
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    FaultPriority priority() {return _priority;}
-    FaultStat & stat() {return _stat;}
+    FaultStat & countStat() {return _count;}
 };
 
-class PDtbMissFault : public AlphaFault
+class InterruptLevelN : public EnumeratedFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _baseTrapType;
-    static FaultStat _stat;
+    static FaultStat _count;
+    TrapType baseTrapType() {return _baseTrapType;}
   public:
+    InterruptLevelN(uint32_t n) : EnumeratedFault(n) {;}
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    FaultPriority priority() {return 32 - _n;}
-    FaultStat & stat() {return _stat;}
+    FaultStat & countStat() {return _count;}
 };
 
-class DtbPageFault : public AlphaFault
+class SpillNNormal : public EnumeratedFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _baseTrapType;
-    static FaultStat _stat;
+    static FaultPriority _priority;
+    static FaultStat _count;
+    TrapType baseTrapType() {return _baseTrapType;}
   public:
+    SpillNNormal(uint32_t n) : EnumeratedFault(n) {;}
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    FaultPriority priority() {return _priority;}
-    FaultStat & stat() {return _stat;}
+    FaultStat & countStat() {return _count;}
 };
 
-class DtbAcvFault : public AlphaFault
+class SpillNOther : public EnumeratedFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _baseTrapType;
-    static FaultStat _stat;
+    static FaultPriority _priority;
+    static FaultStat _count;
+    TrapType baseTrapType() {return _baseTrapType;}
   public:
+    SpillNOther(uint32_t n) : EnumeratedFault(n) {;}
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    FaultPriority priority() {return _priority;}
-    FaultStat & stat() {return _stat;}
+    FaultStat & countStat() {return _count;}
 };
 
-class ItbMissFault : public AlphaFault
+class FillNNormal : public EnumeratedFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _baseTrapType;
-    static FaultStat _stat;
+    static FaultPriority _priority;
+    static FaultStat _count;
+    TrapType baseTrapType() {return _baseTrapType;}
   public:
+    FillNNormal(uint32_t n) : EnumeratedFault(n) {;}
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    FaultPriority priority() {return _priority;}
-    FaultStat & stat() {return _stat;}
+    FaultStat & countStat() {return _count;}
 };
 
-class ItbPageFault : public AlphaFault
+class FillNOther : public EnumeratedFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _baseTrapType;
-    static FaultStat _stat;
+    static FaultPriority _priority;
+    static FaultStat _count;
+    TrapType baseTrapType() {return _baseTrapType;}
   public:
+    FillNOther(uint32_t n) : EnumeratedFault(n) {;}
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    FaultPriority priority() {return _priority;}
-    FaultStat & stat() {return _stat;}
+    FaultStat & countStat() {return _count;}
 };
 
-class ItbAcvFault : public AlphaFault
+class TrapInstruction : public EnumeratedFault
 {
   private:
     static FaultName _name;
-    static FaultVect _vect;
+    static TrapType _baseTrapType;
-    static FaultStat _stat;
+    static FaultPriority _priority;
+    static FaultStat _count;
+    TrapType baseTrapType() {return _baseTrapType;}
   public:
+    TrapInstruction(uint32_t n) : EnumeratedFault(n) {;}
     FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
+    FaultPriority priority() {return _priority;}
-    FaultStat & stat() {return _stat;}
+    FaultStat & countStat() {return _count;}
 };
 
-class UnimplementedOpcodeFault : public AlphaFault
+} // SparcISA namespace
-{
-  private:
-    static FaultName _name;
-    static FaultVect _vect;
-    static FaultStat _stat;
-  public:
-    FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
-    FaultStat & stat() {return _stat;}
-};
-
-class FloatEnableFault : public AlphaFault
-{
-  private:
-    static FaultName _name;
-    static FaultVect _vect;
-    static FaultStat _stat;
-  public:
-    FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
-    FaultStat & stat() {return _stat;}
-};
-
-class PalFault : public AlphaFault
-{
-  protected:
-    bool skipFaultingInstruction() {return true;}
-  private:
-    static FaultName _name;
-    static FaultVect _vect;
-    static FaultStat _stat;
-  public:
-    FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
-    FaultStat & stat() {return _stat;}
-};
-
-class IntegerOverflowFault : public AlphaFault
-{
-  private:
-    static FaultName _name;
-    static FaultVect _vect;
-    static FaultStat _stat;
-  public:
-    FaultName name() {return _name;}
-    FaultVect vect() {return _vect;}
-    FaultStat & stat() {return _stat;}
-};
-
-} // AlphaISA namespace
 
 #endif // __FAULTS_HH__