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

Timestamp:

Nov 12, 2023 1:36:45 AM (17 months ago)

Author:

vboxsync

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

160181

Message:

VMM/IEM: Native translation of IEM_MC_CLEAR_HIGH_GREG_U64. Had to extend IEMAllN8veRecompiler.py to insert IEM_MC_FREE_LOCAL (and IEM_MC_FREE_ARG) into ELSE branches to simplify state consolidation on IEM_MC_ENDIF (had trouble with cmovxx). bugref:10371

Location:

trunk/src/VBox/VMM/VMMAll

Files:

• IEMAllInstPython.py (modified) (3 diffs)
• IEMAllN8vePython.py (modified) (3 diffs)
• IEMAllN8veRecompiler.cpp (modified) (2 diffs)
• IEMAllThrdPython.py (modified) (1 diff)

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

@@ -1991 +1991 @@
     ## @}
 
-    def __init__(self, sSrcFile, iBeginLine, offBeginLine, oFunction, iInFunction, cchIndent = None):
+    def __init__(self, sSrcFile, iBeginLine, offBeginLine, oFunction, iInFunction, cchIndent = None, fDeferToCImpl = False):
+        ## Set if IEM_MC_DEFER_TO_CIMPL_0_RET and friends, clear if IEM_MC_BEGIN/END block.
+        self.fDeferToCImpl = fDeferToCImpl;
         ## The source file containing the block.
         self.sSrcFile     = sSrcFile;
@@ -2793 +2795 @@
     'IEM_MC_CLEAR_EFL_BIT':                                      (McBlock.parseMcGeneric,           True,  False, ),
     'IEM_MC_CLEAR_FSW_EX':                                       (McBlock.parseMcGeneric,           True,  False, ),
-    'IEM_MC_CLEAR_HIGH_GREG_U64':                                (McBlock.parseMcGeneric,           True,  False, ),
+    'IEM_MC_CLEAR_HIGH_GREG_U64':                                (McBlock.parseMcGeneric,           True,  True,  ),
     'IEM_MC_CLEAR_XREG_U32_MASK':                                (McBlock.parseMcGeneric,           True,  False, ),
     'IEM_MC_CLEAR_YREG_128_UP':                                  (McBlock.parseMcGeneric,           True,  False, ),
@@ -5201 +5203 @@
         # Start a new block.
         oMcBlock = McBlock(self.sSrcFile, self.iLine, offBeginStatementInLine,
-                           self.oCurFunction, self.iMcBlockInFunc, cchIndent);
+                           self.oCurFunction, self.iMcBlockInFunc, cchIndent, fDeferToCImpl = True);
 
         # Parse the statment.

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

@@ -198 +198 @@
         return True;
 
