Changeset 104084 in vbox for trunk/src

Timestamp:

Mar 27, 2024 12:55:34 PM (12 months ago)

Author:

vboxsync

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

162485

Message:

VMM/IEM: Implement support for automatically flushing all call volatile registers which shadow a guest register and have unwritten data stored when calling an external helper, add a flag to iemNativeEmitCallCommon() to prevent calling iemNativeRegFlushPendingWrites() (except for call volatile registers which get written back always). make us of that flag when emitting code for IEM_MC_CALL_VOID_AIMPL_XXX/IEM_MC_CALL_AIMPL_XXX as assembly helplers can't throw exceptions and don't access CPUMCTX but operate entirely on the given arguments. This should avoid a few unnecessary writebacks, bugref:10629

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/IEMAllN8veRecompFuncs.h (modified) (1 diff)
• VMMAll/IEMAllN8veRecompiler.cpp (modified) (9 diffs)
• include/IEMN8veRecompiler.h (modified) (2 diffs)

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

@@ -2415 +2415 @@
     /*
      * Do all the call setup and cleanup.
+     *
+     * It is only required to flush pending guest register writes in call volatile registers as
+     * assembly helpers can't throw and don't access anything living in CPUMCTX, they only
+     * access parameters. The flushing of call volatile registers is always done in iemNativeEmitCallCommon()
+     * no matter the fFlushPendingWrites parameter.
      */
-    off = iemNativeEmitCallCommon(pReNative, off, cArgs, 0 /*cHiddenArgs*/);
+    off = iemNativeEmitCallCommon(pReNative, off, cArgs, 0 /*cHiddenArgs*/, false /*fFlushPendingWrites*/);
 
     /*

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

@@ -4376 +4376 @@
     RT_NOREF(pszCaller);
 
+#ifdef IEMNATIVE_WITH_DELAYED_REGISTER_WRITEBACK
+    Assert(!(pReNative->Core.aHstRegs[idxRegNew].fGstRegShadows & pReNative->Core.bmGstRegShadowDirty));
+#endif
     iemNativeRegClearGstRegShadowing(pReNative, idxRegNew, off);
 
@@ -5183 +5186 @@
     RT_NOREF(pszCaller);
 
+    Assert(!(  (pReNative->Core.bmGstSimdRegShadowDirtyLo128 | pReNative->Core.bmGstSimdRegShadowDirtyHi128)
+             & pReNative->Core.aHstSimdRegs[idxRegNew].fGstRegShadows));
     iemNativeSimdRegClearGstSimdRegShadowing(pReNative, idxRegNew, off);
 
@@ -5418 +5423 @@
 
             AssertMsg(pReNative->Core.aHstSimdRegs[idxSimdReg].fGstRegShadows != 0, ("idxSimdReg=%#x\n", idxSimdReg));
+
+#ifdef IEMNATIVE_WITH_DELAYED_REGISTER_WRITEBACK
+            /*
+             * Flush any pending writes now (might have been skipped earlier in iemEmitCallCommon() but it doesn't apply
+             * to call volatile registers).
+             */
+            if (  (pReNative->Core.bmGstSimdRegShadowDirtyLo128 | pReNative->Core.bmGstSimdRegShadowDirtyHi128)
+                & pReNative->Core.aHstSimdRegs[idxSimdReg].fGstRegShadows)
+                off = iemNativeSimdRegFlushDirtyGuestByHostSimdRegShadow(pReNative, off, idxSimdReg);
+#endif
             Assert(!(  (pReNative->Core.bmGstSimdRegShadowDirtyLo128 | pReNative->Core.bmGstSimdRegShadowDirtyHi128)
                      & pReNative->Core.aHstSimdRegs[idxSimdReg].fGstRegShadows));
@@ -5551 +5566 @@
 
             AssertMsg(pReNative->Core.aHstRegs[idxReg].fGstRegShadows != 0, ("idxReg=%#x\n", idxReg));
+
 #ifdef IEMNATIVE_WITH_DELAYED_REGISTER_WRITEBACK
+            /*
+             * Flush any pending writes now (might have been skipped earlier in iemEmitCallCommon() but it doesn't apply
+             * to call volatile registers).
+             */
+            if (pReNative->Core.bmGstRegShadowDirty & pReNative->Core.aHstRegs[idxReg].fGstRegShadows)
+                off = iemNativeRegFlushDirtyGuestByHostRegShadow(pReNative, off, idxReg);
             Assert(!(pReNative->Core.bmGstRegShadowDirty & pReNative->Core.aHstRegs[idxReg].fGstRegShadows));
 #endif
+
             pReNative->Core.bmGstRegShadows &= ~pReNative->Core.aHstRegs[idxReg].fGstRegShadows;
             pReNative->Core.aHstRegs[idxReg].fGstRegShadows = 0;
@@ -5886 +5909 @@
     return off;
 }
