Clean up of the SPARC isa description.

--HG--
extra : convert_revision : 21fe35fe4719f487168c89dd7bfc87dc38af0267

1 files changed, 99 insertions, 52 deletions

diff --git a/arch/sparc/isa/base.isa b/arch/sparc/isa/base.isa
index b504f1906..992504369 100644
--- a/arch/sparc/isa/base.isa
+++ b/arch/sparc/isa/base.isa
@@ -4,79 +4,126 @@
 //
 
 output header {{
+
+        struct condCodes
+        {
+            uint8_t c:1;
+            uint8_t v:1;
+            uint8_t z:1;
+            uint8_t n:1;
+        }
+
+        enum condTest
+        {
+            Always=0x8,
+            Never=0x0,
+            NotEqual=0x9,
+            Equal=0x1,
+            Greater=0xA,
+            LessOrEqual=0x2,
+            GreaterOrEqual=0xB,
+            Less=0x3,
+            GreaterUnsigned=0xC,
+            LessOrEqualUnsigned=0x4,
+            CarryClear=0xD,
+            CarrySet=0x5,
+            Positive=0xE,
+            Negative=0x6,
+            OverflowClear=0xF,
+            OverflowSet=0x7
+        }
+
         /**
          * Base class for all SPARC static instructions.
          */
-        class SparcStaticInst : public StaticInst<SPARCISA>
+        class SparcStaticInst : public StaticInst
         {
-        protected:
-
-                // Constructor.
-                SparcStaticInst(const char *mnem, MachInst _machInst, OpClass __opClass)
-                    : StaticInst<SPARCISA>(mnem, _machInst, __opClass)
+          protected:
+            // Constructor.
+            SparcStaticInst(const char *mnem,
+                 MachInst _machInst, OpClass __opClass)
+                    : StaticInst(mnem, _machInst, __opClass)
                 {
                 }
 
-                std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
+            std::string generateDisassembly(Addr pc,
+                const SymbolTable *symtab) const;
         };
 
-        bool passesCondition(struct {uint8_t c:1; uint8_t v:1; uint8_t z:1; uint8_t n:1} codes, uint8_t condition);
+        bool passesCondition(condCodes codes, condTest condition);
 }};
 
 output decoder {{
 
-        std::string SparcStaticInst::generateDisassembly(Addr pc, const SymbolTable *symtab) const
+        std::string SparcStaticInst::generateDisassembly(Addr pc,
+            const SymbolTable *symtab) const
         {
-                std::stringstream ss;
+            std::stringstream ss;
 
-                ccprintf(ss, "%-10s ", mnemonic);
+            ccprintf(ss, "%-10s ", mnemonic);
 
-                // just print the first two source regs... if there's
-                // a third one, it's a read-modify-write dest (Rc),
-                // e.g. for CMOVxx
-                if(_numSrcRegs > 0)
-                {
-                        printReg(ss, _srcRegIdx[0]);
-                }
-                if(_numSrcRegs > 1)
-                {
-                        ss << ",";
-                        printReg(ss, _srcRegIdx[1]);
-                }
+            // just print the first two source regs... if there's
+            // a third one, it's a read-modify-write dest (Rc),
+            // e.g. for CMOVxx
+            if(_numSrcRegs > 0)
+            {
+                printReg(ss, _srcRegIdx[0]);
+            }
+            if(_numSrcRegs > 1)
+            {
+                ss << ",";
+                printReg(ss, _srcRegIdx[1]);
+            }
 
-                // just print the first dest... if there's a second one,
-                // it's generally implicit
-                if(_numDestRegs > 0)
-                {
-                        if(_numSrcRegs > 0)
-                                ss << ",";
-                        printReg(ss, _destRegIdx[0]);
-                }
+            // just print the first dest... if there's a second one,
+            // it's generally implicit
+            if(_numDestRegs > 0)
+            {
+                if(_numSrcRegs > 0)
+                    ss << ",";
+                    printReg(ss, _destRegIdx[0]);
+            }
 
-                return ss.str();
+            return ss.str();
         }
 
-        bool passesCondition(struct {uint8_t c:1; uint8_t v:1; uint8_t z:1; uint8_t n:1} codes, uint8_t condition)
+        bool passesCondition(condCodes codes, condTest condition)
         {
-                switch(condition)
-                {
-                        case 0b1000: return true;
-                        case 0b0000: return false;
-                        case 0b1001: return !codes.z;
-                        case 0b0001: return codes.z;
-                        case 0b1010: return !(codes.z | (codes.n ^ codes.v));
-                        case 0b0010: return codes.z | (codes.n ^ codes.v);
-                        case 0b1011: return !(codes.n ^ codes.v);
-                        case 0b0011: return (codes.n ^ codes.v);
-                        case 0b1100: return !(codes.c | codes.z);
-                        case 0b0100: return (codes.c | codes.z);
-                        case 0b1101: return !codes.c;
-                        case 0b0101: return codes.c;
-                        case 0b1110: return !codes.n;
-                        case 0b0110: return codes.n;
-                        case 0b1111: return !codes.v;
-                        case 0b0111: return codes.v;
-                }
+            switch(condition)
+            {
+              case Always:
+                return true;
+              case Never:
+                return false;
+              case NotEqual:
+                return !codes.z;
+              case Equal:
+                return codes.z;
+              case Greater:
+                return !(codes.z | (codes.n ^ codes.v));
+              case LessOrEqual:
+                return codes.z | (codes.n ^ codes.v);
+              case GreaterOrEqual:
+                return !(codes.n ^ codes.v);
+              case Less:
+                return (codes.n ^ codes.v);
+              case GreaterUnsigned:
+                return !(codes.c | codes.z);
+              case LessOrEqualUnsigned:
+                return (codes.c | codes.z);
+              case CarryClear:
+                return !codes.c;
+              case CarrySet:
+                return codes.c;
+              case Positive:
+                return !codes.n;
+              case Negative:
+                return codes.n;
+              case OverflowClear:
+                return !codes.v;
+              case OverflowSet:
+                return codes.v;
+            }
         }
 }};