1 files changed, 47 insertions, 25 deletions

diff --git a/src/arch/x86/predecoder.cc b/src/arch/x86/predecoder.cc
index 573012ee6..3ed18aeb2 100644
--- a/src/arch/x86/predecoder.cc
+++ b/src/arch/x86/predecoder.cc
@@ -62,6 +62,24 @@
 
 namespace X86ISA
 {
+    void Predecoder::reset()
+    {
+        origPC = basePC + offset;
+        DPRINTF(Predecoder, "Setting origPC to %#x\n", origPC);
+        emi.rex = 0;
+        emi.legacy = 0;
+        emi.opcode.num = 0;
+
+        immediateCollected = 0;
+        emi.immediate = 0;
+        displacementCollected = 0;
+        emi.displacement = 0;
+
+        emi.modRM = 0;
+        emi.sib = 0;
+        emi.mode = 0;
+    }
+
     void Predecoder::process()
     {
         //This function drives the predecoder state machine.
@@ -78,6 +96,9 @@ namespace X86ISA
             uint8_t nextByte = getNextByte();
             switch(state)
             {
+              case ResetState:
+                reset();
+                state = PrefixState;
               case PrefixState:
                 state = doPrefixState(nextByte);
                 break;
@@ -150,7 +171,6 @@ namespace X86ISA
             emi.rex = nextByte;
             break;
           case 0:
-            emi.opcode.num = 0;
             nextState = OpcodeState;
             break;
           default:
@@ -188,55 +208,50 @@ namespace X86ISA
             DPRINTF(Predecoder, "Found opcode %#x.\n", nextByte);
             emi.opcode.op = nextByte;
 
-            //Prepare for any immediate/displacement we might need
-            immediateCollected = 0;
-            emi.immediate = 0;
-            displacementCollected = 0;
-            emi.displacement = 0;
-
             //Figure out the effective operand size. This can be overriden to
             //a fixed value at the decoder level.
+            int logOpSize;
             if(/*FIXME long mode*/1)
             {
-                if(emi.rex && emi.rex.w)
-                    emi.opSize = 3; // 64 bit operand size
+                if(emi.rex.w)
+                    logOpSize = 3; // 64 bit operand size
                 else if(emi.legacy.op)
-                    emi.opSize = 1; // 16 bit operand size
+                    logOpSize = 1; // 16 bit operand size
                 else
-                    emi.opSize = 2; // 32 bit operand size
+                    logOpSize = 2; // 32 bit operand size
             }
             else if(/*FIXME default 32*/1)
             {
                 if(emi.legacy.op)
-                    emi.opSize = 1; // 16 bit operand size
+                    logOpSize = 1; // 16 bit operand size
                 else
-                    emi.opSize = 2; // 32 bit operand size
+                    logOpSize = 2; // 32 bit operand size
             }
             else // 16 bit default operand size
             {
                 if(emi.legacy.op)
-                    emi.opSize = 2; // 32 bit operand size
+                    logOpSize = 2; // 32 bit operand size
                 else
-                    emi.opSize = 1; // 16 bit operand size
+                    logOpSize = 1; // 16 bit operand size
             }
 
             //Figure out how big of an immediate we'll retreive based
             //on the opcode.
             int immType = ImmediateType[emi.opcode.num - 1][nextByte];
-            immediateSize = SizeTypeToSize[emi.opSize - 1][immType];
+            immediateSize = SizeTypeToSize[logOpSize - 1][immType];
+
+            //Set the actual op size
+            emi.opSize = 1 << logOpSize;
 
             //Determine what to expect next
             if (UsesModRM[emi.opcode.num - 1][nextByte]) {
                 nextState = ModRMState;
             } else {
-                //If there's no modRM byte, set it to 0 so we can detect
-                //that later.
-                emi.modRM = 0;
                 if(immediateSize) {
                     nextState = ImmediateState;
                 } else {
                     emiIsReady = true;
-                    nextState = PrefixState;
+                    nextState = ResetState;
                 }
             }
         }
@@ -282,7 +297,7 @@ namespace X86ISA
             nextState = ImmediateState;
         } else {
             emiIsReady = true;
-            nextState = PrefixState;
+            nextState = ResetState;
         }
         //The ModRM byte is consumed no matter what
         consumeByte();
@@ -304,7 +319,7 @@ namespace X86ISA
             nextState = ImmediateState;
         } else {
             emiIsReady = true;
-            nextState = PrefixState;
+            nextState = ResetState;
         }
         return nextState;
     }
@@ -344,7 +359,7 @@ namespace X86ISA
                 nextState = ImmediateState;
             } else {
                 emiIsReady = true;
-                nextState = PrefixState;
+                nextState = ResetState;
             }
         }
         else
@@ -375,12 +390,19 @@ namespace X86ISA
             //Instructions which use true 64 bit immediates won't be
             //affected, and instructions that use true 32 bit immediates
             //won't notice.
-            if(immediateSize == 4)
+            switch(immediateSize)
+            {
+              case 4:
                 emi.immediate = sext<32>(emi.immediate);
+                break;
+              case 1:
+                emi.immediate = sext<8>(emi.immediate);
+            }
+
             DPRINTF(Predecoder, "Collected immediate %#x.\n",
                     emi.immediate);
             emiIsReady = true;
-            nextState = PrefixState;
+            nextState = ResetState;
         }
         else
             nextState = ImmediateState;