+
+
+#ifdef IEMNATIVE_WITH_DELAYED_REGISTER_WRITEBACK
+/**
+ * Flush all shadowed guest SIMD registers marked as dirty for the given host SIMD register.
+ *
+ * @returns New code buffer offset.
+ * @param   pReNative       The native recompile state.
+ * @param   off             Current code buffer position.
+ * @param   idxHstSimdReg   The host SIMD register.
+ *
+ * @note This doesn't do any unshadowing of guest registers from the host register.
+ */
+DECL_HIDDEN_THROW(uint32_t) iemNativeSimdRegFlushDirtyGuestByHostSimdRegShadow(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t const idxHstSimdReg)
+{
+    /* We need to flush any pending guest register writes this host register shadows. */
+    uint64_t bmGstSimdRegShadowDirty =   (pReNative->Core.bmGstSimdRegShadowDirtyLo128 | pReNative->Core.bmGstSimdRegShadowDirtyHi128)
+                                       & pReNative->Core.aHstSimdRegs[idxHstSimdReg].fGstRegShadows;
+    if (bmGstSimdRegShadowDirty)
+    {
+# ifdef IEMNATIVE_WITH_TB_DEBUG_INFO
+        iemNativeDbgInfoAddNativeOffset(pReNative, off);
+        iemNativeDbgInfoAddGuestRegWriteback(pReNative, true /*fSimdReg*/, bmGstSimdRegShadowDirty);
+# endif
+
+        uint32_t idxGstSimdReg = 0;
+        do
+        {
+            if (bmGstSimdRegShadowDirty & 0x1)
+                off = iemNativeSimdRegFlushPendingWrite(pReNative, off, IEMNATIVEGSTSIMDREG_SIMD(idxGstSimdReg));
+
+            idxGstSimdReg++;
+            bmGstSimdRegShadowDirty >>= 1;
+        } while (bmGstSimdRegShadowDirty);
+    }
+
+    return off;
+}
+#endif
 
 
@@ -6674 +6736 @@
  * the guest state (like raising exceptions) and such.
  *
- * This optimization has not yet been implemented.  The first target would be
- * RIP updates, since these are the most common ones.
- *
  * @note This function does not flush any shadowing information for guest registers. This needs to be done by
  *       the caller if it wishes to do so.
@@ -9103 +9162 @@
  *                          them, whereas all the regular arguments must
  *                          (tstIEMCheckMc ensures this).
+ * @param   fFlushPendingWrites Flag whether to flush pending writes (default true),
+ *                              this will still flush pending writes in call volatile registers if false.
  */
 DECL_HIDDEN_THROW(uint32_t)
-iemNativeEmitCallCommon(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t cArgs, uint8_t cHiddenArgs)
+iemNativeEmitCallCommon(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t cArgs, uint8_t cHiddenArgs, bool fFlushPendingWrites /*= true*/)
 {
 #ifdef VBOX_STRICT
@@ -9124 +9185 @@
 
     /* We don't know what the called function makes use of, so flush any pending register writes. */
-    off = iemNativeRegFlushPendingWrites(pReNative, off);
+#ifdef IEMNATIVE_WITH_DELAYED_REGISTER_WRITEBACK
+    if (fFlushPendingWrites)
+#endif
+        off = iemNativeRegFlushPendingWrites(pReNative, off);
 
     /*
@@ -9190 +9254 @@
 
     uint8_t const cRegArgs = RT_MIN(cArgs, RT_ELEMENTS(g_aidxIemNativeCallRegs));
+
+#ifdef IEMNATIVE_WITH_DELAYED_REGISTER_WRITEBACK
+    /*
+     * At the very first step go over the host registers that will be used for arguments
+     * don't shadow anything which needs writing back first.
+     */
+    for (uint32_t i = 0; i < cRegArgs; i++)
+    {
+        uint8_t const idxArgReg = g_aidxIemNativeCallRegs[i];
+
+        /* Writeback any dirty guest shadows before using this register. */
+        if (pReNative->Core.bmGstRegShadowDirty & pReNative->Core.aHstRegs[idxArgReg].fGstRegShadows)
+            off = iemNativeRegFlushDirtyGuestByHostRegShadow(pReNative, off, idxArgReg);
+        Assert(!(pReNative->Core.bmGstRegShadowDirty & pReNative->Core.aHstRegs[idxArgReg].fGstRegShadows));
+    }
+#endif
 
     /*

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

@@ -1571 +1571 @@
 #ifdef IEMNATIVE_WITH_SIMD_REG_ALLOCATOR
 DECLHIDDEN(void)            iemNativeSimdRegFreeVar(PIEMRECOMPILERSTATE pReNative, uint8_t idxHstSimdReg, bool fFlushShadows) RT_NOEXCEPT;
+# ifdef IEMNATIVE_WITH_DELAYED_REGISTER_WRITEBACK
+DECL_HIDDEN_THROW(uint32_t) iemNativeSimdRegFlushDirtyGuestByHostSimdRegShadow(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t idxHstReg);
+# endif
 #endif
 DECLHIDDEN(void)            iemNativeRegFreeAndFlushMask(PIEMRECOMPILERSTATE pReNative, uint32_t fHstRegMask) RT_NOEXCEPT;
@@ -1655 +1658 @@
 #endif
 DECL_HIDDEN_THROW(uint32_t) iemNativeEmitCheckCallRetAndPassUp(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t idxInstr);
-DECL_HIDDEN_THROW(uint32_t) iemNativeEmitCallCommon(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t cArgs, uint8_t cHiddenArgs);
+DECL_HIDDEN_THROW(uint32_t) iemNativeEmitCallCommon(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t cArgs, uint8_t cHiddenArgs, bool fFlushPendingWrites = true);
 DECL_HIDDEN_THROW(uint32_t) iemNativeEmitCImplCall(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t idxInstr,
                                                    uint64_t fGstShwFlush, uintptr_t pfnCImpl, uint8_t cbInstr, uint8_t cAddParams,