Changeset 103371 in vbox

Timestamp:

Feb 14, 2024 8:15:01 PM (11 months ago)

Author:

vboxsync

Message:

VMM/DBGFR3Flow: Moved duplicate code for determining the pointer size to an inline function. Mark parfait false positive to avoid re-analysis. bugref:3409

File:

• trunk/src/VBox/VMM/VMMR3/DBGFR3Flow.cpp (modified) (7 diffs)

trunk/src/VBox/VMM/VMMR3/DBGFR3Flow.cpp

@@ -723 +723 @@
 
 
+#if 0 /* unused */
 /**
  * Returns the CPU mode based on the given assembler flags.
@@ -748 +749 @@
 
     return enmMode;
+}
+#endif
+
+
+/**
+ * Returns the (PC) pointer size based on given assembler flags.
+ *
+ * @returns 2, 4, or 8.
+ * @param   pUVM                The user mode VM handle.
+ * @param   idCpu               CPU id for disassembling.
+ * @param   fFlagsDisasm        The flags used for disassembling.
+ */
+DECLINLINE(uint32_t) dbgfR3FlowGetDisasPtrSize(PUVM pUVM, VMCPUID idCpu, uint32_t fFlagsDisasm)
+{
+    switch (fFlagsDisasm & DBGF_DISAS_FLAGS_MODE_MASK)
+    {
+        case DBGF_DISAS_FLAGS_16BIT_MODE:
+        case DBGF_DISAS_FLAGS_16BIT_REAL_MODE:
+            return sizeof(uint16_t);
+        case DBGF_DISAS_FLAGS_32BIT_MODE:
+            return sizeof(uint32_t);
+        case DBGF_DISAS_FLAGS_64BIT_MODE:
+            return sizeof(uint64_t);
+        default:
+            AssertMsgFailed(("%#x\n", fFlagsDisasm));
+            RT_FALL_THRU();
+        case DBGF_DISAS_FLAGS_DEFAULT_MODE:
+        {
+            CPUMMODE const enmMode = DBGFR3CpuGetMode(pUVM, idCpu);
+            switch (enmMode)
+            {
+                case CPUMMODE_REAL:
+                    return sizeof(uint16_t);
+                case CPUMMODE_PROTECTED:
+                case CPUMMODE_ARMV8_AARCH32:
+                    return sizeof(uint32_t);
+                default:
+                    AssertFailed();
+                    RT_FALL_THRU();
+                case CPUMMODE_LONG:
+                case CPUMMODE_ARMV8_AARCH64:
+                    return sizeof(uint64_t);
+            }
+            break;
+        }
+    }
 }
 
@@ -922 +969 @@
                                                uint8_t idxGenRegBase, uint32_t cbPtr, PUVM pUVM, VMCPUID idCpu, bool fBranchTbl)
 {
-    int rc = VINF_SUCCESS;
-
+    int rc;
     if (!fBranchTbl)
     {
-        union { uint16_t u16Val; uint32_t u32Val; uint64_t u64Val; } uVal;
-        rc = DBGFR3MemRead(pUVM, idCpu, pAddrBranchTgt, &uVal, cbPtr);
+        RTUINT64U uVal = { 0 };
+        Assert(cbPtr <= sizeof(uVal));
+        rc = DBGFR3MemRead(pUVM, idCpu, pAddrBranchTgt, &uVal, cbPtr); /* (parfait wrong about potential buffer overflow, cbPtr is known) */
         if (RT_SUCCESS(rc))
         {
             DBGFADDRESS AddrTgt;
-            RTGCUINTPTR GCPtr =   cbPtr == sizeof(uint64_t)
-                                ? uVal.u64Val
+            RTGCUINTPTR GCPtr =   cbPtr == sizeof(uint64_t) /* (We could use uVal directly on little endian machines.) */
+                                ? uVal.au64[0]
                                 : cbPtr == sizeof(uint32_t)
-                                ? uVal.u32Val
-                                : uVal.u16Val;
+                                ? uVal.au32[0]
+                                : uVal.au16[0];
             if (DBGFADDRESS_IS_FLAT(pAddrBranchTgt))
                 DBGFR3AddrFromFlat(pUVM, &AddrTgt, GCPtr);
@@ -946 +993 @@
                 pFlowBb->AddrTarget = AddrTgt;
                 rc = dbgfR3FlowBbSuccessorAdd(pThis, &AddrTgt,
-                                              (pFlowBb->fFlags & DBGF_FLOW_BB_F_BRANCH_TABLE),
+                                              pFlowBb->fFlags & DBGF_FLOW_BB_F_BRANCH_TABLE,
                                               pFlowBb->pFlowBranchTbl);
             }
@@ -977 +1024 @@
     Assert(dbgfR3FlowBranchTargetIsIndirect(pDisParam));
 
-    uint32_t cbPtr = 0;
-    CPUMMODE enmMode = dbgfR3FlowGetDisasCpuMode(pUVM, idCpu, fFlagsDisasm);
-
-    switch (enmMode)
-    {
-        case CPUMMODE_REAL:
-            cbPtr = sizeof(uint16_t);
-            break;
-        case CPUMMODE_PROTECTED:
-            cbPtr = sizeof(uint32_t);
-            break;
-        case CPUMMODE_LONG:
-            cbPtr = sizeof(uint64_t);
-            break;
-        default:
-            AssertMsgFailed(("Invalid CPU mode %u\n", enmMode));
-    }
-
     if (pDisParam->fUse & DISUSE_BASE)
     {
-        uint8_t idxRegBase = pDisParam->x86.Base.idxGenReg;
+        uint8_t const idxRegBase = pDisParam->x86.Base.idxGenReg;
+        uint32_t const cbPtr = dbgfR3FlowGetDisasPtrSize(pUVM, idCpu, fFlagsDisasm);
 
         /* Check that the used register size and the pointer size match. */
@@ -1064 +1094 @@
     Assert(pFlowBb->fFlags & DBGF_FLOW_BB_F_BRANCH_TABLE && pFlowBb->pFlowBranchTbl);
 
-    uint32_t cbPtr = 0;
-    CPUMMODE enmMode = dbgfR3FlowGetDisasCpuMode(pUVM, idCpu, fFlagsDisasm);
-
-    switch (enmMode)
-    {
-        case CPUMMODE_REAL:
-            cbPtr = sizeof(uint16_t);
-            break;
-        case CPUMMODE_PROTECTED:
-            cbPtr = sizeof(uint32_t);
-            break;
-        case CPUMMODE_LONG:
-            cbPtr = sizeof(uint64_t);
-            break;
-        default:
-            AssertMsgFailed(("Invalid CPU mode %u\n", enmMode));
-    }
-
     if (pDisParam->fUse & DISUSE_BASE)
     {
-        uint8_t idxRegBase = pDisParam->x86.Base.idxGenReg;
+        uint8_t const idxRegBase = pDisParam->x86.Base.idxGenReg;
+        uint32_t const cbPtr = dbgfR3FlowGetDisasPtrSize(pUVM, idCpu, fFlagsDisasm);
 
         /* Check that the used register size and the pointer size match. */
@@ -1124 +1137 @@
  */
 static int dbgfR3FlowBbProcess(PUVM pUVM, VMCPUID idCpu, PDBGFFLOWINT pThis, PDBGFFLOWBBINT pFlowBb,
-                              uint32_t cbDisasmMax, uint32_t fFlags)
+                               uint32_t cbDisasmMax, uint32_t fFlags)
 {
     int rc = VINF_SUCCESS;