Changeset 41738 in vbox for trunk/src/VBox/VMM/VMMR3

Timestamp:

Jun 15, 2012 1:25:47 AM (13 years ago)

Author:

vboxsync

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

78546

Message:

DISOPCODE: s/optype/fOpType/ s/param/fParam/ docs

Location:

trunk/src/VBox/VMM/VMMR3

Files:

• CSAM.cpp (modified) (6 diffs)
• EMRaw.cpp (modified) (1 diff)
• PATM.cpp (modified) (25 diffs)
• PATMGuest.cpp (modified) (1 diff)
• PATMPatch.cpp (modified) (5 diffs)

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

@@ -881 +881 @@
 
     case OP_PUSH:
-        if (pCpu->pCurInstr->param1 != OP_PARM_REG_CS)
+        if (pCpu->pCurInstr->fParam1 != OP_PARM_REG_CS)
             break;
 
@@ -956 +956 @@
     {
         // return or jump/call through a jump table
-        if (OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J)
+        if (OP_PARM_VTYPE(pCpu->pCurInstr->fParam1) != OP_PARM_J)
         {
 #ifdef DEBUG
@@ -1304 +1304 @@
          * If it's harmless, then don't bother checking it (the disasm tables had better be accurate!)
          */
-        if ((cpu.pCurInstr->optype & ~DISOPTYPE_RRM_MASK) == DISOPTYPE_HARMLESS)
+        if ((cpu.pCurInstr->fOpType & ~DISOPTYPE_RRM_MASK) == DISOPTYPE_HARMLESS)
         {
             AssertMsg(pfnCSAMR3Analyse(pVM, &cpu, pInstrGC, pCurInstrGC, pCacheRec, (void *)pPage) == VWRN_CONTINUE_ANALYSIS, ("Instruction incorrectly marked harmless?!?!?\n"));
@@ -1327 +1327 @@
 
         // For our first attempt, we'll handle only simple relative jumps and calls (immediate offset coded in instruction)
-        if (    ((cpu.pCurInstr->optype & DISOPTYPE_CONTROLFLOW) && (OP_PARM_VTYPE(cpu.pCurInstr->param1) == OP_PARM_J))
+        if (    ((cpu.pCurInstr->fOpType & DISOPTYPE_CONTROLFLOW) && (OP_PARM_VTYPE(cpu.pCurInstr->fParam1) == OP_PARM_J))
             ||  (cpu.pCurInstr->uOpcode == OP_CALL && cpu.param1.fUse == DISUSE_DISPLACEMENT32))  /* simple indirect call (call dword ptr [address]) */
         {
@@ -1395 +1395 @@
 
             rc = VWRN_CONTINUE_ANALYSIS;
-        } //if ((cpu.pCurInstr->optype & DISOPTYPE_CONTROLFLOW) && (OP_PARM_VTYPE(cpu.pCurInstr->param1) == OP_PARM_J))
+        } //if ((cpu.pCurInstr->fOpType & DISOPTYPE_CONTROLFLOW) && (OP_PARM_VTYPE(cpu.pCurInstr->fParam1) == OP_PARM_J))
 #ifdef CSAM_SCAN_JUMP_TABLE
         else
@@ -2567 +2567 @@
                     if (    rc == VINF_SUCCESS
                         &&  cpu.pCurInstr->uOpcode == OP_PUSH
-                        &&  cpu.pCurInstr->param1 == OP_PARM_REG_CS)
+                        &&  cpu.pCurInstr->fParam1 == OP_PARM_REG_CS)
                     {
                         rc = PATMR3InstallPatch(pVM, pHandler - aOpenBsdPushCSOffset[i], PATMFL_CODE32 | PATMFL_GUEST_SPECIFIC);

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

@@ -622 +622 @@
         rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &cpu, "Guest Trap: ");
         if (    RT_SUCCESS(rc)
-            &&  (cpu.pCurInstr->optype & DISOPTYPE_PORTIO))
+            &&  (cpu.pCurInstr->fOpType & DISOPTYPE_PORTIO))
         {
             /*

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

@@ -1395 +1395 @@
     {
         /* No unconditional jumps or calls without fixed displacements. */
-        if (    (pCpu->pCurInstr->optype & DISOPTYPE_CONTROLFLOW)
+        if (    (pCpu->pCurInstr->fOpType & DISOPTYPE_CONTROLFLOW)
              && (pCpu->pCurInstr->uOpcode == OP_JMP || pCpu->pCurInstr->uOpcode == OP_CALL)
            )
@@ -1402 +1402 @@
             if (    pCpu->param1.cb == 6 /* far call/jmp */
                 ||  (pCpu->pCurInstr->uOpcode == OP_CALL && !(pPatch->flags & PATMFL_SUPPORT_CALLS))
-                ||  (OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J && !(pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS))
+                ||  (OP_PARM_VTYPE(pCpu->pCurInstr->fParam1) != OP_PARM_J && !(pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS))
                )
             {
@@ -1502 +1502 @@
 
     default:
-        if (pCpu->pCurInstr->optype & (DISOPTYPE_PRIVILEGED_NOTRAP))
+        if (pCpu->pCurInstr->fOpType & (DISOPTYPE_PRIVILEGED_NOTRAP))
         {
             patmAddIllegalInstrRecord(pVM, pPatch, pCurInstrGC);
@@ -1511 +1511 @@
 
     /* If single instruction patch, we've copied enough instructions *and* the current instruction is not a relative jump. */
-    if ((pPatch->flags & PATMFL_CHECK_SIZE) && pPatch->cbPatchBlockSize > SIZEOF_NEARJUMP32 && !(pCpu->pCurInstr->optype & DISOPTYPE_RELATIVE_CONTROLFLOW))
+    if ((pPatch->flags & PATMFL_CHECK_SIZE) && pPatch->cbPatchBlockSize > SIZEOF_NEARJUMP32 && !(pCpu->pCurInstr->fOpType & DISOPTYPE_RELATIVE_CONTROLFLOW))
     {
         /* The end marker for this kind of patch is any instruction at a location outside our patch jump. */
@@ -1554 +1554 @@
     {
         // no unconditional jumps or calls without fixed displacements
-        if (    (pCpu->pCurInstr->optype & DISOPTYPE_CONTROLFLOW)
+        if (    (pCpu->pCurInstr->fOpType & DISOPTYPE_CONTROLFLOW)
              && (pCpu->pCurInstr->uOpcode == OP_JMP || pCpu->pCurInstr->uOpcode == OP_CALL)
            )
@@ -1561 +1561 @@
             if (    pCpu->param1.cb == 6 /* far call/jmp */
                 ||  (pCpu->pCurInstr->uOpcode == OP_CALL && !(pPatch->flags & PATMFL_SUPPORT_CALLS))
-                ||  (OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J && !(pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS))
+                ||  (OP_PARM_VTYPE(pCpu->pCurInstr->fParam1) != OP_PARM_J && !(pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS))
                )
             {
@@ -1583 +1583 @@
     #if 0
         ///@todo we can handle certain in/out and privileged instructions in the guest context
-        if (pCpu->pCurInstr->optype & DISOPTYPE_PRIVILEGED && pCpu->pCurInstr->uOpcode != OP_STI)
+        if (pCpu->pCurInstr->fOpType & DISOPTYPE_PRIVILEGED && pCpu->pCurInstr->uOpcode != OP_STI)
         {
             Log(("Illegal instructions for function patch!!\n"));
@@ -1616 +1616 @@
         return VWRN_CONTINUE_ANALYSIS;
     default:
-        if (pCpu->pCurInstr->optype & (DISOPTYPE_PRIVILEGED_NOTRAP))
+        if (pCpu->pCurInstr->fOpType & (DISOPTYPE_PRIVILEGED_NOTRAP))
         {
             patmAddIllegalInstrRecord(pVM, pPatch, pCurInstrGC);
@@ -1694 +1694 @@
      * Indirect calls are handled below.
      */
-    if (   (pCpu->pCurInstr->optype & DISOPTYPE_CONTROLFLOW)
+    if (   (pCpu->pCurInstr->fOpType & DISOPTYPE_CONTROLFLOW)
         && (pCpu->pCurInstr->uOpcode != OP_CALL || (pPatch->flags & PATMFL_SUPPORT_CALLS))
-        && (OP_PARM_VTYPE(pCpu->pCurInstr->param1) == OP_PARM_J))
+        && (OP_PARM_VTYPE(pCpu->pCurInstr->fParam1) == OP_PARM_J))
     {
         RCPTRTYPE(uint8_t *) pTargetGC = PATMResolveBranch(pCpu, pCurInstrGC);
@@ -1745 +1745 @@
 
     case OP_MOV:
-        if (pCpu->pCurInstr->optype & DISOPTYPE_POTENTIALLY_DANGEROUS)
+        if (pCpu->pCurInstr->fOpType & DISOPTYPE_POTENTIALLY_DANGEROUS)
         {
             /* mov ss, src? */
@@ -1772 +1772 @@
 
     case OP_POP:
-        if (pCpu->pCurInstr->param1 == OP_PARM_REG_SS)
-        {
-            Assert(pCpu->pCurInstr->optype & DISOPTYPE_INHIBIT_IRQS);
+        if (pCpu->pCurInstr->fParam1 == OP_PARM_REG_SS)
+        {
+            Assert(pCpu->pCurInstr->fOpType & DISOPTYPE_INHIBIT_IRQS);
 
             Log(("Force recompilation of next instruction for OP_MOV at %RRv\n", pCurInstrGC));
@@ -1879 +1879 @@
 
     case OP_PUSH:
-        if (pCpu->pCurInstr->param1 == OP_PARM_REG_CS)
+        if (pCpu->pCurInstr->fParam1 == OP_PARM_REG_CS)
         {
             rc = patmPatchGenPushCS(pVM, pPatch);
@@ -1979 +1979 @@
     case OP_MOV_DR:
         /* Note: currently we let DRx writes cause a trap d; our trap handler will decide to interpret it or not. */
-        if (pCpu->pCurInstr->param2 == OP_PARM_Dd)
+        if (pCpu->pCurInstr->fParam2 == OP_PARM_Dd)
         {
             rc = patmPatchGenMovDebug(pVM, pPatch, pCpu);
@@ -1990 +1990 @@
     case OP_MOV_CR:
         /* Note: currently we let CRx writes cause a trap d; our trap handler will decide to interpret it or not. */
-        if (pCpu->pCurInstr->param2 == OP_PARM_Cd)
+        if (pCpu->pCurInstr->fParam2 == OP_PARM_Cd)
         {
             rc = patmPatchGenMovControl(pVM, pPatch, pCpu);
@@ -2000 +2000 @@
 
     default:
-        if (pCpu->pCurInstr->optype & (DISOPTYPE_CONTROLFLOW | DISOPTYPE_PRIVILEGED_NOTRAP))
+        if (pCpu->pCurInstr->fOpType & (DISOPTYPE_CONTROLFLOW | DISOPTYPE_PRIVILEGED_NOTRAP))
         {
 gen_illegal_instr:
@@ -2049 +2049 @@
         if (    (pPatch->flags & PATMFL_CHECK_SIZE)
              &&  pCurInstrGC + pCpu->cbInstr - pInstrGC >= SIZEOF_NEARJUMP32
-             &&  !(pCpu->pCurInstr->optype & DISOPTYPE_RELATIVE_CONTROLFLOW)
+             &&  !(pCpu->pCurInstr->fOpType & DISOPTYPE_RELATIVE_CONTROLFLOW)
              &&  !(pPatch->flags & PATMFL_RECOMPILE_NEXT) /* do not do this when the next instruction *must* be executed! */
            )
@@ -2232 +2232 @@
 
         /* For our first attempt, we'll handle only simple relative jumps and calls (immediate offset coded in instruction) */
-        if (   (cpu.pCurInstr->optype & DISOPTYPE_CONTROLFLOW)
-            && (OP_PARM_VTYPE(cpu.pCurInstr->param1) == OP_PARM_J)
+        if (   (cpu.pCurInstr->fOpType & DISOPTYPE_CONTROLFLOW)
+            && (OP_PARM_VTYPE(cpu.pCurInstr->fParam1) == OP_PARM_J)
             &&  cpu.pCurInstr->uOpcode != OP_CALL /* complete functions are replaced; don't bother here. */
            )
@@ -2419 +2419 @@
 
                 default:
-                    if (cpunext.pCurInstr->optype & DISOPTYPE_CONTROLFLOW)
+                    if (cpunext.pCurInstr->fOpType & DISOPTYPE_CONTROLFLOW)
                     {
                         Log(("Unexpected control flow instruction after inhibit irq instruction\n"));
@@ -2453 +2453 @@
 
         /* For our first attempt, we'll handle only simple relative jumps and calls (immediate offset coded in instruction). */
-        if (   (cpu.pCurInstr->optype & DISOPTYPE_CONTROLFLOW)
-            && (OP_PARM_VTYPE(cpu.pCurInstr->param1) == OP_PARM_J)
+        if (   (cpu.pCurInstr->fOpType & DISOPTYPE_CONTROLFLOW)
+            && (OP_PARM_VTYPE(cpu.pCurInstr->fParam1) == OP_PARM_J)
             &&  cpu.pCurInstr->uOpcode != OP_CALL /* complete functions are replaced; don't bother here. */
            )
@@ -2469 +2469 @@
 
             /* We don't check if the branch target lies in a valid page as we've already done that in the analysis phase. */
-            if (!(cpu.pCurInstr->optype & DISOPTYPE_UNCOND_CONTROLFLOW))
+            if (!(cpu.pCurInstr->fOpType & DISOPTYPE_UNCOND_CONTROLFLOW))
             {
                 Log(("patmRecompileCodeStream continue passed conditional jump\n"));
@@ -2517 +2517 @@
         }
         else
-        if (cpu.pCurInstr->optype & DISOPTYPE_UNCOND_CONTROLFLOW)
+        if (cpu.pCurInstr->fOpType & DISOPTYPE_UNCOND_CONTROLFLOW)
         {
             rc = VINF_SUCCESS;
@@ -5198 +5198 @@
     if (    disret == true
         && (pConflictPatch->flags & PATMFL_CODE32)
-        && (cpu.pCurInstr->uOpcode == OP_JMP || (cpu.pCurInstr->optype & DISOPTYPE_COND_CONTROLFLOW))
+        && (cpu.pCurInstr->uOpcode == OP_JMP || (cpu.pCurInstr->fOpType & DISOPTYPE_COND_CONTROLFLOW))
         && (cpu.param1.fUse & DISUSE_IMMEDIATE32_REL))
     {
@@ -6014 +6014 @@
         rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCurPatchInstrGC, &CpuOld, 0);
         if (    RT_FAILURE(rc)
-            ||  !(CpuOld.pCurInstr->optype & DISOPTYPE_HARMLESS))
+            ||  !(CpuOld.pCurInstr->fOpType & DISOPTYPE_HARMLESS))
         {
             if (RT_SUCCESS(rc))
@@ -6050 +6050 @@
 
     if (    RT_SUCCESS(rc)
-        &&  (CpuOld.pCurInstr->optype & DISOPTYPE_HARMLESS)
+        &&  (CpuOld.pCurInstr->fOpType & DISOPTYPE_HARMLESS)
        )
     {
@@ -6065 +6065 @@
             rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCurInstrGC, &CpuNew, 0);
 
-            fValidInstr = !!(CpuNew.pCurInstr->optype & DISOPTYPE_HARMLESS);
+            fValidInstr = !!(CpuNew.pCurInstr->fOpType & DISOPTYPE_HARMLESS);
             if (    !fValidInstr
-                &&  (CpuNew.pCurInstr->optype & DISOPTYPE_RELATIVE_CONTROLFLOW)
+                &&  (CpuNew.pCurInstr->fOpType & DISOPTYPE_RELATIVE_CONTROLFLOW)
                )
             {

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

@@ -235 +235 @@
          *  cli
          */
-        if (pCpu->pCurInstr->param1 == OP_PARM_REG_CS)
+        if (pCpu->pCurInstr->fParam1 == OP_PARM_REG_CS)
             return PATMPatchOpenBSDHandlerPrefix(pVM, pCpu, pInstrGC, pInstrHC, pPatchRec);
 

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

@@ -695 +695 @@
         Log(("patmPatchGenIndirectCall\n"));
         Assert(pCpu->param1.cb == 4);
-        Assert(OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J);
+        Assert(OP_PARM_VTYPE(pCpu->pCurInstr->fParam1) != OP_PARM_J);
 
         /* We push it onto the stack here, so the guest's context isn't ruined when this happens to cause
@@ -720 +720 @@
         AssertMsg(PATMIsPatchGCAddr(pVM, pTargetGC) == false, ("Target is already a patch address (%RRv)?!?\n", pTargetGC));
         Assert(pTargetGC);
-        Assert(OP_PARM_VTYPE(pCpu->pCurInstr->param1) == OP_PARM_J);
+        Assert(OP_PARM_VTYPE(pCpu->pCurInstr->fParam1) == OP_PARM_J);
 
         /** @todo wasting memory as the complex search is overkill and we need only one lookup slot... */
@@ -791 +791 @@
     Log(("patmPatchGenIndirectJump\n"));
     Assert(pCpu->param1.cb == 4);
-    Assert(OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J);
+    Assert(OP_PARM_VTYPE(pCpu->pCurInstr->fParam1) != OP_PARM_J);
 
     /* We push it onto the stack here, so the guest's context isn't ruined when this happens to cause
@@ -1158 +1158 @@
     mod = 0;            //effective address (only)
     rm  = 5;            //disp32
-    if (pCpu->pCurInstr->param1 == OP_PARM_Dd)
+    if (pCpu->pCurInstr->fParam1 == OP_PARM_Dd)
     {
         Assert(0);  // You not come here. Illegal!
@@ -1208 +1208 @@
     mod = 0;            //effective address (only)
     rm  = 5;            //disp32
-    if (pCpu->pCurInstr->param1 == OP_PARM_Cd)
+    if (pCpu->pCurInstr->fParam1 == OP_PARM_Cd)
     {
         Assert(0);  // You not come here. Illegal!