-    def renderCode(self, cchIndent):
-        """
-        Returns the native recompiler function body for this threaded variant.
-        """
-        # Take the threaded function statement list and add detected
-        # IEM_CIMPL_F_XXX flags to the IEM_MC_BEGIN statement.  Also add
-        # IEM_MC_F_WITHOUT_FLAGS if this isn't a variation with eflags checking
-        # and clearing while there are such variations for this function (this
-        # sounds a bit backwards, but has to be done this way for the use we
-        # make of the flags in CIMPL calls).
-        aoStmts = list(self.oVariation.aoStmtsForThreadedFunction) # type: list(McStmt)
+    def raiseProblem(self, sMessage):
+        """ Raises a problem. """
+        raise Exception('%s:%s: error: %s'
+                        % (self.oVariation.oParent.oMcBlock.sSrcFile, self.oVariation.oParent.oMcBlock.iBeginLine, sMessage,));
+
+    def __analyzeVariableLiveness(self, aoStmts, dVars, iDepth = 0):
+        """
+        Performs liveness analysis of the given statement list, inserting new
+        statements to signal to the native recompiler that a variable is no
+        longer used and can be freed.
+
+        Returns list of freed variables.
+        """
+
+        class VarInfo(object):
+            """ Variable info """
+            def __init__(self, oStmt):
+                self.oStmt         = oStmt;
+                self.fIsArg        = isinstance(oStmt, iai.McStmtArg);
+                self.oReferences   = None       # type: VarInfo
+                self.oReferencedBy = None       # type: VarInfo
+
+            def isArg(self):
+                return self.fIsArg;
+
+            def makeReference(self, oLocal, oParent):
+                if not self.isArg():
+                    oParent.raiseProblem('Attempt to make a reference out of an local variable: %s = &%s'
+                                         % (self.oStmt.sVarName, oLocal.oStmt.sVarName,));
+                if self.oReferences:
+                    oParent.raiseProblem('Can only make a variable a reference once: %s = &%s; now = &%s'
+                                         % (self.oStmt.sVarName, self.oReferences.oStmt.sVarName, oLocal.oStmt.sVarName,));
+                if oLocal.isArg():
+                    oParent.raiseProblem('Attempt to make a reference to an argument: %s = &%s'
+                                         % (self.oStmt.sVarName, oLocal.oStmt.sVarName,));
+                if oLocal.oReferencedBy:
+                    oParent.raiseProblem('%s is already referenced by %s, so cannot make %s reference it as well'
+                                         % (oLocal.oStmt.sVarName, oLocal.oReferencedBy.oStmt.sVarName, self.oStmt.sVarName,));
+                oInfo.oReferences = oLocal;
+                oInfo.oReferences.oReferencedBy = self;
+                return True;
+
+        #
+        # Gather variable declarations and add them to dVars.
+        # Also keep a local list of them for scoping when iDepth > 0.
+        #
+        asVarsInScope = [];
+        for oStmt in aoStmts:
+            if isinstance(oStmt, iai.McStmtVar):
+                if oStmt.sVarName in dVars:
+                    raise Exception('Duplicate variable: %s' % (oStmt.sVarName, ));
+
+                oInfo = VarInfo(oStmt);
+                if oInfo.isArg() and oStmt.sRefType == 'local':
+                    oInfo.makeReference(dVars[oStmt.sRef], self);
+
+                dVars[oStmt.sVarName] = oInfo;
+                asVarsInScope.append(oStmt.sVarName);
+
+            elif oStmt.sName == 'IEM_MC_REF_LOCAL':
+                dVars[oStmt.asParam[0]].makeReference(dVars[oStmt.asParam[1]], self);
+
+        #
+        # Now work the statements backwards and look for the last reference to
+        # each of the variables in dVars.  We remove the variables from the
+        # collections as we go along.
+        #
+        def freeVariable(aoStmts, iStmt, oVarInfo, dFreedVars, dVars, fIncludeReferences = True):
+            sVarName = oVarInfo.oStmt.sVarName;
+            if not oVarInfo.isArg():
+                aoStmts.insert(iStmt + 1, iai.McStmt('IEM_MC_FREE_LOCAL', [sVarName,]));
+                assert not oVarInfo.oReferences;
+            else:
+                aoStmts.insert(iStmt + 1, iai.McStmt('IEM_MC_FREE_ARG', [sVarName,]));
+                if fIncludeReferences and oVarInfo.sReference:
+                    sRefVarName = oVarInfo.oReferences.oStmt.sVarName;
+                    if sRefVarName in dVars:
+                        dFreedVars[sRefVarName] = dVars[sRefVarName];
+                        del dVars[sRefVarName];
+                        aoStmts.insert(iStmt + 1, iai.McStmt('IEM_MC_FREE_LOCAL', [sRefVarName,]));
+            dFreedVars[sVarName] = oVarInfo;
+            if dVars is not None:
+                del dVars[sVarName];
+
+        dFreedVars = {};
+        for iStmt in range(len(aoStmts) - 1, -1, -1):
+            oStmt = aoStmts[iStmt];
+            if isinstance(oStmt, iai.McStmtCond):
+                #
+                # Conditionals requires a bit more work...
+                #
+
+                # Start by replacing the conditional statement by a shallow copy.
+                oStmt = copy.copy(oStmt);
+                oStmt.aoIfBranch   = list(oStmt.aoIfBranch);
+                oStmt.aoElseBranch = list(oStmt.aoElseBranch);
+                aoStmts[iStmt] = oStmt;
+
+                # Check the two branches for final references. Both branches must
+                # start processing with the same dVars set, fortunately as shallow
+                # copy suffices.
+                dFreedInIfBranch   = self.__analyzeVariableLiveness(oStmt.aoIfBranch, dict(dVars), iDepth + 1);
+                dFreedInElseBranch = self.__analyzeVariableLiveness(oStmt.aoElseBranch, dVars, iDepth + 1);
+
+                # Add free statements to the start of the IF-branch for variables use
+                # for the last time in the else branch.
+                for sVarName, oVarInfo in dFreedInElseBranch.items():
+                    if sVarName not in dFreedInIfBranch:
+                        freeVariable(oStmt.aoIfBranch, -1, oVarInfo, dFreedVars, None, False);
+                    else:
+                        dFreedVars[sVarName] = oVarInfo;
+
+                # And vice versa.
+                for sVarName, oVarInfo in dFreedInIfBranch.items():
+                    if sVarName not in dFreedInElseBranch:
+                        freeVariable(oStmt.aoElseBranch, -1, oVarInfo, dFreedVars, dVars, False);
+
+                #
+                # Now check if any remaining variables are used for the last time
+                # in the conditional statement ifself, in which case we need to insert
+                # free statements to both branches.
+                #
+                if not oStmt.isCppStmt():
+                    aoFreeStmts = [];
+                    for sParam in oStmt.asParams:
+                        if sParam in dVars:
+                            freeVariable(aoFreeStmts, -1, dVars[sParam], dFreedVars, dVars);
+                    for oFreeStmt in aoFreeStmts:
+                        oStmt.aoIfBranch.insert(0, oFreeStmt);
+                        oStmt.aoElseBranch.insert(0, oFreeStmt);
+
+            elif not oStmt.isCppStmt():
+                if isinstance(oStmt, iai.McStmtCall):
+                    #
+                    # Call statements will make use of all argument variables and
+                    # will implicitly free them.  So, iterate the variable and
+                    # move them from dVars and onto dFreedVars.
+                    #
+                    # We explictly free any referenced variable that is still in
+                    # dVar at this point (since only arguments can hold variable
+                    # references).
+                    #
+                    for sParam in oStmt.asParams[oStmt.idxParams:]:
+                        oVarInfo = dVars.get(sParam);
+                        if oVarInfo:
+                            if not oVarInfo.isArg():
+                                self.raiseProblem('Argument %s in %s is not an argument!' % (sParam, oStmt.sName,));
+                            if oVarInfo.oReferences:
+                                sRefVarName = oVarInfo.oReferences.oStmt.sVarName;
+                                if sRefVarName in dVars:
+                                    dFreedVars[sRefVarName] = dVars[sRefVarName];
+                                    del dVars[sRefVarName];
+                                    aoStmts.insert(iStmt + 1, iai.McStmt('IEM_MC_FREE_LOCAL', [sRefVarName,]));
+                            dFreedVars[sParam] = oVarInfo;
+                            del dVars[sParam];
+                        elif sParam in dFreedVars:
+                            self.raiseProblem('Argument %s in %s was used after the call!' % (sParam, oStmt.sName,));
+                        else:
+                            self.raiseProblem('Argument %s in %s is not known to us' % (sParam, oStmt.sName,));
+
+                    # Check for stray argument variables.
+                    for oVarInfo in dVars.values():
+                        if oVarInfo.isArg():
+                            self.raiseProblem('Unused argument variable: %s' % (oVarInfo.oStmt.sVarName,));
+                else:
+                    #
+                    # Scan all the parameters of generic statements.
+                    #
+                    for sParam in oStmt.asParams:
+                        if sParam in dVars:
+                            freeVariable(aoStmts, iStmt, dVars[sParam], dFreedVars, dVars);
+
+        #
+        # Free anything left from asVarsInScope that's now going out of scope.
+        #
+        if iDepth > 0:
+            for sVarName in asVarsInScope:
+                if sVarName in dVars:
+                    freeVariable(aoStmts, len(aoStmts) - 1, dVars[sVarName], dFreedVars, dVars);
+        return dFreedVars;
+
+    def __morphStatements(self, aoStmts):
+        """
+        Morphs the given statement list into something more suitable for
+        native recompilation.
+
+        The following is currently done here:
+            - Amend IEM_MC_BEGIN with all the IEM_CIMPL_F_XXX and IEM_MC_F_XXX
+              flags found and derived, including IEM_MC_F_WITHOUT_FLAGS which
+              we determine here.
+            - Insert IEM_MC_FREE_LOCAL when after the last statment a local
+              variable is last used.
+
+        Returns a new list of statements.
+        """
+
+        #
+        # We can skip IEM_MC_DEFER_TO_CIMPL_x_RET stuff.
+        #
+        if self.oVariation.oParent.oMcBlock.fDeferToCImpl:
+            return aoStmts;
+
+        #
+        # We make a shallow copy of the list, and only make deep copies of the
+        # statements we modify.
+        #
+        aoStmts = list(aoStmts) # type: list(iai.McStmt)
+
+        #
+        # First, amend the IEM_MC_BEGIN statment, adding all the flags found
+        # to it so the native recompiler can correctly process ARG and CALL
+        # statements (among other things).
+        #
+        # Also add IEM_MC_F_WITHOUT_FLAGS if this isn't a variation with eflags
+        # checking and clearing while there are such variations for this
+        # function (this sounds a bit backwards, but has to be done this way
+        # for the use we make of the flags in CIMPL calls).
+        #
         for iStmt, oStmt in enumerate(aoStmts):
             if oStmt.sName == 'IEM_MC_BEGIN':
