Changeset 102010 in vbox

Timestamp:

Nov 8, 2023 9:36:54 PM (17 months ago)

Author:

vboxsync

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

160109

Message:

VMM/IEM: More on the subject of correctly flushing guest register shadow copies when making CIMPL calls. bugref:10371

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/IEMAllN8vePython.py (modified) (1 diff)
• VMMAll/IEMAllN8veRecompiler.cpp (modified) (3 diffs)
• VMMAll/IEMAllThrdPython.py (modified) (2 diffs)
• VMMAll/IEMAllThrdTables.h (modified) (2 diffs)
• include/IEMInternal.h (modified) (1 diff)

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

@@ -197 +197 @@
         """
         # Take the threaded function statement list and add detected
-        # IEM_CIMPL_F_XXX flags to the IEM_MC_BEGIN statement.
+        # 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)
         for iStmt, oStmt in enumerate(aoStmts):
-            if oStmt.sName == 'IEM_MC_BEGIN' and self.oVariation.oParent.dsCImplFlags:
-                oNewStmt = copy.deepcopy(oStmt);
-                oNewStmt.asParams[3] = ' | '.join(sorted(self.oVariation.oParent.dsCImplFlags.keys()));
-                aoStmts[iStmt] = oNewStmt;
+            if oStmt.sName == 'IEM_MC_BEGIN':
+                fWithoutFlags = (    self.oVariation.isWithFlagsCheckingAndClearingVariation()
+                                 and self.oVariation.oParent.hasWithFlagsCheckingAndClearingVariation());
+                if fWithoutFlags or self.oVariation.oParent.dsCImplFlags:
+                    oNewStmt = copy.deepcopy(oStmt);
+                    if fWithoutFlags:
+                        oNewStmt.asParams[2] = ' | '.join(sorted(  list(self.oVariation.oParent.oMcBlock.dsMcFlags.keys())
+                                                                 + ['IEM_MC_F_WITHOUT_FLAGS',] ));
+                    if self.oVariation.oParent.dsCImplFlags:
+                        oNewStmt.asParams[3] = ' | '.join(sorted(self.oVariation.oParent.dsCImplFlags.keys()));
+                    aoStmts[iStmt] = oNewStmt;
 
         return iai.McStmt.renderCodeForList(aoStmts, cchIndent);

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

@@ -3487 +3487 @@
 {
     /*
-     * Flush stuff.
-     */
-    fGstShwFlush = iemNativeCImplFlagsToGuestShadowFlushMask(pReNative->fCImpl, fGstShwFlush | RT_BIT_64(kIemNativeGstReg_Pc));
+     * Flush stuff. PC and EFlags are implictly flushed, the latter because we
+     * don't do with/without flags variants of defer-to-cimpl stuff at the moment.
+     */
+    fGstShwFlush = iemNativeCImplFlagsToGuestShadowFlushMask(pReNative->fCImpl,
+                                                             fGstShwFlush
+                                                             | RT_BIT_64(kIemNativeGstReg_Pc)
+                                                             | RT_BIT_64(kIemNativeGstReg_EFlags));
     iemNativeRegFlushGuestShadows(pReNative, fGstShwFlush);
 
@@ -5565 +5569 @@
     off = iemNativeEmitLoadGprByBpU32(pReNative, off, X86_GREG_xAX, IEMNATIVE_FP_OFF_IN_SHADOW_ARG0); /* rcStrict (see above) */
 #endif
-/** @todo Always flush EFLAGS if this is an xxF variation. */
-    iemNativeRegFlushGuestShadows(pReNative,
-                                  iemNativeCImplFlagsToGuestShadowFlushMask(pReNative->fCImpl, RT_BIT_64(kIemNativeGstReg_Pc)) );
+    uint64_t fGstShwFlush = iemNativeCImplFlagsToGuestShadowFlushMask(pReNative->fCImpl, RT_BIT_64(kIemNativeGstReg_Pc));
+    if (!(pReNative->fMc & IEM_MC_F_WITHOUT_FLAGS)) /** @todo We don't emit with-flags/without-flags variations for CIMPL calls.  */
+        fGstShwFlush |= RT_BIT_64(kIemNativeGstReg_EFlags);
+    iemNativeRegFlushGuestShadows(pReNative, fGstShwFlush);
 
     return iemNativeEmitCheckCallRetAndPassUp(pReNative, off, idxInstr);
@@ -5947 +5952 @@
 static IEM_DECL_IEMNATIVERECOMPFUNC_DEF(iemNativeRecompFunc_BltIn_DeferToCImpl0)
 {
-    PFNIEMCIMPL0 const pfnCImpl = (PFNIEMCIMPL0)(uintptr_t)pCallEntry->auParams[0];
-    uint8_t const      cbInstr  = (uint8_t)pCallEntry->auParams[1];
-    /** @todo Drop this crap hack?
-     *  We don't have the flush mask here so we we must pass UINT64_MAX. */
-    return iemNativeEmitCImplCall(pReNative, off, pCallEntry->idxInstr, UINT64_MAX, (uintptr_t)pfnCImpl, cbInstr, 0, 0, 0, 0);
+    PFNIEMCIMPL0 const pfnCImpl     = (PFNIEMCIMPL0)(uintptr_t)pCallEntry->auParams[0];
+    uint8_t const      cbInstr      = (uint8_t)pCallEntry->auParams[1];
+    uint64_t const     fGstShwFlush = (uint8_t)pCallEntry->auParams[2];
+    return iemNativeEmitCImplCall(pReNative, off, pCallEntry->idxInstr, fGstShwFlush, (uintptr_t)pfnCImpl, cbInstr, 0, 0, 0, 0);
 }
 

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

@@ -474 +474 @@
         return '%s_%s%s' % ( sName, self.oParent.oMcBlock.iInFunction, self.sVariation, );
 
+    def isWithFlagsCheckingAndClearingVariation(self):
+        """
+        Checks if this is a variation that checks and clears EFLAGS.
+        """
+        return self.sVariation in ThreadedFunctionVariation.kdVariationsWithEflagsCheckingAndClearing;
+
     #
     # Analysis and code morphing.
@@ -1294 +1300 @@
                                             iai.DecoderFunction('null', 999999999, 'nil', ('','')), 999999999));
 
+    def hasWithFlagsCheckingAndClearingVariation(self):
+        """
+        Check if there is one or more with flags checking and clearing
+        variations for this threaded function.
+        """
+        for sVarWithFlags in ThreadedFunctionVariation.kdVariationsWithEflagsCheckingAndClearing:
+            if sVarWithFlags in self.dVariations:
+                return True;
+        return False;
+
+    #
+    # Analysis and code morphing.
+    #
+
     def raiseProblem(self, sMessage):
         """ Raises a problem. """

trunk/src/VBox/VMM/VMMAll/IEMAllThrdTables.h

@@ -83 +83 @@
 
 #include "IEMThreadedFunctions.h"
+#include "IEMN8veRecompiler.h" /* For a_fGstShwFlush and iemThreadedRecompilerMcDeferToCImpl0. */
 
 
@@ -302 +303 @@
 #undef IEM_MC_DEFER_TO_CIMPL_0_RET
 #define IEM_MC_DEFER_TO_CIMPL_0_RET(a_fFlags, a_fGstShwFlush, a_pfnCImpl) \
-    return iemThreadedRecompilerMcDeferToCImpl0(pVCpu, a_fFlags, a_pfnCImpl)
-
-DECLINLINE(VBOXSTRICTRC) iemThreadedRecompilerMcDeferToCImpl0(PVMCPUCC pVCpu, uint32_t fFlags, PFNIEMCIMPL0 pfnCImpl)
+    return iemThreadedRecompilerMcDeferToCImpl0(pVCpu, a_fFlags, a_fGstShwFlush, a_pfnCImpl)
+
+DECLINLINE(VBOXSTRICTRC)
+iemThreadedRecompilerMcDeferToCImpl0(PVMCPUCC pVCpu, uint32_t fFlags, uint64_t fGstShwFlush, PFNIEMCIMPL0 pfnCImpl)
 {
-    Log8(("CImpl0: %04x:%08RX64 LB %#x: %#x %p\n",
-          pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, IEM_GET_INSTR_LEN(pVCpu), fFlags, pfnCImpl));
+    Log8(("CImpl0: %04x:%08RX64 LB %#x: %#x %#RX64 %p\n",
+          pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, IEM_GET_INSTR_LEN(pVCpu), fFlags, fGstShwFlush, pfnCImpl));
     pVCpu->iem.s.fTbCurInstr = fFlags;
 
     IEM_MC2_BEGIN_EMIT_CALLS(fFlags & IEM_CIMPL_F_CHECK_IRQ_BEFORE);
-    IEM_MC2_EMIT_CALL_2(kIemThreadedFunc_BltIn_DeferToCImpl0, (uintptr_t)pfnCImpl, IEM_GET_INSTR_LEN(pVCpu));
+    IEM_MC2_EMIT_CALL_3(kIemThreadedFunc_BltIn_DeferToCImpl0, (uintptr_t)pfnCImpl, IEM_GET_INSTR_LEN(pVCpu), fGstShwFlush);
     if (   (fFlags & (IEM_CIMPL_F_MODE | IEM_CIMPL_F_VMEXIT))
         && !(fFlags & (IEM_CIMPL_F_END_TB | IEM_CIMPL_F_BRANCH_FAR)))

trunk/src/VBox/VMM/include/IEMInternal.h

@@ -560 +560 @@
 #define IEM_MC_F_64BIT              RT_BIT_32(6)
 #define IEM_MC_F_NOT_64BIT          RT_BIT_32(7)
+/** This is set by IEMAllN8vePython.py to indicate a variation without the
+ * flags-clearing-and-checking, when there is also a variation with that.
+ * @note Do not use this manully, it's only for python and for testing in
+ *       the native recompiler! */
+#define IEM_MC_F_WITHOUT_FLAGS      RT_BIT_32(8)
 /** @} */