1 files changed, 21 insertions, 33 deletions

diff --git a/src/arch/x86/isa/macroop.isa b/src/arch/x86/isa/macroop.isa
index 2d928d7c9..8453a4fe9 100644
--- a/src/arch/x86/isa/macroop.isa
+++ b/src/arch/x86/isa/macroop.isa
@@ -111,6 +111,12 @@ output header {{
         };
 }};
 
+//////////////////////////////////////////////////////////////////////////////
+//
+//  X86 specific
+//
+//////////////////////////////////////////////////////////////////////////////
+
 // Basic instruction class declaration template.
 def template MacroDeclare {{
         namespace X86Macroop
@@ -122,17 +128,19 @@ def template MacroDeclare {{
             {
               public:
                 // Constructor.
-                %(class_name)s(ExtMachInst machInst, EmulEnv env);
+                %(class_name)s(ExtMachInst machInst, X86ISA::EmulEnv env);
             };
         };
 }};
 
 // Basic instruction class constructor template.
 def template MacroConstructor {{
-        inline X86Macroop::%(class_name)s::%(class_name)s(ExtMachInst machInst, EmulEnv env)
+        inline X86Macroop::%(class_name)s::%(class_name)s(
+                ExtMachInst machInst, EmulEnv env)
             : %(base_class)s("%(mnemonic)s", machInst, %(num_microops)s)
         {
             %(adjust_env)s;
+            %(do_modrm)s;
             %(constructor)s;
             //alloc_microops is the code that sets up the microops
             //array in the parent class.
@@ -140,11 +148,6 @@ def template MacroConstructor {{
         }
 }};
 
-//////////////////////////////////////////////////////////////////////////////
-//
-//  X86 specific
-//
-
 let {{
     from micro_asm import Combinational_Macroop, Rom_Macroop
     class X86Macroop(Combinational_Macroop):
@@ -157,6 +160,7 @@ let {{
             }
             self.declared = False
             self.adjust_env = ""
+            self.doModRM = ""
         def getAllocator(self, env):
             return "new X86Macroop::%s(machInst, %s)" % (self.name, env.getAllocator())
         def getDeclaration(self):
@@ -180,30 +184,11 @@ let {{
             iop = InstObjParams(self.name, self.name, "Macroop",
                                 {"code" : "", "num_microops" : numMicroops,
                                  "alloc_microops" : allocMicroops,
-                                 "adjust_env" : self.adjust_env})
+                                 "adjust_env" : self.adjust_env,
+                                 "do_modrm" : self.doModRM})
             return MacroConstructor.subst(iop);
 }};
 
-output header {{
-    struct EmulEnv
-    {
-        X86ISA::RegIndex reg;
-        X86ISA::RegIndex regm;
-        uint64_t immediate;
-        uint64_t displacement;
-        int addressSize;
-        int dataSize;
-
-        EmulEnv(X86ISA::RegIndex _reg, X86ISA::RegIndex _regm,
-                uint64_t _immediate, uint64_t _displacement,
-                int _addressSize, int _dataSize) :
-            reg(_reg), regm(_regm),
-            immediate(_immediate), displacement(_displacement),
-            addressSize(_addressSize), dataSize(_dataSize)
-        {;}
-    };
-}};
-
 let {{
     class EmulEnv(object):
         def __init__(self):
@@ -211,17 +196,17 @@ let {{
             self.regUsed = False
             self.regm = "0"
             self.regmUsed = False
-            self.immediate = "IMMEDIATE"
-            self.displacement = "DISPLACEMENT"
             self.addressSize = "ADDRSIZE"
             self.dataSize = "OPSIZE"
+            self.stackSize = "STACKSIZE"
+            self.doModRM = False
+
         def getAllocator(self):
             return '''EmulEnv(%(reg)s,
                               %(regm)s,
-                              %(immediate)s,
-                              %(displacement)s,
+                              %(dataSize)s,
                               %(addressSize)s,
-                              %(dataSize)s)''' % \
+                              %(stackSize)s)''' % \
                 self.__dict__
         def addReg(self, reg):
             if not self.regUsed:
@@ -235,12 +220,15 @@ let {{
 }};
 
 let {{
+    doModRMString = "env.doModRM(machInst);\n"
     def genMacroop(Name, env):
         blocks = OutputBlocks()
         if not macroopDict.has_key(Name):
             raise Exception, "Unrecognized instruction: %s" % Name
         macroop = macroopDict[Name]
         if not macroop.declared:
+            if env.doModRM:
+                macroop.doModRM = doModRMString
             blocks.header_output = macroop.getDeclaration()
             blocks.decoder_output = macroop.getDefinition()
             macroop.declared = True