sparc: Pull StaticInst base classes out of the ISA description.

Also, do some minor refactoring to use a BitUnion to pull apart
condition codes, etc.

Change-Id: I0c88878b07a731d0c0fe30f264f53dd795db99ae
Reviewed-on: https://gem5-review.googlesource.com/5421
Reviewed-by: Jason Lowe-Power <jason@lowepower.com>
Maintainer: Gabe Black <gabeblack@google.com>

1 files changed, 77 insertions, 79 deletions

diff --git a/src/arch/sparc/isa/formats/basic.isa b/src/arch/sparc/isa/formats/basic.isa
index 63f3e4a6c..a6b15388d 100644
--- a/src/arch/sparc/isa/formats/basic.isa
+++ b/src/arch/sparc/isa/formats/basic.isa
@@ -30,121 +30,119 @@
 
 // Basic instruction class declaration template.
 def template BasicDeclare {{
-        /**
-         * Static instruction class for "%(mnemonic)s".
-         */
-        class %(class_name)s : public %(base_class)s
-        {
-          public:
-            // Constructor.
-            %(class_name)s(ExtMachInst machInst);
-            Fault execute(ExecContext *, Trace::InstRecord *) const;
-        };
+/**
+ * Static instruction class for "%(mnemonic)s".
+ */
+class %(class_name)s : public %(base_class)s
+{
+  public:
+    // Constructor.
+    %(class_name)s(ExtMachInst machInst);
+    Fault execute(ExecContext *, Trace::InstRecord *) const;
+};
 }};
 
 // Basic instruction class declaration template.
 def template FpBasicDeclare {{
-        /**
-         * Static instruction class for "%(mnemonic)s".
-         */
-        class %(class_name)s : public %(base_class)s
-        {
-          public:
-            // Constructor.
-            %(class_name)s(ExtMachInst machInst);
-            Fault execute(ExecContext *, Trace::InstRecord *) const;
-            Fault doFpOp(ExecContext *,
-                         Trace::InstRecord *) const M5_NO_INLINE;
-        };
+/**
+ * Static instruction class for "%(mnemonic)s".
+ */
+class %(class_name)s : public %(base_class)s
+{
+  public:
+    // Constructor.
+    %(class_name)s(ExtMachInst machInst);
+    Fault execute(ExecContext *, Trace::InstRecord *) const;
+    Fault doFpOp(ExecContext *, Trace::InstRecord *) const M5_NO_INLINE;
+};
 }};
 
 // Basic instruction class declaration template.
 def template BasicDeclareWithMnemonic {{
-        /**
-         * Static instruction class for "%(mnemonic)s".
-         */
-        class %(class_name)s : public %(base_class)s
-        {
-          public:
-            // Constructor.
-            %(class_name)s(const char * mnemonic, ExtMachInst machInst);
-            Fault execute(ExecContext *, Trace::InstRecord *) const;
-        };
+/**
+ * Static instruction class for "%(mnemonic)s".
+ */
+class %(class_name)s : public %(base_class)s
+{
+  public:
+    // Constructor.
+    %(class_name)s(const char *mnemonic, ExtMachInst machInst);
+    Fault execute(ExecContext *, Trace::InstRecord *) const;
+};
 }};
 
 // Basic instruction class constructor template.
 def template BasicConstructor {{
-        %(class_name)s::%(class_name)s(ExtMachInst machInst)
-            : %(base_class)s("%(mnemonic)s", machInst, %(op_class)s)
-        {
-                %(constructor)s;
-        }
+%(class_name)s::%(class_name)s(ExtMachInst machInst) :
+        %(base_class)s("%(mnemonic)s", machInst, %(op_class)s)
+{
+    %(constructor)s;
+}
 }};
 
 // Basic instruction class constructor template.
 def template BasicConstructorWithMnemonic {{
-        %(class_name)s::%(class_name)s(const char * mnemonic,
-                ExtMachInst machInst)
-            : %(base_class)s(mnemonic, machInst, %(op_class)s)
-        {
-                %(constructor)s;
-        }
+%(class_name)s::%(class_name)s(const char *mnemonic, ExtMachInst machInst) :
+        %(base_class)s(mnemonic, machInst, %(op_class)s)
+{
+    %(constructor)s;
+}
 }};
 
 // Basic instruction class execute method template.
 def template BasicExecute {{
-        Fault
-        %(class_name)s::execute(ExecContext *xc,
-                Trace::InstRecord *traceData) const
-        {
-            Fault fault = NoFault;
+Fault
+%(class_name)s::execute(ExecContext *xc,
+        Trace::InstRecord *traceData) const
+{
+    Fault fault = NoFault;
 
-            %(fp_enable_check)s;
-            %(op_decl)s;
-            %(op_rd)s;
-            %(code)s;
+    %(fp_enable_check)s;
+    %(op_decl)s;
+    %(op_rd)s;
+    %(code)s;
 
-            if (fault == NoFault) {
-                %(op_wb)s;
-            }
-            return fault;
-        }
+    if (fault == NoFault) {
+        %(op_wb)s;
+    }
+    return fault;
+}
 }};
 
 def template DoFpOpExecute {{
-        Fault
-        %(class_name)s::doFpOp(ExecContext *xc,
-                Trace::InstRecord *traceData) const
-        {
-            Fault fault = NoFault;
-            %(op_decl)s;
-            %(op_rd)s;
-            %(fp_code)s;
-            if (fault == NoFault) {
-                %(op_wb)s;
-            }
-            return fault;
-        }
+Fault
+%(class_name)s::doFpOp(ExecContext *xc, Trace::InstRecord *traceData) const
+{
+    Fault fault = NoFault;
+    %(op_decl)s;
+    %(op_rd)s;
+    %(fp_code)s;
+    if (fault == NoFault) {
+        %(op_wb)s;
+    }
+    return fault;
+}
 }};
 
 // Basic decode template.
 def template BasicDecode {{
-        return new %(class_name)s(machInst);
+return new %(class_name)s(machInst);
 }};
 
 // Basic decode template, passing mnemonic in as string arg to constructor.
 def template BasicDecodeWithMnemonic {{
-    return new %(class_name)s("%(mnemonic)s", machInst);
+return new %(class_name)s("%(mnemonic)s", machInst);
 }};
 
 // The most basic instruction format... used only for a few misc. insts
 def format BasicOperate(code, *flags) {{
-        code = filterDoubles(code)
-        iop = InstObjParams(name, Name, 'SparcStaticInst', code, flags)
-        header_output = BasicDeclare.subst(iop)
-        decoder_output = BasicConstructor.subst(iop)
-        decode_block = BasicDecode.subst(iop)
-        exec_output = BasicExecute.subst(iop)
+    code = filterDoubles(code)
+    iop = InstObjParams(name, Name, 'SparcStaticInst', code, flags)
+    header_output = BasicDeclare.subst(iop)
+    decoder_output = BasicConstructor.subst(iop)
+    decode_block = BasicDecode.subst(iop)
+    exec_output = BasicExecute.subst(iop)
+
 }};
 
 def format FpBasic(code, *flags) {{
@@ -168,7 +166,7 @@ def format FpBasic(code, *flags) {{
 """
     fp_code = filterDoubles(code)
     iop = InstObjParams(name, Name, 'SparcStaticInst',
-            { "code" : exec_code, "fp_code" : fp_code }, flags)
+                        { "code" : exec_code, "fp_code" : fp_code }, flags)
     header_output = FpBasicDeclare.subst(iop)
     decoder_output = BasicConstructor.subst(iop)
     decode_block = BasicDecode.subst(iop)