Changeset 100111 in vbox for trunk/src/VBox/VMM/VMMAll

Timestamp:

Jun 7, 2023 11:39:47 PM (21 months ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

157804

Message:

VMM/IEM: Working on parsing the IEM_MC_DEFER_TO_CIMPL_[0-9]_RET() macro invocations and treat them as a special McBlock case. bugref:10369

Location:

trunk/src/VBox/VMM/VMMAll

Files:

• IEMAllInstructionsPython.py (modified) (10 diffs)
• IEMAllThreadedPython.py (modified) (11 diffs)

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

@@ -1918 +1918 @@
 class McBlock(object):
     """
-    Microcode block (IEM_MC_BEGIN ... IEM_MC_END).
+    Microcode block (IEM_MC_BEGIN ... IEM_MC_END, IEM_MC_DEFER_TO_CIMPL_x_RET).
     """
 
     def __init__(self, sSrcFile, iBeginLine, offBeginLine, oFunction, iInFunction, cchIndent = None):
-        self.sSrcFile     = sSrcFile;                           ##< The source file containing the block.
-        self.iBeginLine   = iBeginLine;                         ##< The line with the IEM_MC_BEGIN statement.
-        self.offBeginLine = offBeginLine;                       ##< The offset of the IEM_MC_BEGIN statement within the line.
-        self.iEndLine     = -1;                                 ##< The line with the IEM_MC_END statement.
-        self.offEndLine   = 0;                                  ##< The offset of the IEM_MC_END statement within the line.
-        self.oFunction    = oFunction;                          ##< The function the block resides in.
-        self.sFunction    = oFunction.sName;                    ##< The name of the function the block resides in. DEPRECATED.
-        self.iInFunction  = iInFunction;                        ##< The block number wihtin the function.
+        ## The source file containing the block.
+        self.sSrcFile     = sSrcFile;
+        ## The line with the IEM_MC_BEGIN/IEM_MC_DEFER_TO_CIMPL_X_RET statement.
+        self.iBeginLine   = iBeginLine;
+        ## The offset of the IEM_MC_BEGIN/IEM_MC_DEFER_TO_CIMPL_X_RET statement within the line.
+        self.offBeginLine = offBeginLine;
+        ## The line with the IEM_MC_END statement / last line of IEM_MC_DEFER_TO_CIMPL_X_RET.
+        self.iEndLine     = -1;
+        ## The offset of the IEM_MC_END statement within the line / semicolon offset for defer-to.
+        self.offEndLine   = 0;
+        ## The offset following the IEM_MC_END/IEM_MC_DEFER_TO_CIMPL_X_RET semicolon.
+        self.offAfterEnd  = 0;
+        ## The function the block resides in.
+        self.oFunction    = oFunction;
+        ## The name of the function the block resides in. DEPRECATED.
+        self.sFunction    = oFunction.sName;
+        ## The block number within the function.
+        self.iInFunction  = iInFunction;
         self.cchIndent    = cchIndent if cchIndent else offBeginLine;
         self.asLines      = []              # type: list(str)   ##< The raw lines the block is made up of.
@@ -1935 +1945 @@
         self.aoStmts      = []              # type: list(McStmt)
 
-    def complete(self, iEndLine, offEndLine, asLines):
+    def complete(self, iEndLine, offEndLine, offAfterEnd, asLines):
         """
         Completes the microcode block.
@@ -1942 +1952 @@
         self.iEndLine     = iEndLine;
         self.offEndLine   = offEndLine;
+        self.offAfterEnd  = offAfterEnd;
         self.asLines      = asLines;
 
@@ -2432 +2443 @@
     def decode(self):
         """
-        Decodes the block, populating self.aoStmts.
+        Decodes the block, populating self.aoStmts if necessary.
         Returns the statement list.
         Raises ParserException on failure.
         """
-        self.aoStmts = self.decodeCode(''.join(self.asLines));
+        if not self.aoStmts:
+            self.aoStmts = self.decodeCode(''.join(self.asLines));
         return self.aoStmts;
 
@@ -2915 +2927 @@
         self.oReHashDefine3 = re.compile('(?s)\A\s*([A-Za-z_][A-Za-z0-9_]*)[^(]\s*(.*)\Z');        ##< Simple, no arguments.
         self.oReHashUndef   = re.compile('^\s*#\s*undef\s+(.*)$');
-        self.oReMcBeginEnd  = re.compile(r'\bIEM_MC_(BEGIN|END)\s*\(');
-
+        self.oReMcBeginEnd  = re.compile(r'\bIEM_MC_(BEGIN|END|DEFER_TO_CIMPL_[0-5]_RET)\s*\(');
         self.fDebug         = True;
         self.fDebugMc       = False;
@@ -4601 +4612 @@
         while asLines[-1].strip() == '':
             asLines.pop();
-        sFinal      = asLines[-1];
-        offFinalEnd = sFinal.find('IEM_MC_END');
+        sFinal        = asLines[-1];
+        offFinalEnd   = sFinal.find('IEM_MC_END');
+        offEndInFinal = offFinalEnd;
         if offFinalEnd < 0: self.raiseError('bogus IEM_MC_END: Not in final line: %s' % (sFinal,));
         offFinalEnd += len('IEM_MC_END');
@@ -4626 +4638 @@
         # Complete and discard the current block.
         #
-        self.oCurMcBlock.complete(self.iLine, offEndStatementInLine, asLines);
+        self.oCurMcBlock.complete(self.iLine, offEndStatementInLine,
+                                  offEndStatementInLine + offFinalEnd - offEndInFinal, asLines);
         self.oCurMcBlock = None;
+        return True;
+
+    def workerIemMcDeferToCImplXRet(self, sCode, offBeginStatementInCodeStr, offBeginStatementInLine, cParams):
+        """
+        Process a IEM_MC_DEFER_TO_CIMPL_[0-5]_RET macro invocation.
+        """
+        if self.fDebugMc:
+            self.debug('IEM_MC_DEFER_TO_CIMPL_%d_RET on %s off %s' % (cParams, self.iLine, offBeginStatementInLine,));
+            #self.debug('%s<eos>' % (sCode,));
+
+        # Check preconditions.
+        if not self.oCurFunction:
+            self.raiseError('IEM_MC_DEFER_TO_CIMPL_x_RET w/o current function (%s)' % (sCode,));
+        if self.oCurMcBlock:
+            self.raiseError('IEM_MC_DEFER_TO_CIMPL_x_RET inside IEM_MC_BEGIN blocki starting at line %u'
+                            % (self.oCurMcBlock.iBeginLine,));
+
+        # Figure out the indent level the block starts at, adjusting for expanded multiline macros.
+        cchIndent = offBeginStatementInCodeStr;
+        offPrevNewline = sCode.rfind('\n', 0, offBeginStatementInCodeStr);
+        if offPrevNewline >= 0:
+            cchIndent -= offPrevNewline + 1;
+        #self.debug('cchIndent=%s offPrevNewline=%s sFunc=%s' % (cchIndent, offPrevNewline, self.oCurFunction.sName));
+
+        # Start a new block.
+        oMcBlock = McBlock(self.sSrcFile, self.iLine, offBeginStatementInLine,
+                           self.oCurFunction, self.iMcBlockInFunc, cchIndent);
+
+        # Parse the statment (first call may advance self.iLine!).
+        offAfter, asArgs = self.findAndParseMacroInvocationEx(sCode[offBeginStatementInCodeStr:],
+                                                              'IEM_MC_DEFER_TO_CIMPL_%d_RET' % (cParams,));
+        if asArgs is None:
+            self.raiseError('IEM_MC_DEFER_TO_CIMPL_x_RET: Closing parenthesis not found!');
+        if len(asArgs) != cParams + 3:
+            self.raiseError('IEM_MC_DEFER_TO_CIMPL_%d_RET: findAndParseMacroInvocationEx returns %s args, expected %s!'
+                            % (cParams, len(asArgs), cParams + 3,));
+
+        oMcBlock.aoStmts = [McStmtCall(asArgs[0], asArgs[1:], 1),];
+
+        ## @todo complete this after some sleep...
+        _  = offAfter;
+        #asLines =
+
+        # Complete the block.
+        #oMcBlock.complete(self.iLine, offBeginStatementInCodeStr);
+
+        #g_aoMcBlocks.append(oMcBlock);
+        #self.cTotalMcBlocks += 1;
+        #self.iMcBlockInFunc += 1;
         return True;
 
@@ -4781 +4843 @@
                     if oMatch.group(1) == 'END':
                         self.workerIemMcEnd(offLine + oMatch.start());
+                    elif oMatch.group(1) == 'BEGIN':
+                        self.workerIemMcBegin(sCode, oMatch.start(), offLine + oMatch.start());
                     else:
-                        self.workerIemMcBegin(sCode, oMatch.start(), offLine + oMatch.start());
+                        self.workerIemMcDeferToCImplXRet(sCode, oMatch.start(), offLine + oMatch.start(),
+                                                         int(oMatch.group(1)[len('DEFER_TO_CIMPL_')]));
                 return True;
 
@@ -4952 +5017 @@
         """
         Parses the given file.
+
         Returns number or errors.
         Raises exception on fatal trouble.
@@ -4957 +5023 @@
         #self.debug('Parsing %s' % (self.sSrcFile,));
 
+        #
+        # Loop thru the lines.
+        #
+        # Please mind that self.iLine may be updated by checkCodeForMacro and
+        # other worker methods.
+        #
         while self.iLine < len(self.asLines):
             sLine = self.asLines[self.iLine];

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

@@ -171 +171 @@
         ksVariation_64_Addr32,
     );
