Changeset 65834 in vbox for trunk/src/VBox

Timestamp:

Feb 21, 2017 4:21:36 PM (8 years ago)

Author:

vboxsync

Message:

IEMAllInstructionsPython.py: some more tinkering.

Location:

trunk/src/VBox/VMM/VMMAll

Files:

• IEMAllInstructionsOneByte.cpp.h (modified) (1 diff)
• IEMAllInstructionsPython.py (modified) (12 diffs)

trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsOneByte.cpp.h

@@ -57 +57 @@
  * @opstats     add_Eb_Gb
  * @opgroup     op_gen_arith_bin
- * @optest                  op1=1 op2=1 -> op1=2 efl&~=a?,p?
- * @optest      o32 /   op1=0xfffffffe:dw in2=1:dw -> out1=0xffffffff:dw efl&~=a?,p?
+ * @optest                  op1=1 op2=1 -> op1=2 efl=of,sf,zf,af
+ * @optest      o32 /   op1=0xfffffffe op2=1 -> op1=0xffffffff efl=af,pe,up
  */
 FNIEMOP_DEF(iemOp_add_Eb_Gb)

trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsPython.py

@@ -72 +72 @@
 
 
+g_kdX86EFlagsConstants = {
+    'X86_EFL_CF':          0x00000001, # RT_BIT_32(0)
+    'X86_EFL_1':           0x00000002, # RT_BIT_32(1)
+    'X86_EFL_PF':          0x00000004, # RT_BIT_32(2)
+    'X86_EFL_AF':          0x00000010, # RT_BIT_32(4)
+    'X86_EFL_ZF':          0x00000040, # RT_BIT_32(6)
+    'X86_EFL_SF':          0x00000080, # RT_BIT_32(7)
+    'X86_EFL_TF':          0x00000100, # RT_BIT_32(8)
+    'X86_EFL_IF':          0x00000200, # RT_BIT_32(9)
+    'X86_EFL_DF':          0x00000400, # RT_BIT_32(10)
+    'X86_EFL_OF':          0x00000800, # RT_BIT_32(11)
+    'X86_EFL_IOPL':        0x00003000, # (RT_BIT_32(12) | RT_BIT_32(13))
+    'X86_EFL_NT':          0x00004000, # RT_BIT_32(14)
+    'X86_EFL_RF':          0x00010000, # RT_BIT_32(16)
+    'X86_EFL_VM':          0x00020000, # RT_BIT_32(17)
+    'X86_EFL_AC':          0x00040000, # RT_BIT_32(18)
+    'X86_EFL_VIF':         0x00080000, # RT_BIT_32(19)
+    'X86_EFL_VIP':         0x00100000, # RT_BIT_32(20)
+    'X86_EFL_ID':          0x00200000, # RT_BIT_32(21)
+    'X86_EFL_LIVE_MASK':   0x003f7fd5, # UINT32_C(0x003f7fd5)
+    'X86_EFL_RA1_MASK':    0x00000002, # RT_BIT_32(1)
+};
+
+
 def _isValidOpcodeByte(sOpcode):
     """
@@ -136 +160 @@
     possible to override fUnsigned=True by prefixing the value with '+' or '-'.
     """
-    def __init__(self, sName, fUnsigned = True):
+    def __init__(self, sName, acbSizes = None, fUnsigned = True):
         self.sName = sName;
+        self.acbSizes = [1, 2, 4, 8, 16, 32] if acbSizes is None else acbSizes;  # Normal sizes.
         self.fUnsigned = fUnsigned;
 
@@ -143 +168 @@
         """ Bad value exception. """
         def __init__(self, sMessage):
-            Exception.__init__(sMessage);
+            Exception.__init__(self, sMessage);
             self.sMessage = sMessage;
 
     def get(self, sValue):
         """
-        Get the shortest byte representation of oValue.
-
-        Returns (fSignExtend, bytearray)
+        Get the shortest normal sized byte representation of oValue.
+
+        Returns ((fSignExtend, bytearray), ) or ((fSignExtend, bytearray), (fSignExtend, bytearray), ).
+        The latter form is for AND+OR pairs where the first entry is what to
+        AND with the field and the second the one or OR with.
+
         Raises BadValue if invalid value.
-
-        The returned byte array is a reasonable size, e.g. for an integer type
-        it's for instance 1, 2, 4, or 8 byte in size but never 3, 5 or 7 bytes.
         """
         if len(sValue) == 0:
@@ -163 +188 @@
         if sValue[0] == '-' or sValue[0] == '+':
             fSignExtend = True;
-            fHex = len(sValue) > 3 and sValue[1:2].lower() == '0x';
+            fHex = len(sValue) > 3 and sValue[1:3].lower() == '0x';
         else:
             fHex = len(sValue) > 2 and sValue[0:2].lower() == '0x';
@@ -170 +195 @@
         try:
             iValue = long(sValue, 16 if fHex else 10);
-        except:
-            raise TestType.BadValue('failed to convert "%s" to integer' % (iValue,));
+        except Exception as oXcpt:
+            raise TestType.BadValue('failed to convert "%s" to integer (%s)' % (sValue, oXcpt));
 
         # Convert the hex string and pad it to a decent value.
-        sHex = hex(iValue);
+        if iValue >= 0:
+            sHex = hex(iValue);
+        else:
+            sHex = hex(iValue);
         assert sHex[:2] == '0x', sHex;
         if sys.version_info[0] >= 3:
@@ -183 +211 @@
 
         cDigits = len(sHex);