@@ -221 +428 @@
                         oNewStmt.asParams[3] = ' | '.join(sorted(self.oVariation.oParent.dsCImplFlags.keys()));
                     aoStmts[iStmt] = oNewStmt;
-
-        return iai.McStmt.renderCodeForList(aoStmts, cchIndent);
+                break;
+
+        #
+        # Do a simple liveness analysis of the variable and insert
+        # IEM_MC_FREE_LOCAL statements after the last statements using each
+        # variable.  We do this recursively to best handle conditionals and
+        # scoping related to those.
+        #
+        self.__analyzeVariableLiveness(aoStmts, {});
+
+        return aoStmts;
+
+
+    def renderCode(self, cchIndent):
+        """
+        Returns the native recompiler function body for this threaded variant.
+        """
+        return iai.McStmt.renderCodeForList(self.__morphStatements(self.oVariation.aoStmtsForThreadedFunction), cchIndent);
 
     @staticmethod
@@ -307 +530 @@
                 g_dUnsupportedMcStmtLastOneVarStats[sStmt] = [oVariation,];
 
-
-
     return None;

trunk/src/VBox/VMM/VMMAll/IEMAllN8veRecompiler.cpp

@@ -5578 +5578 @@
 
 
+#define IEM_MC_FREE_LOCAL(a_Name)   iemNativeVarFreeLocal(pReNative, a_Name)
+
+/**
+ * This is called by IEM_MC_FREE_LOCAL.
+ */
+DECLINLINE(void) iemNativeVarFreeLocal(PIEMRECOMPILERSTATE pReNative, uint8_t idxVar)
+{
+    IEMNATIVE_ASSERT_VAR_IDX(pReNative, idxVar);
+    Assert(pReNative->Core.aVars[idxVar].uArgNo == UINT8_MAX);
+    iemNativeVarFreeOneWorker(pReNative, idxVar);
+}
+
+
+#define IEM_MC_FREE_ARG(a_Name)     iemNativeVarFreeArg(pReNative, a_Name)
+
+/**
+ * This is called by IEM_MC_FREE_ARG.
+ */
+DECLINLINE(void) iemNativeVarFreeArg(PIEMRECOMPILERSTATE pReNative, uint8_t idxVar)
+{
+    IEMNATIVE_ASSERT_VAR_IDX(pReNative, idxVar);
+    Assert(pReNative->Core.aVars[idxVar].uArgNo < RT_ELEMENTS(pReNative->Core.aidxArgVars));
+    iemNativeVarFreeOneWorker(pReNative, idxVar);
+}
+
+
+
 /*********************************************************************************************************************************
 *   Emitters for IEM_MC_CALL_CIMPL_XXX                                                                                           *
@@ -6386 +6413 @@
     off = iemNativeEmitTop32BitsClearCheck(pReNative, off, idxVarReg);
 #endif
+    return off;
+}
+
+
+
+#define IEM_MC_CLEAR_HIGH_GREG_U64(a_iGReg) \
+    off = iemNativeEmitClearHighGregU64(pReNative, off, a_iGReg)
+
+/** Emits code for IEM_MC_CLEAR_HIGH_GREG_U64. */
+DECL_INLINE_THROW(uint32_t)
+iemNativeEmitClearHighGregU64(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t iGReg)
+{
+    Assert(iGReg < 16);
+    uint8_t const idxGstTmpReg = iemNativeRegAllocTmpForGuestReg(pReNative, &off, IEMNATIVEGSTREG_GPR(iGReg),
+                                                                 kIemNativeGstRegUse_ForUpdate);
+    off = iemNativeEmitLoadGprFromGpr32(pReNative, off, idxGstTmpReg, idxGstTmpReg);
+    off = iemNativeEmitStoreGprToVCpuU64(pReNative, off, idxGstTmpReg, RT_UOFFSETOF_DYN(VMCPU, cpum.GstCtx.aGRegs[iGReg]));
+    iemNativeRegFreeTmp(pReNative, idxGstTmpReg);
     return off;
 }

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

@@ -850 +850 @@
                 # ... and IEM_MC_CALL_CIMPL_[0-5] and IEM_MC_DEFER_TO_CIMPL_[0-5]_RET into *_THREADED ...
                 elif oNewStmt.sName.startswith('IEM_MC_CALL_CIMPL_') or oNewStmt.sName.startswith('IEM_MC_DEFER_TO_CIMPL_'):
-                    oNewStmt.sName += '_THREADED';
+                    oNewStmt.sName     += '_THREADED';
+                    oNewStmt.idxFn     += 1;
+                    oNewStmt.idxParams += 1;
                     oNewStmt.asParams.insert(0, self.dParamRefs['cbInstr'][0].sNewName);