+    kasVariationsEmitOrder = (
+        ksVariation_Default,
+        ksVariation_64,
+        ksVariation_32_Flat,
+        ksVariation_32,
+        ksVariation_16,
+        ksVariation_16_Addr32,
+        ksVariation_16_Pre386,
+        ksVariation_32_Addr16,
+        ksVariation_64_Addr32,
+    );
+    kdVariationNames = {
+        ksVariation_Default:    'defer-to-cimpl',
+        ksVariation_16:         '16-bit',
+        ksVariation_16_Addr32:  '16-bit w/ address prefix (Addr32)',
+        ksVariation_16_Pre386:  '16-bit on pre-386 CPU',
+        ksVariation_32:         '32-bit',
+        ksVariation_32_Flat:    '32-bit flat and wide open CS, SS, DS and ES',
+        ksVariation_32_Addr16:  '32-bit w/ address prefix (Addr16)',
+        ksVariation_64:         '64-bit',
+        ksVariation_64_Addr32:  '64-bit w/ address prefix (Addr32)',
+
+    };
     ## @}
 
@@ -187 +210 @@
         ## List/tree of statements for the threaded function.
         self.aoStmtsForThreadedFunction = [] # type: list(McStmt)
+
+        ## Function enum number, for verification. Set by generateThreadedFunctionsHeader.
+        self.iEnumValue     = -1;
 
     def getIndexName(self):