-        if cDigits <= 2:
-            cDigits = (cDigits + 1) & ~1;
-        elif cDigits <= 4:
-            cDigits = (cDigits + 3) & ~3;
-        elif cDigits <= 8:
-            cDigits = (cDigits + 7) & ~7;
+        if cDigits <= self.acbSizes[-1] * 2:
+            for cb in self.acbSizes:
+                if cDigits <= cb * 2:
+                    cDigits = int((cDigits + cb - 1) / cb) * cb; # Seems like integer division returns a float in python.
+                    break;
         else:
-            cDigits = (cDigits + 15) & ~15;
+            cDigits = int((cDigits + self.acbSizes[-1] - 1) / self.acbSizes[-1]) * self.acbSizes[-1];
+            assert isinstance(cDigits, int)
 
         if cDigits != len(sHex):
+            cNeeded = cDigits - len(sHex);
             if iValue >= 0:
-                sHex = '0' * (cDigits - len(sHex)) + sHex;
+                sHex = ('0' * cNeeded) + sHex;
             else:
-                sHex = 'f' * (cDigits - len(sHex)) + sHex;
+                sHex = ('f' * cNeeded) + sHex;
 
         # Invert and convert to bytearray and return it.
         abValue = bytearray([int(sHex[offHex - 2 : offHex], 16) for offHex in range(len(sHex), 0, -2)]);
 
-        return (fSignExtend, abValue);
+        return ((fSignExtend, abValue),);
 
     def validate(self, sValue):
@@ -213 +242 @@
         return True;
 
+    def isAndOrPair(self, sValue):
+        """
+        Checks if sValue is a pair.
+        """
+        return False;
 
 
@@ -220 +254 @@
     """
 
+    kdZeroValueFlags = { 'nv': 0, 'pl': 0, 'nz': 0, 'na': 0, 'pe': 0, 'nc': 0, 'di': 0, 'up': 0 };
+
     def __init__(self, sName):
-        TestType.__init__(self, sName, fUnsigned = True);
+        TestType.__init__(self, sName, acbSizes = [1, 2, 4, 8], fUnsigned = True);
 
     def get(self, sValue):
-
-        return None;
+        print('get(%s)' % (sValue,));
+        fClear = 0;
+        fSet   = 0;
+        for sFlag in sValue.split(','):
+            sConstant = SimpleParser.kdEFlags.get(sFlag, None);
+            if sConstant is None:
+                print('get(%s) raise for %s/%s' % (sValue, sFlag,sConstant));
+                raise self.BadValue('Unknown flag "%s" in "%s"' % (sFlag, sValue))
+            if sConstant[0] == '!':
+                fClear |= g_kdX86EFlagsConstants[sConstant[1:]];
+            else:
+                fSet   |= g_kdX86EFlagsConstants[sConstant];
+
+        print('get -> TestType.get');
+        aoSet = TestType.get(self, '0x%x' % (fSet,));
+        print('get: aoSet=%s' % (aoSet,));
+        if fClear != 0:
+            print('get -> TestType.get(%#x)' % (~fClear));
+            try:
+                aoClear = TestType.get(self, '%#x' % (~fClear))
+            except Exception as oXcpt:
+                print( '%s' % (oXcpt,))
+                raise;
+            print('get: aoClear=%s' % (aoSet,));
+            assert self.isAndOrPair(sValue) == True;
+            return (aoClear[0], aoSet[0]);
+        assert self.isAndOrPair(sValue) == False;
+        return aoSet;
+
+    def isAndOrPair(self, sValue):
+        for sZeroFlag in self.kdZeroValueFlags.keys():
+            if sValue.find(sZeroFlag) >= 0:
+                print('isAndOrPair(%s) -> True' % (sValue,));
+                return True;
+        print('isAndOrPair(%s) -> False' % (sValue,));
+        return False;
 
 
@@ -427 +497 @@
         assert sVariable in self.kdVariables;
         assert sOp in self.kasCompareOps;
-        assert sValue in self.kdVariables[sValue];
+        assert sValue in self.kdVariables[sVariable];
         self.sVariable  = sVariable;
         self.sOp        = sOp;
@@ -1514 +1584 @@
                                     oValid = TestInOut.kdTypes[sType].validate(sValue);
                                     if oValid is True:
-                                        oItem = TestInOut(sField, sOp, sValue, sType);
+                                        if not TestInOut.kdTypes[sType].isAndOrPair(sValue) or sOp == '!=':
+                                            oItem = TestInOut(sField, sOp, sValue, sType);
+                                        else:
+                                            self.errorComment(iTagLine,
+                                                              '%s: and-or value "%s" can only be used with the "="'
+                                                                        % ( sTag, sDesc, sValue, sItem, sType, ));
                                     else:
                                         self.errorComment(iTagLine, '%s: invalid %s value "%s" in "%s" (type: %s)'
@@ -1533 +1608 @@
                         aoDst.append(oItem);
                     else:
-                        fRc = self.errorComment(iTagLine, '%s: failed to parse selector: %s' % ( sTag, sItem,));
+                        fRc = self.errorComment(iTagLine, '%s: failed to parse assignment: %s' % ( sTag, sItem,));
 
             #
@@ -1694 +1769 @@
 
         #
+        # Process the final tag.
+        #
+        if sCurTag in self.dTagHandlers:
+            self.dTagHandlers[sCurTag](sCurTag, aasSections, iCurTagLine, iLine);
+            cOpTags += 1;
+        elif sCurTag.startswith('@op'):
+            self.errorComment(iCurTagLine, 'Unknown tag: %s' % (sCurTag));
+        elif sCurTag == '@default':
+            sFlatDefault = self.flattenAllSections(aasSections);
+
+        #
         # Don't allow default text in blocks containing @op*.
         #