arm: Merge ISA files with pseudo instructions

This changeset moves the pseudo instructions used to signal unknown
instructions and unimplemented instructions to the same source files
as the decoder fault.

2 files changed, 171 insertions, 0 deletions

diff --git a/src/arch/arm/insts/pseudo.cc b/src/arch/arm/insts/pseudo.cc
index 085db3613..de4a5afdc 100644
--- a/src/arch/arm/insts/pseudo.cc
+++ b/src/arch/arm/insts/pseudo.cc
@@ -11,6 +11,9 @@
  * unmodified and in its entirety in all distributions of the software,
  * modified or unmodified, in source code or in binary form.
  *
+ * Copyright (c) 2007-2008 The Florida State University
+ * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met: redistributions of source code must retain the above copyright
@@ -35,6 +38,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Authors: Andreas Sandberg
+ *          Stephen Hines
  */
 
 #include "arch/arm/insts/pseudo.hh"
@@ -99,3 +103,100 @@ DecoderFaultInst::generateDisassembly(Addr pc, const SymbolTable *symtab) const
 {
     return csprintf("gem5fault %s", faultName());
 }
+
+
+
+FailUnimplemented::FailUnimplemented(const char *_mnemonic,
+                                     ExtMachInst _machInst)
+    : ArmStaticInst(_mnemonic, _machInst, No_OpClass)
+{
+    // don't call execute() (which panics) if we're on a
+    // speculative path
+    flags[IsNonSpeculative] = true;
+}
+
+FailUnimplemented::FailUnimplemented(const char *_mnemonic,
+                                     ExtMachInst _machInst,
+                                     const std::string& _fullMnemonic)
+    : ArmStaticInst(_mnemonic, _machInst, No_OpClass),
+      fullMnemonic(_fullMnemonic)
+{
+    // don't call execute() (which panics) if we're on a
+    // speculative path
+    flags[IsNonSpeculative] = true;
+}
+
+Fault
+FailUnimplemented::execute(ExecContext *xc, Trace::InstRecord *traceData) const
+{
+    return std::make_shared<UndefinedInstruction>(machInst, false, mnemonic);
+}
+
+std::string
+FailUnimplemented::generateDisassembly(Addr pc, const SymbolTable *symtab) const
+{
+    return csprintf("%-10s (unimplemented)",
+                    fullMnemonic.size() ? fullMnemonic.c_str() : mnemonic);
+}
+
+
+
+WarnUnimplemented::WarnUnimplemented(const char *_mnemonic,
+                                     ExtMachInst _machInst)
+    : ArmStaticInst(_mnemonic, _machInst, No_OpClass), warned(false)
+{
+    // don't call execute() (which panics) if we're on a
+    // speculative path
+    flags[IsNonSpeculative] = true;
+}
+
+WarnUnimplemented::WarnUnimplemented(const char *_mnemonic,
+                                     ExtMachInst _machInst,
+                                     const std::string& _fullMnemonic)
+    : ArmStaticInst(_mnemonic, _machInst, No_OpClass), warned(false),
+      fullMnemonic(_fullMnemonic)
+{
+    // don't call execute() (which panics) if we're on a
+    // speculative path
+    flags[IsNonSpeculative] = true;
+}
+
+Fault
+WarnUnimplemented::execute(ExecContext *xc, Trace::InstRecord *traceData) const
+{
+    if (!warned) {
+        warn("\tinstruction '%s' unimplemented\n",
+             fullMnemonic.size() ? fullMnemonic.c_str() : mnemonic);
+        warned = true;
+    }
+
+    return NoFault;
+}
+
+std::string
+WarnUnimplemented::generateDisassembly(Addr pc, const SymbolTable *symtab) const
+{
+    return csprintf("%-10s (unimplemented)",
+                    fullMnemonic.size() ? fullMnemonic.c_str() : mnemonic);
+}
+
+
+
+FlushPipeInst::FlushPipeInst(const char *_mnemonic, ExtMachInst _machInst)
+    : ArmStaticInst(_mnemonic, _machInst, No_OpClass)
+{
+    flags[IsNonSpeculative] = true;
+}
+
+Fault
+FlushPipeInst::execute(ExecContext *xc, Trace::InstRecord *traceData) const
+{
+    Fault fault = std::make_shared<FlushPipe>();
+    return fault;
+}
+
+std::string
+FlushPipeInst::generateDisassembly(Addr pc, const SymbolTable *symtab) const
+{
+    return csprintf("%-10s (pipe flush)", mnemonic);
+}
diff --git a/src/arch/arm/insts/pseudo.hh b/src/arch/arm/insts/pseudo.hh
index 61be08270..3bf3b2c3a 100644
--- a/src/arch/arm/insts/pseudo.hh
+++ b/src/arch/arm/insts/pseudo.hh
@@ -11,6 +11,9 @@
  * unmodified and in its entirety in all distributions of the software,
  * modified or unmodified, in source code or in binary form.
  *