@@ -770 +796 @@
         ## Variations for this block. There is at least one.
         self.aoVariations   = []            # type: list(ThreadedFunctionVariation)
+        ## Variation dictionary containing the same as aoVariations.
+        self.dVariations    = {}            # type: dict(str,ThreadedFunctionVariation)
         ## Dictionary of local variables (IEM_MC_LOCAL[_CONST]) and call arguments (IEM_MC_ARG*).
         self.dVariables     = {}            # type: dict(str,McStmtVar)
@@ -829 +857 @@
                                  for sVar in ThreadedFunctionVariation.kasVariationsWithoutAddress];
 
+        # Dictionary variant of the list.
+        self.dVariations = { oVar.sVariation: oVar for oVar in self.aoVariations };
+
         # Continue the analysis on each variation.
         for oVariation in self.aoVariations:
@@ -846 +877 @@
 
         # Currently only have variations for address mode.
-        dByVari = { oVar.sVariation: oVar for oVar in self.aoVariations };
+        dByVari = self.dVariations;
 
         sExecMask = 'IEM_F_MODE_CPUMODE_MASK';
@@ -1080 +1111 @@
             '    kIemThreadedFunc_Invalid = 0,',
         ];
-        for oThreadedFunction in self.aoThreadedFuncs:
-            for oVariation in oThreadedFunction.aoVariations:
-                asLines.append('    ' + oVariation.getIndexName() + ',');
+        iThreadedFunction = 0;
+        for sVariation in ThreadedFunctionVariation.kasVariationsEmitOrder:
+            asLines += [
+                    '',
+                    '    /*',
+                    '     * Variation: ' + ThreadedFunctionVariation.kdVariationNames[sVariation] + '',
+                    '     */',
+            ];
+            for oThreadedFunction in self.aoThreadedFuncs:
+                oVariation = oThreadedFunction.dVariations.get(sVariation, None);
+                if oVariation:
+                    iThreadedFunction += 1;
+                    oVariation.iEnumValue = iThreadedFunction;
+                    asLines.append('    ' + oVariation.getIndexName() + ',');
         asLines += [
             '    kIemThreadedFunc_End',
@@ -1131 +1173 @@
         # Emit the function definitions.
         #
-        for oThreadedFunction in self.aoThreadedFuncs:
-            oMcBlock = oThreadedFunction.oMcBlock;
-            for oVariation in oThreadedFunction.aoVariations:
-                # Function header
-                oOut.write(  '\n'
-                           + '\n'
-                           + '/**\n'
-                           + ' * %s at line %s offset %s in %s%s\n'
-                              % (oMcBlock.sFunction, oMcBlock.iBeginLine, oMcBlock.offBeginLine,
-                                 os.path.split(oMcBlock.sSrcFile)[1],
-                                 ' (macro expansion)' if oMcBlock.iBeginLine == oMcBlock.iEndLine else '')
-                           + ' */\n'
-                           + 'static IEM_DECL_IMPL_DEF(VBOXSTRICTRC, ' + oVariation.getFunctionName() + ',\n'
-                           + '                         ' + sParamList
-                           + '{\n');
-
-                aasVars = [];
-                for aoRefs in oVariation.dParamRefs.values():
-                    oRef  = aoRefs[0];
-                    if oRef.sType[0] != 'P':
-                        cBits = g_kdTypeInfo[oRef.sType][0];
-                        sType = g_kdTypeInfo[oRef.sType][2];
-                    else:
-                        cBits = 64;
-                        sType = oRef.sType;
-
-                    sTypeDecl = sType + ' const';
-
-                    if cBits == 64:
-                        assert oRef.offNewParam == 0;
-                        if sType == 'uint64_t':
-                            sUnpack = 'uParam%s;' % (oRef.iNewParam,);
+        for sVariation in ThreadedFunctionVariation.kasVariationsEmitOrder:
+            sVarName = ThreadedFunctionVariation.kdVariationNames[sVariation];
+            oOut.write(  '\n'
+                       + '\n'
+                       + '\n'
+                       + '\n'
+                       + '/*' + '*' * 128 + '\n'
+                       + '*   Variation: ' + sVarName + ' ' * (129 - len(sVarName) - 15) + '*\n'
+                       + '*' * 128 + '*/\n');
+
+            for oThreadedFunction in self.aoThreadedFuncs:
+                oVariation = oThreadedFunction.dVariations.get(sVariation, None);
+                if oVariation:
+                    oMcBlock = oThreadedFunction.oMcBlock;
+
+                    # Function header
+                    oOut.write(  '\n'
+                               + '\n'
+                               + '/**\n'
+                               + ' * %s at line %s offset %s in %s%s\n'
+                                  % (oMcBlock.sFunction, oMcBlock.iBeginLine, oMcBlock.offBeginLine,
+                                     os.path.split(oMcBlock.sSrcFile)[1],
+                                     ' (macro expansion)' if oMcBlock.iBeginLine == oMcBlock.iEndLine else '')
+                               + ' */\n'
+                               + 'static IEM_DECL_IMPL_DEF(VBOXSTRICTRC, ' + oVariation.getFunctionName() + ',\n'
+                               + '                         ' + sParamList
+                               + '{\n');
+
+                    aasVars = [];
+                    for aoRefs in oVariation.dParamRefs.values():
+                        oRef  = aoRefs[0];
+                        if oRef.sType[0] != 'P':
+                            cBits = g_kdTypeInfo[oRef.sType][0];
+                            sType = g_kdTypeInfo[oRef.sType][2];
                         else:
-                            sUnpack = '(%s)uParam%s;' % (sType, oRef.iNewParam,);
-                    elif oRef.offNewParam == 0:
-                        sUnpack = '(%s)(uParam%s & %s);' % (sType, oRef.iNewParam, self.ksBitsToIntMask[cBits]);
-                    else:
-                        sUnpack = '(%s)((uParam%s >> %s) & %s);' \
-                                % (sType, oRef.iNewParam, oRef.offNewParam, self.ksBitsToIntMask[cBits]);
-
-                    sComment = '/* %s - %s ref%s */' % (oRef.sOrgRef, len(aoRefs), 's' if len(aoRefs) != 1 else '',);
-
-                    aasVars.append([ '%s:%02u' % (oRef.iNewParam, oRef.offNewParam),
-                                     sTypeDecl, oRef.sNewName, sUnpack, sComment ]);
-                acchVars = [0, 0, 0, 0, 0];
-                for asVar in aasVars:
-                    for iCol, sStr in enumerate(asVar):
-                        acchVars[iCol] = max(acchVars[iCol], len(sStr));
-                sFmt = '    %%-%ss %%-%ss = %%-%ss %%s\n' % (acchVars[1], acchVars[2], acchVars[3]);
-                for asVar in sorted(aasVars):
-                    oOut.write(sFmt % (asVar[1], asVar[2], asVar[3], asVar[4],));
-
-                # RT_NOREF for unused parameters.
-                if oVariation.cMinParams < g_kcThreadedParams:
-                    oOut.write('    RT_NOREF('
-                               + ', '.join(['uParam%u' % (i,) for i in range(oVariation.cMinParams, g_kcThreadedParams)])
-                               + ');\n');
-
-                # Now for the actual statements.
-                oOut.write(iai.McStmt.renderCodeForList(oVariation.aoStmtsForThreadedFunction, cchIndent = 4));
-
-                oOut.write('}\n');
+                            cBits = 64;
+                            sType = oRef.sType;
+
+                        sTypeDecl = sType + ' const';
+
+                        if cBits == 64:
+                            assert oRef.offNewParam == 0;
+                            if sType == 'uint64_t':
+                                sUnpack = 'uParam%s;' % (oRef.iNewParam,);
+                            else:
+                                sUnpack = '(%s)uParam%s;' % (sType, oRef.iNewParam,);
+                        elif oRef.offNewParam == 0:
+                            sUnpack = '(%s)(uParam%s & %s);' % (sType, oRef.iNewParam, self.ksBitsToIntMask[cBits]);
+                        else:
+                            sUnpack = '(%s)((uParam%s >> %s) & %s);' \
+                                    % (sType, oRef.iNewParam, oRef.offNewParam, self.ksBitsToIntMask[cBits]);
+
+                        sComment = '/* %s - %s ref%s */' % (oRef.sOrgRef, len(aoRefs), 's' if len(aoRefs) != 1 else '',);
+
+                        aasVars.append([ '%s:%02u' % (oRef.iNewParam, oRef.offNewParam),
+                                         sTypeDecl, oRef.sNewName, sUnpack, sComment ]);
+                    acchVars = [0, 0, 0, 0, 0];
+                    for asVar in aasVars:
+                        for iCol, sStr in enumerate(asVar):
+                            acchVars[iCol] = max(acchVars[iCol], len(sStr));
+                    sFmt = '    %%-%ss %%-%ss = %%-%ss %%s\n' % (acchVars[1], acchVars[2], acchVars[3]);
+                    for asVar in sorted(aasVars):
+                        oOut.write(sFmt % (asVar[1], asVar[2], asVar[3], asVar[4],));
+
+                    # RT_NOREF for unused parameters.
+                    if oVariation.cMinParams < g_kcThreadedParams:
+                        oOut.write('    RT_NOREF('
+                                   + ', '.join(['uParam%u' % (i,) for i in range(oVariation.cMinParams, g_kcThreadedParams)])
+                                   + ');\n');
+
+                    # Now for the actual statements.
+                    oOut.write(iai.McStmt.renderCodeForList(oVariation.aoStmtsForThreadedFunction, cchIndent = 4));
+
+                    oOut.write('}\n');
 
 
@@ -1207 +1261 @@
                    + '    /*Invalid*/ NULL, \n');
         iThreadedFunction = 0;
-        for oThreadedFunction in self.aoThreadedFuncs:
-            for oVariation in oThreadedFunction.aoVariations:
-                iThreadedFunction += 1;
-                oOut.write('    /*%4u*/ %s,\n' % (iThreadedFunction, oVariation.getFunctionName(),));
+        for sVariation in ThreadedFunctionVariation.kasVariationsEmitOrder:
+            oOut.write(  '\n'
+                       + '    /*\n'
+                       + '     * Variation: ' + ThreadedFunctionVariation.kdVariationNames[sVariation] + '\n'
+                       + '     */\n');
+            for oThreadedFunction in self.aoThreadedFuncs:
+                oVariation = oThreadedFunction.dVariations.get(sVariation, None);
+                if oVariation:
+                    iThreadedFunction += 1;
+                    assert oVariation.iEnumValue == iThreadedFunction;
+                    oOut.write('    /*%4u*/ %s,\n' % (iThreadedFunction, oVariation.getFunctionName(),));
         oOut.write('};\n');
 
@@ -1223 +1284 @@
             return self.aoThreadedFuncs[idx];
         return ThreadedFunction.dummyInstance();
-
-    def findEndOfMcEndStmt(self, sLine, offEndStmt):
-        """
-        Helper that returns the line offset following the 'IEM_MC_END();'.
-        """
-        assert sLine[offEndStmt:].startswith('IEM_MC_END');
-        off = sLine.find(';', offEndStmt + len('IEM_MC_END'));
-        assert off > 0, 'sLine="%s"' % (sLine, );
-        return off + 1 if off > 0 else 99999998;
 
     def generateModifiedInput(self, oOut):
@@ -1274 +1326 @@
                     sLine = oParser.asLines[iLine - 1];
                     assert sLine.count('IEM_MC_') == 1;
-                    oOut.write(sLine[self.findEndOfMcEndStmt(sLine, oThreadedFunction.oMcBlock.offEndLine) : ]);
+                    oOut.write(sLine[oThreadedFunction.oMcBlock.offAfterEnd : ]);
 
                     # Advance
@@ -1288 +1340 @@
 
                         sModified = oThreadedFunction.generateInputCode().strip();
-                        assert sModified.startswith('IEM_MC_BEGIN'), 'sModified="%s"' % (sModified,);
+                        assert (   sModified.startswith('IEM_MC_BEGIN')
+                                or sModified.startswith('IEM_MC_DEFER_TO_CIMPL_')), 'sModified="%s"' % (sModified,);
                         oOut.write(sModified);
 
-                        offLine = self.findEndOfMcEndStmt(sLine, oThreadedFunction.oMcBlock.offEndLine);
+                        offLine = oThreadedFunction.oMcBlock.offAfterEnd;
 
                         # Advance