+ * Copyright (c) 2007-2008 The Florida State University
+ * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met: redistributions of source code must retain the above copyright
@@ -35,6 +38,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Authors: Andreas Sandberg
+ *          Stephen Hines
  */
 
 #ifndef __ARCH_ARM_INSTS_PSEUDO_HH__
@@ -57,5 +61,71 @@ class DecoderFaultInst : public ArmStaticInst
     std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
 };
 
+/**
+ * Static instruction class for unimplemented instructions that
+ * cause simulator termination.  Note that these are recognized
+ * (legal) instructions that the simulator does not support; the
+ * 'Unknown' class is used for unrecognized/illegal instructions.
+ * This is a leaf class.
+ */
+class FailUnimplemented : public ArmStaticInst
+{
+  private:
+    /// Full mnemonic for MRC and MCR instructions including the
+    /// coproc. register name
+    std::string fullMnemonic;
+
+  public:
+    FailUnimplemented(const char *_mnemonic, ExtMachInst _machInst);
+    FailUnimplemented(const char *_mnemonic, ExtMachInst _machInst,
+                      const std::string& _fullMnemonic);
+
+    Fault execute(ExecContext *xc, Trace::InstRecord *traceData) const;
+
+    std::string
+    generateDisassembly(Addr pc, const SymbolTable *symtab) const;
+};
+
+/**
+ * Base class for unimplemented instructions that cause a warning
+ * to be printed (but do not terminate simulation).  This
+ * implementation is a little screwy in that it will print a
+ * warning for each instance of a particular unimplemented machine
+ * instruction, not just for each unimplemented opcode.  Should
+ * probably make the 'warned' flag a static member of the derived
+ * class.
+ */
+class WarnUnimplemented : public ArmStaticInst
+{
+  private:
+    /// Have we warned on this instruction yet?
+    mutable bool warned;
+    /// Full mnemonic for MRC and MCR instructions including the
+    /// coproc. register name
+    std::string fullMnemonic;
+
+  public:
+    WarnUnimplemented(const char *_mnemonic, ExtMachInst _machInst);
+    WarnUnimplemented(const char *_mnemonic, ExtMachInst _machInst,
+                      const std::string& _fullMnemonic);
+
+    Fault execute(ExecContext *xc, Trace::InstRecord *traceData) const;
+
+    std::string
+    generateDisassembly(Addr pc, const SymbolTable *symtab) const;
+};
+
+class FlushPipeInst : public ArmStaticInst
+{
+  public:
+    FlushPipeInst(const char *_mnemonic, ExtMachInst _machInst);
+
+    Fault execute(ExecContext *xc, Trace::InstRecord *traceData) const;
+
+    std::string
+    generateDisassembly(Addr pc, const SymbolTable *symtab) const;
+
+};
+
 
 #endif