Changeset 54764 in vbox for trunk/src/VBox/VMM

Timestamp:

Mar 15, 2015 3:25:11 AM (10 years ago)

Author:

vboxsync

Message:

Added an infix 'ASMFIX' to the PATMA.h fixup types used in the patch template code in PATMA.asm.

Location:

trunk/src/VBox/VMM

Files:

• VMMR3/PATM.cpp (modified) (3 diffs)
• VMMR3/PATMA.asm (modified) (144 diffs)
• VMMR3/PATMA.mac (modified) (3 diffs)
• VMMR3/PATMPatch.cpp (modified) (17 diffs)
• VMMR3/PATMSSM.cpp (modified) (11 diffs)
• include/PATMA.h (modified) (3 diffs)
• include/PATMInternal.h (modified) (2 diffs)

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

@@ -784 +784 @@
         {
         case FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL:
-            Assert(pRec->pDest == pRec->pSource); Assert(PATM_IS_FIXUP_TYPE(pRec->pSource));
+            Assert(pRec->pDest == pRec->pSource); Assert(PATM_IS_ASMFIX(pRec->pSource));
             Log(("Absolute patch template fixup type %#x at %RHv -> %RHv at %RRv\n", pRec->pSource, *(RTRCUINTPTR *)pRec->pRelocPos, *(RTRCINTPTR*)pRec->pRelocPos + delta, pRec->pRelocPos));
             *(RTRCUINTPTR *)pRec->pRelocPos += delta;
@@ -942 +942 @@
             /* Only applicable when loading state. */
             Assert(pRec->pDest == pRec->pSource);
-            Assert(PATM_IS_FIXUP_TYPE(pRec->pSource));
+            Assert(PATM_IS_ASMFIX(pRec->pSource));
             break;
 
@@ -3606 +3606 @@
     if (pPatchTargetGC)
     {
-        /* Create a trampoline that also sets PATM_INTERRUPTFLAG. */
+        /* Create a trampoline that also sets PATM_ASMFIX_INTERRUPTFLAG. */
         rc = PATMR3InstallPatch(pVM, pBranchTarget, PATMFL_CODE32 | PATMFL_TRAMPOLINE);
     }

trunk/src/VBox/VMM/VMMR3/PATMA.asm

@@ -208 +208 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMStats
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushf
-    inc     dword [ss:PATM_ALLPATCHCALLS]
-    inc     dword [ss:PATM_PERPATCHCALLS]
+    inc     dword [ss:PATM_ASMFIX_ALLPATCHCALLS]
+    inc     dword [ss:PATM_ASMFIX_PERPATCHCALLS]
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMStats
 
@@ -220 +220 @@
 GLOBALNAME g_patmStatsRecord
     PATCHASMRECORD_INIT PATMStats, 4
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_ALLPATCHCALLS, 0
-    DD      PATM_PERPATCHCALLS, 0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_ALLPATCHCALLS, 0
+    DD      PATM_ASMFIX_PERPATCHCALLS, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 %endif ; VBOX_WITH_STATISTICS
@@ -229 +229 @@
 
 ;
-; Set PATM_INTERRUPTFLAG
+; Set PATM_ASMFIX_INTERRUPTFLAG
 ;
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMSetPIF
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMSetPIF
 
-; Patch record for setting PATM_INTERRUPTFLAG
+; Patch record for setting PATM_ASMFIX_INTERRUPTFLAG
 BEGIN_PATCH_RODATA_SECTION
 GLOBALNAME g_patmSetPIFRecord
     PATCHASMRECORD_INIT PATMSetPIF, 1
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      0ffffffffh, 0ffffffffh
-
-;
-; Clear PATM_INTERRUPTFLAG
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      0ffffffffh, 0ffffffffh
+
+;
+; Clear PATM_ASMFIX_INTERRUPTFLAG
 ;
 BEGIN_PATCH_CODE_SECTION
@@ -251 +251 @@
     not     dword [esp-64]
     not     dword [esp-64]
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
 ENDPROC     PATMClearPIF
 
-; Patch record for clearing PATM_INTERRUPTFLAG
+; Patch record for clearing PATM_ASMFIX_INTERRUPTFLAG
 BEGIN_PATCH_RODATA_SECTION
 GLOBALNAME g_patmClearPIFRecord
     PATCHASMRECORD_INIT PATMClearPIF, 1
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      0ffffffffh, 0ffffffffh
-
-;
-; Clear PATM_INHIBITIRQADDR and fault if IF=0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      0ffffffffh, 0ffffffffh
+
+;
+; Clear PATM_ASMFIX_INHIBITIRQADDR and fault if IF=0
 ;
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMClearInhibitIRQFaultIF0
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
-    mov     dword [ss:PATM_INHIBITIRQADDR], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INHIBITIRQADDR], 0
     pushf
 
-    test    dword [ss:PATM_VMFLAGS], X86_EFL_IF
+    test    dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF
     jz      PATMClearInhibitIRQFaultIF0_Fault
 
     ; if interrupts are pending, then we must go back to the host context to handle them!
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
+    test    dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMClearInhibitIRQFaultIF0_Continue
 
     ; Go to our hypervisor trap handler to dispatch the pending irq
-    mov     dword [ss:PATM_TEMP_EAX], eax
-    mov     dword [ss:PATM_TEMP_ECX], ecx
-    mov     dword [ss:PATM_TEMP_EDI], edi
-    mov     dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
+    mov     dword [ss:PATM_ASMFIX_TEMP_EAX], eax
+    mov     dword [ss:PATM_ASMFIX_TEMP_ECX], ecx
+    mov     dword [ss:PATM_ASMFIX_TEMP_EDI], edi
+    mov     dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
     mov     eax, PATM_ACTION_DISPATCH_PENDING_IRQ
-    lock    or dword [ss:PATM_PENDINGACTION], eax
-    mov     ecx, PATM_ACTION_MAGIC
-    mov     edi, PATM_NEXTINSTRADDR
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
+    mov     ecx, PATM_ACTION_MAGIC
+    mov     edi, PATM_ASMFIX_NEXTINSTRADDR
     popfd                   ; restore flags we pushed above (the or instruction changes the flags as well)
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -292 +292 @@
 PATMClearInhibitIRQFaultIF0_Fault:
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
 PATMClearInhibitIRQFaultIF0_Continue:
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMClearInhibitIRQFaultIF0
 
-; Patch record for clearing PATM_INHIBITIRQADDR
+; Patch record for clearing PATM_ASMFIX_INHIBITIRQADDR
 BEGIN_PATCH_RODATA_SECTION
 GLOBALNAME g_patmClearInhibitIRQFaultIF0Record
     PATCHASMRECORD_INIT PATMClearInhibitIRQFaultIF0, 12
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      PATM_INHIBITIRQADDR,     0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VM_FORCEDACTIONS,   0
-    DD      PATM_TEMP_EAX,           0
-    DD      PATM_TEMP_ECX,           0
-    DD      PATM_TEMP_EDI,           0
-    DD      PATM_TEMP_RESTORE_FLAGS, 0
-    DD      PATM_PENDINGACTION,      0
-    DD      PATM_NEXTINSTRADDR,      0
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      0ffffffffh, 0ffffffffh
-
-
-;
-; Clear PATM_INHIBITIRQADDR and continue if IF=0 (duplicated function only; never jump back to guest code afterwards!!)
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INHIBITIRQADDR,     0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VM_FORCEDACTIONS,   0
+    DD      PATM_ASMFIX_TEMP_EAX,           0
+    DD      PATM_ASMFIX_TEMP_ECX,           0
+    DD      PATM_ASMFIX_TEMP_EDI,           0
+    DD      PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
+    DD      PATM_ASMFIX_NEXTINSTRADDR,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      0ffffffffh, 0ffffffffh
+
+
+;
+; Clear PATM_ASMFIX_INHIBITIRQADDR and continue if IF=0 (duplicated function only; never jump back to guest code afterwards!!)
 ;
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMClearInhibitIRQContIF0
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
-    mov     dword [ss:PATM_INHIBITIRQADDR], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INHIBITIRQADDR], 0
     pushf
 
-    test    dword [ss:PATM_VMFLAGS], X86_EFL_IF
+    test    dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF
     jz      PATMClearInhibitIRQContIF0_Continue
 
     ; if interrupts are pending, then we must go back to the host context to handle them!
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
+    test    dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMClearInhibitIRQContIF0_Continue
 
     ; Go to our hypervisor trap handler to dispatch the pending irq
-    mov     dword [ss:PATM_TEMP_EAX], eax
-    mov     dword [ss:PATM_TEMP_ECX], ecx
-    mov     dword [ss:PATM_TEMP_EDI], edi
-    mov     dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
+    mov     dword [ss:PATM_ASMFIX_TEMP_EAX], eax
+    mov     dword [ss:PATM_ASMFIX_TEMP_ECX], ecx
+    mov     dword [ss:PATM_ASMFIX_TEMP_EDI], edi
+    mov     dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
     mov     eax, PATM_ACTION_DISPATCH_PENDING_IRQ
-    lock    or dword [ss:PATM_PENDINGACTION], eax
-    mov     ecx, PATM_ACTION_MAGIC
-    mov     edi, PATM_NEXTINSTRADDR
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
+    mov     ecx, PATM_ACTION_MAGIC
+    mov     edi, PATM_ASMFIX_NEXTINSTRADDR
     popfd                   ; restore flags we pushed above (the or instruction changes the flags as well)
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -350 +350 @@
 PATMClearInhibitIRQContIF0_Continue:
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMClearInhibitIRQContIF0
 
-; Patch record for clearing PATM_INHIBITIRQADDR
+; Patch record for clearing PATM_ASMFIX_INHIBITIRQADDR
 BEGIN_PATCH_RODATA_SECTION
 GLOBALNAME g_patmClearInhibitIRQContIF0Record
     PATCHASMRECORD_INIT PATMClearInhibitIRQContIF0, 11
-    DD      PATM_INTERRUPTFLAG,      0   
-    DD      PATM_INHIBITIRQADDR,     0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VM_FORCEDACTIONS,   0
-    DD      PATM_TEMP_EAX,           0
-    DD      PATM_TEMP_ECX,           0
-    DD      PATM_TEMP_EDI,           0
-    DD      PATM_TEMP_RESTORE_FLAGS, 0
-    DD      PATM_PENDINGACTION,      0
-    DD      PATM_NEXTINSTRADDR,      0
-    DD      PATM_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0   
+    DD      PATM_ASMFIX_INHIBITIRQADDR,     0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VM_FORCEDACTIONS,   0
+    DD      PATM_ASMFIX_TEMP_EAX,           0
+    DD      PATM_ASMFIX_TEMP_ECX,           0
+    DD      PATM_ASMFIX_TEMP_EDI,           0
+    DD      PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
+    DD      PATM_ASMFIX_NEXTINSTRADDR,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
     DD      0ffffffffh, 0ffffffffh
 
@@ -376 +376 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMCliReplacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushf
 %ifdef PATM_LOG_PATCHINSTR
@@ -382 +382 @@
     push    ecx
     mov     eax, PATM_ACTION_LOG_CLI
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -389 +389 @@
 %endif
 
-    and     dword [ss:PATM_VMFLAGS], ~X86_EFL_IF
+    and     dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IF
     popf
 
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMCliJump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 ENDPROC     PATMCliReplacement
 
@@ -406 +406 @@
     PATCHASMRECORD_INIT_JUMP PATMCliReplacement, PATMCliJump, 3
 %endif
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
 %ifdef PATM_LOG_PATCHINSTR
-    DD      PATM_PENDINGACTION, 0
-%endif
-    DD      PATM_VMFLAGS,       0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_PENDINGACTION, 0
+%endif
+    DD      PATM_ASMFIX_VMFLAGS,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -420 +420 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMStiReplacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
-    mov     dword [ss:PATM_INHIBITIRQADDR], PATM_NEXTINSTRADDR
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INHIBITIRQADDR], PATM_ASMFIX_NEXTINSTRADDR
     pushf
 %ifdef PATM_LOG_PATCHINSTR
@@ -427 +427 @@
     push    ecx
     mov     eax, PATM_ACTION_LOG_STI
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -433 +433 @@
     pop     eax
 %endif
-    or      dword [ss:PATM_VMFLAGS], X86_EFL_IF
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMStiReplacement
 
@@ -446 +446 @@
     PATCHASMRECORD_INIT PATMStiReplacement, 5
 %endif
-    DD      PATM_INTERRUPTFLAG,  0
-    DD      PATM_INHIBITIRQADDR, 0
-    DD      PATM_NEXTINSTRADDR,  0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,  0
+    DD      PATM_ASMFIX_INHIBITIRQADDR, 0
+    DD      PATM_ASMFIX_NEXTINSTRADDR,  0
 %ifdef PATM_LOG_PATCHINSTR
-    DD      PATM_PENDINGACTION,  0
-%endif
-    DD      PATM_VMFLAGS,        0
-    DD      PATM_INTERRUPTFLAG,  0
+    DD      PATM_ASMFIX_PENDINGACTION,  0
+%endif
+    DD      PATM_ASMFIX_VMFLAGS,        0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,  0
     DD      0ffffffffh, 0ffffffffh
 
@@ -472 +472 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMTrapEntry
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushf
 
@@ -481 +481 @@
     lea     edx, dword [ss:esp+12+4]        ;3 dwords + pushed flags -> iret eip
     mov     eax, PATM_ACTION_LOG_GATE_ENTRY
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -502 +502 @@
     ; correct EFLAGS on the stack to include the current IOPL
     push    eax
-    mov     eax, dword [ss:PATM_VMFLAGS]
+    mov     eax, dword [ss:PATM_ASMFIX_VMFLAGS]
     and     eax, X86_EFL_IOPL
     and     dword [esp+16], ~X86_EFL_IOPL       ; esp+16 = eflags = esp+8+4(efl)+4(eax)
@@ -509 +509 @@
 
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMTrapEntryJump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 ENDPROC     PATMTrapEntry
 
@@ -523 +523 @@
     PATCHASMRECORD_INIT_JUMP PATMTrapEntry, PATMTrapEntryJump, 3
 %endif
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
 %ifdef PATM_LOG_PATCHIRET
-    DD      PATM_PENDINGACTION, 0
-%endif
-    DD      PATM_VMFLAGS,       0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_PENDINGACTION, 0
+%endif
+    DD      PATM_ASMFIX_VMFLAGS,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -549 +549 @@
 BEGINPROC   PATMTrapEntryErrorCode
 PATMTrapErrorCodeEntryStart:
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushf
 
@@ -558 +558 @@
     lea     edx, dword [ss:esp+12+4+4]        ;3 dwords + pushed flags + error code -> iret eip
     mov     eax, PATM_ACTION_LOG_GATE_ENTRY
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -579 +579 @@
     ; correct EFLAGS on the stack to include the current IOPL
     push    eax
-    mov     eax, dword [ss:PATM_VMFLAGS]
+    mov     eax, dword [ss:PATM_ASMFIX_VMFLAGS]
     and     eax, X86_EFL_IOPL
     and     dword [esp+20], ~X86_EFL_IOPL       ; esp+20 = eflags = esp+8+4(efl)+4(error code)+4(eax)
@@ -586 +586 @@
 
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMTrapErrorCodeEntryJump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 ENDPROC     PATMTrapEntryErrorCode
 
@@ -600 +600 @@
     PATCHASMRECORD_INIT_JUMP PATMTrapEntryErrorCode, PATMTrapErrorCodeEntryJump, 3
 %endif
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
 %ifdef PATM_LOG_PATCHIRET
-    DD      PATM_PENDINGACTION, 0
-%endif
-    DD      PATM_VMFLAGS,       0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_PENDINGACTION, 0
+%endif
+    DD      PATM_ASMFIX_VMFLAGS,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -624 +624 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMIntEntry
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushf
 
@@ -633 +633 @@
     lea     edx, dword [ss:esp+12+4]        ;3 dwords + pushed flags -> iret eip
     mov     eax, PATM_ACTION_LOG_GATE_ENTRY
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -654 +654 @@
     ; correct EFLAGS on the stack to include the current IOPL
     push    eax
-    mov     eax, dword [ss:PATM_VMFLAGS]
+    mov     eax, dword [ss:PATM_ASMFIX_VMFLAGS]
     and     eax, X86_EFL_IOPL
     and     dword [esp+16], ~X86_EFL_IOPL       ; esp+16 = eflags = esp+8+4(efl)+4(eax)
@@ -661 +661 @@
 
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMIntEntry
 
@@ -672 +672 @@
     PATCHASMRECORD_INIT PATMIntEntry, 3
 %endif
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
 %ifdef PATM_LOG_PATCHIRET
-    DD      PATM_PENDINGACTION, 0
-%endif
-    DD      PATM_VMFLAGS,       0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_PENDINGACTION, 0
+%endif
+    DD      PATM_ASMFIX_VMFLAGS,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -697 +697 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMIntEntryErrorCode
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushf
 
@@ -706 +706 @@
     lea     edx, dword [ss:esp+12+4+4]        ;3 dwords + pushed flags + error code -> iret eip
     mov     eax, PATM_ACTION_LOG_GATE_ENTRY
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -727 +727 @@
     ; correct EFLAGS on the stack to include the current IOPL
     push    eax
-    mov     eax, dword [ss:PATM_VMFLAGS]
+    mov     eax, dword [ss:PATM_ASMFIX_VMFLAGS]
     and     eax, X86_EFL_IOPL
     and     dword [esp+20], ~X86_EFL_IOPL       ; esp+20 = eflags = esp+8+4(efl)+4(eax)+4(error code)
@@ -734 +734 @@
 
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMIntEntryErrorCode
 
@@ -745 +745 @@
     PATCHASMRECORD_INIT PATMIntEntryErrorCode, 3
 %endif
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
 %ifdef PATM_LOG_PATCHIRET
-    DD      PATM_PENDINGACTION, 0
-%endif
-    DD      PATM_VMFLAGS,       0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_PENDINGACTION, 0
+%endif
+    DD      PATM_ASMFIX_VMFLAGS,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -759 +759 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMPopf32Replacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
 %ifdef PATM_LOG_PATCHINSTR
     push    eax
@@ -769 +769 @@
 
 PATMPopf32_Log:
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -778 +778 @@
     test    dword [esp], X86_EFL_IF
     jnz     PATMPopf32_Ok
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -785 +785 @@
     ; In this particular patch it's rather unlikely the pushf was included, so we have no way to check if the flags on the stack were correctly synced
     ; PATMPopf32Replacement_NoExit is different, because it's only used in IDT and function patches
-    or      dword [ss:PATM_VMFLAGS], X86_EFL_IF
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF
 
     ; if interrupts are pending, then we must go back to the host context to handle them!
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
+    test    dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMPopf32_Continue
 
     ; Go to our hypervisor trap handler to dispatch the pending irq
-    mov     dword [ss:PATM_TEMP_EAX], eax
-    mov     dword [ss:PATM_TEMP_ECX], ecx
-    mov     dword [ss:PATM_TEMP_EDI], edi
-    mov     dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
+    mov     dword [ss:PATM_ASMFIX_TEMP_EAX], eax
+    mov     dword [ss:PATM_ASMFIX_TEMP_ECX], ecx
+    mov     dword [ss:PATM_ASMFIX_TEMP_EDI], edi
+    mov     dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
     mov     eax, PATM_ACTION_DISPATCH_PENDING_IRQ
-    lock    or dword [ss:PATM_PENDINGACTION], eax
-    mov     ecx, PATM_ACTION_MAGIC
-    mov     edi, PATM_NEXTINSTRADDR
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
+    mov     ecx, PATM_ACTION_MAGIC
+    mov     edi, PATM_ASMFIX_NEXTINSTRADDR
 
     popfd                   ; restore flags we pushed above (the or instruction changes the flags as well)
@@ -807 +807 @@
 PATMPopf32_Continue:
     popfd                   ; restore flags we pushed above
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMPopf32Jump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 ENDPROC     PATMPopf32Replacement
 
@@ -821 +821 @@
     PATCHASMRECORD_INIT_JUMP PATMPopf32Replacement, PATMPopf32Jump, 11
 %endif
-    DD      PATM_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
 %ifdef PATM_LOG_PATCHINSTR
-    DD      PATM_PENDINGACTION,      0
-%endif
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VM_FORCEDACTIONS,   0
-    DD      PATM_TEMP_EAX,           0
-    DD      PATM_TEMP_ECX,           0
-    DD      PATM_TEMP_EDI,           0
-    DD      PATM_TEMP_RESTORE_FLAGS, 0
-    DD      PATM_PENDINGACTION,      0
-    DD      PATM_NEXTINSTRADDR,      0
-    DD      PATM_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
+%endif
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VM_FORCEDACTIONS,   0
+    DD      PATM_ASMFIX_TEMP_EAX,           0
+    DD      PATM_ASMFIX_TEMP_ECX,           0
+    DD      PATM_ASMFIX_TEMP_EDI,           0
+    DD      PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
+    DD      PATM_ASMFIX_NEXTINSTRADDR,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
     DD      0ffffffffh, 0ffffffffh
 
@@ -843 +843 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMPopf32Replacement_NoExit
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
 %ifdef PATM_LOG_PATCHINSTR
     push    eax
@@ -853 +853 @@
 
 PATMPopf32_NoExitLog:
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -863 +863 @@
 
     ; if interrupts are pending, then we must go back to the host context to handle them!
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
+    test    dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMPopf32_NoExit_Continue
 
     ; Go to our hypervisor trap handler to dispatch the pending irq
-    mov     dword [ss:PATM_TEMP_EAX], eax
-    mov     dword [ss:PATM_TEMP_ECX], ecx
-    mov     dword [ss:PATM_TEMP_EDI], edi
-    mov     dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
+    mov     dword [ss:PATM_ASMFIX_TEMP_EAX], eax
+    mov     dword [ss:PATM_ASMFIX_TEMP_ECX], ecx
+    mov     dword [ss:PATM_ASMFIX_TEMP_EDI], edi
+    mov     dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
     mov     eax, PATM_ACTION_DISPATCH_PENDING_IRQ
-    lock    or dword [ss:PATM_PENDINGACTION], eax
-    mov     ecx, PATM_ACTION_MAGIC
-    mov     edi, PATM_NEXTINSTRADDR
-
-    pop     dword [ss:PATM_VMFLAGS]     ; restore flags now (the or instruction changes the flags as well)
-    push    dword [ss:PATM_VMFLAGS]
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
+    mov     ecx, PATM_ACTION_MAGIC
+    mov     edi, PATM_ASMFIX_NEXTINSTRADDR
+
+    pop     dword [ss:PATM_ASMFIX_VMFLAGS]     ; restore flags now (the or instruction changes the flags as well)
+    push    dword [ss:PATM_ASMFIX_VMFLAGS]
     popfd
 
@@ -884 +884 @@
 
 PATMPopf32_NoExit_Continue:
-    pop     dword [ss:PATM_VMFLAGS]
-    push    dword [ss:PATM_VMFLAGS]
-    popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    pop     dword [ss:PATM_ASMFIX_VMFLAGS]
+    push    dword [ss:PATM_ASMFIX_VMFLAGS]
+    popfd
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMPopf32Replacement_NoExit
 
@@ -898 +898 @@
     PATCHASMRECORD_INIT PATMPopf32Replacement_NoExit, 13
 %endif
-    DD      PATM_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
 %ifdef PATM_LOG_PATCHINSTR
-    DD      PATM_PENDINGACTION,      0
-%endif
-    DD      PATM_VM_FORCEDACTIONS,   0
-    DD      PATM_TEMP_EAX,           0
-    DD      PATM_TEMP_ECX,           0
-    DD      PATM_TEMP_EDI,           0
-    DD      PATM_TEMP_RESTORE_FLAGS, 0
-    DD      PATM_PENDINGACTION,      0
-    DD      PATM_NEXTINSTRADDR,      0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
+%endif
+    DD      PATM_ASMFIX_VM_FORCEDACTIONS,   0
+    DD      PATM_ASMFIX_TEMP_EAX,           0
+    DD      PATM_ASMFIX_TEMP_ECX,           0
+    DD      PATM_ASMFIX_TEMP_EDI,           0
+    DD      PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
+    DD      PATM_ASMFIX_NEXTINSTRADDR,      0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
     DD      0ffffffffh, 0ffffffffh
 
@@ -922 +922 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMPopf16Replacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     test    word [esp], X86_EFL_IF
     jnz     PATMPopf16_Ok
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -931 +931 @@
     ; if interrupts are pending, then we must go back to the host context to handle them!
     ; @note we destroy the flags here, but that should really not matter (PATM_INT3 case)
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
+    test    dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMPopf16_Continue
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
 PATMPopf16_Continue:
 
-    pop     word [ss:PATM_VMFLAGS]
-    push    word [ss:PATM_VMFLAGS]
-    and     dword [ss:PATM_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK
-    or      dword [ss:PATM_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK
+    pop     word [ss:PATM_ASMFIX_VMFLAGS]
+    push    word [ss:PATM_ASMFIX_VMFLAGS]
+    and     dword [ss:PATM_ASMFIX_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK
 
     DB      0x66    ; size override
     popf    ;after the and and or operations!! (flags must be preserved)
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 
     DB      0xE9
 PATMPopf16Jump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 ENDPROC     PATMPopf16Replacement
 
@@ -956 +956 @@
 GLOBALNAME g_patmPopf16Record
     PATCHASMRECORD_INIT_JUMP PATMPopf16Replacement, PATMPopf16Jump, 9
-    DD      PATM_INTERRUPTFLAG,    0
-    DD      PATM_INTERRUPTFLAG,    0
-    DD      PATM_VM_FORCEDACTIONS, 0
-    DD      PATM_INTERRUPTFLAG,    0
-    DD      PATM_VMFLAGS,          0
-    DD      PATM_VMFLAGS,          0
-    DD      PATM_VMFLAGS,          0
-    DD      PATM_VMFLAGS,          0
-    DD      PATM_INTERRUPTFLAG,    0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,    0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,    0
+    DD      PATM_ASMFIX_VM_FORCEDACTIONS, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,    0
+    DD      PATM_ASMFIX_VMFLAGS,          0
+    DD      PATM_ASMFIX_VMFLAGS,          0
+    DD      PATM_ASMFIX_VMFLAGS,          0
+    DD      PATM_ASMFIX_VMFLAGS,          0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,    0
     DD      0ffffffffh, 0ffffffffh
 
@@ -974 +974 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMPopf16Replacement_NoExit
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     test    word [esp], X86_EFL_IF
     jnz     PATMPopf16_Ok_NoExit
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -983 +983 @@
     ; if interrupts are pending, then we must go back to the host context to handle them!
     ; @note we destroy the flags here, but that should really not matter (PATM_INT3 case)
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
+    test    dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMPopf16_Continue_NoExit
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
 PATMPopf16_Continue_NoExit:
 
-    pop     word [ss:PATM_VMFLAGS]
-    push    word [ss:PATM_VMFLAGS]
-    and     dword [ss:PATM_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK
-    or      dword [ss:PATM_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK
+    pop     word [ss:PATM_ASMFIX_VMFLAGS]
+    push    word [ss:PATM_ASMFIX_VMFLAGS]
+    and     dword [ss:PATM_ASMFIX_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK
 
     DB      0x66    ; size override
     popf    ;after the and and or operations!! (flags must be preserved)
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMPopf16Replacement_NoExit
 
@@ -1004 +1004 @@
 GLOBALNAME g_patmPopf16Record_NoExit
     PATCHASMRECORD_INIT PATMPopf16Replacement_NoExit, 9
-    DD      PATM_INTERRUPTFLAG,    0
-    DD      PATM_INTERRUPTFLAG,    0
-    DD      PATM_VM_FORCEDACTIONS, 0
-    DD      PATM_INTERRUPTFLAG,    0
-    DD      PATM_VMFLAGS,          0
-    DD      PATM_VMFLAGS,          0
-    DD      PATM_VMFLAGS,          0
-    DD      PATM_VMFLAGS,          0
-    DD      PATM_INTERRUPTFLAG,    0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,    0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,    0
+    DD      PATM_ASMFIX_VM_FORCEDACTIONS, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,    0
+    DD      PATM_ASMFIX_VMFLAGS,          0
+    DD      PATM_ASMFIX_VMFLAGS,          0
+    DD      PATM_ASMFIX_VMFLAGS,          0
+    DD      PATM_ASMFIX_VMFLAGS,          0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,    0
     DD      0ffffffffh, 0ffffffffh
 
@@ -1021 +1021 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMPushf32Replacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushfd
 %ifdef PATM_LOG_PATCHINSTR
@@ -1027 +1027 @@
     push    ecx
     mov     eax, PATM_ACTION_LOG_PUSHF
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -1038 +1038 @@
     mov     eax, dword [esp+8]
     and     eax, PATM_FLAGS_MASK
-    or      eax, dword [ss:PATM_VMFLAGS]
+    or      eax, dword [ss:PATM_ASMFIX_VMFLAGS]
     mov     dword [esp+8], eax
     pop     eax
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMPushf32Replacement
 
@@ -1053 +1053 @@
     PATCHASMRECORD_INIT PATMPushf32Replacement, 3
 %endif
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
 %ifdef PATM_LOG_PATCHINSTR
-    DD      PATM_PENDINGACTION, 0
-%endif
-    DD      PATM_VMFLAGS,       0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_PENDINGACTION, 0
+%endif
+    DD      PATM_ASMFIX_VMFLAGS,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -1067 +1067 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMPushf16Replacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     DB      0x66    ; size override
     pushf
@@ -1076 +1076 @@
     mov     ax, word [esp+6]
     and     eax, PATM_FLAGS_MASK
-    or      eax, dword [ss:PATM_VMFLAGS]
+    or      eax, dword [ss:PATM_ASMFIX_VMFLAGS]
     mov     word [esp+6], ax
     pop     eax
@@ -1082 +1082 @@
     DB      0x66    ; size override
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC     PATMPushf16Replacement
 
@@ -1089 +1089 @@
 GLOBALNAME g_patmPushf16Record
     PATCHASMRECORD_INIT PATMPushf16Replacement, 3
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_VMFLAGS,       0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_VMFLAGS,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -1100 +1100 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMPushCSReplacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     push    cs
     pushfd
@@ -1113 +1113 @@
     popfd
 
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMPushCSJump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 ENDPROC     PATMPushCSReplacement
 
@@ -1123 +1123 @@
 GLOBALNAME g_patmPushCSRecord
     PATCHASMRECORD_INIT_JUMP PATMPushCSReplacement, PATMPushCSJump, 2
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -1163 +1163 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMIretReplacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushfd
 
@@ -1172 +1172 @@
     lea     edx, dword [ss:esp+12+4]        ;3 dwords + pushed flags -> iret eip
     mov     eax, PATM_ACTION_LOG_IRET
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -1204 +1204 @@
 ; Note: This is very important as pending pic interrupts can be overridden by apic interrupts if we don't check early enough (Fedora 5 boot)
 ; @@todo fix this properly, so we can dispatch pending interrupts in GC
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC
+    test    dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC
     jz      iret_continue
 
 ; Go to our hypervisor trap handler to dispatch the pending irq
-    mov     dword [ss:PATM_TEMP_EAX], eax
-    mov     dword [ss:PATM_TEMP_ECX], ecx
-    mov     dword [ss:PATM_TEMP_EDI], edi
-    mov     dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
+    mov     dword [ss:PATM_ASMFIX_TEMP_EAX], eax
+    mov     dword [ss:PATM_ASMFIX_TEMP_ECX], ecx
+    mov     dword [ss:PATM_ASMFIX_TEMP_EDI], edi
+    mov     dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
     mov     eax, PATM_ACTION_PENDING_IRQ_AFTER_IRET
-    lock    or dword [ss:PATM_PENDINGACTION], eax
-    mov     ecx, PATM_ACTION_MAGIC
-    mov     edi, PATM_CURINSTRADDR
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
+    mov     ecx, PATM_ACTION_MAGIC
+    mov     edi, PATM_ASMFIX_CURINSTRADDR
 
     popfd
@@ -1229 +1229 @@
     mov     eax, dword [esp+16]
     and     eax, X86_EFL_IOPL
-    and     dword [ss:PATM_VMFLAGS], ~X86_EFL_IOPL
-    or      dword [ss:PATM_VMFLAGS], eax
+    and     dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IOPL
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], eax
     pop     eax
     and     dword [esp+12], ~X86_EFL_IOPL
 
     ; Set IF again; below we make sure this won't cause problems.
-    or      dword [ss:PATM_VMFLAGS], X86_EFL_IF
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF
 
     ; make sure iret is executed fully (including the iret below; cli ... iret can otherwise be interrupted)
-    mov     dword [ss:PATM_INHIBITIRQADDR], PATM_CURINSTRADDR
-
-    popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INHIBITIRQADDR], PATM_ASMFIX_CURINSTRADDR
+
+    popfd
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     iretd
     PATM_INT3
@@ -1247 +1247 @@
 iret_fault:
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -1253 +1253 @@
     nop
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -1260 +1260 @@
     pushfd
     push    eax
-    push    PATM_FIXUP
+    push    PATM_ASMFIX_FIXUP
     DB      0E8h                    ; call
-    DD      PATM_IRET_FUNCTION
+    DD      PATM_ASMFIX_IRET_FUNCTION
     add     esp, 4                  ; pushed address of jump table
 
@@ -1282 +1282 @@
     mov     eax, dword [esp+16]
     and     eax, X86_EFL_IOPL
-    and     dword [ss:PATM_VMFLAGS], ~X86_EFL_IOPL
-    or      dword [ss:PATM_VMFLAGS], eax
+    and     dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IOPL
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], eax
     pop     eax
     and     dword [esp+12], ~X86_EFL_IOPL
 
     ; Clear IF
-    and     dword [ss:PATM_VMFLAGS], ~X86_EFL_IF
-    popfd
-
-                                                ; the patched destination code will set PATM_INTERRUPTFLAG after the return!
+    and     dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IF
+    popfd
+
+                                                ; the patched destination code will set PATM_ASMFIX_INTERRUPTFLAG after the return!
     iretd
 
@@ -1299 +1299 @@
 
     ; Go to our hypervisor trap handler to perform the iret to v86 code
-    mov     dword [ss:PATM_TEMP_EAX], eax
-    mov     dword [ss:PATM_TEMP_ECX], ecx
-    mov     dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX
+    mov     dword [ss:PATM_ASMFIX_TEMP_EAX], eax
+    mov     dword [ss:PATM_ASMFIX_TEMP_ECX], ecx
+    mov     dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX
     mov     eax, PATM_ACTION_DO_V86_IRET
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
 
@@ -1335 +1335 @@
     PATCHASMRECORD_INIT PATMIretReplacement, 25
 %endif
-    DD      PATM_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
 %ifdef PATM_LOG_PATCHIRET
-    DD      PATM_PENDINGACTION,      0
-%endif
-    DD      PATM_VM_FORCEDACTIONS,   0
-    DD      PATM_TEMP_EAX,           0
-    DD      PATM_TEMP_ECX,           0
-    DD      PATM_TEMP_EDI,           0
-    DD      PATM_TEMP_RESTORE_FLAGS, 0
-    DD      PATM_PENDINGACTION,      0
-    DD      PATM_CURINSTRADDR,       0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_INHIBITIRQADDR,     0
-    DD      PATM_CURINSTRADDR,       0
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      PATM_FIXUP,              PATMIretTable - NAME(PATMIretReplacement)
-    DD      PATM_IRET_FUNCTION,      0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_TEMP_EAX,           0
-    DD      PATM_TEMP_ECX,           0
-    DD      PATM_TEMP_RESTORE_FLAGS, 0
-    DD      PATM_PENDINGACTION,      0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
+%endif
+    DD      PATM_ASMFIX_VM_FORCEDACTIONS,   0
+    DD      PATM_ASMFIX_TEMP_EAX,           0
+    DD      PATM_ASMFIX_TEMP_ECX,           0
+    DD      PATM_ASMFIX_TEMP_EDI,           0
+    DD      PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
+    DD      PATM_ASMFIX_CURINSTRADDR,       0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_INHIBITIRQADDR,     0
+    DD      PATM_ASMFIX_CURINSTRADDR,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_FIXUP,              PATMIretTable - NAME(PATMIretReplacement)
+    DD      PATM_ASMFIX_IRET_FUNCTION,      0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_TEMP_EAX,           0
+    DD      PATM_ASMFIX_TEMP_ECX,           0
+    DD      PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
     DD      0ffffffffh,              0ffffffffh
 
@@ -1401 +1401 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMIretRing1Replacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushfd
 
@@ -1410 +1410 @@
     lea     edx, dword [ss:esp+12+4]        ;3 dwords + pushed flags -> iret eip
     mov     eax, PATM_ACTION_LOG_IRET
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
     db      0fh, 0bh        ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap)
@@ -1440 +1440 @@
 ; Note: This is very important as pending pic interrupts can be overridden by apic interrupts if we don't check early enough (Fedora 5 boot)
 ; @@todo fix this properly, so we can dispatch pending interrupts in GC
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC
+    test    dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC
     jz      iretring1_continue
 
 ; Go to our hypervisor trap handler to dispatch the pending irq
-    mov     dword [ss:PATM_TEMP_EAX], eax
-    mov     dword [ss:PATM_TEMP_ECX], ecx
-    mov     dword [ss:PATM_TEMP_EDI], edi
-    mov     dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
+    mov     dword [ss:PATM_ASMFIX_TEMP_EAX], eax
+    mov     dword [ss:PATM_ASMFIX_TEMP_ECX], ecx
+    mov     dword [ss:PATM_ASMFIX_TEMP_EDI], edi
+    mov     dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI
     mov     eax, PATM_ACTION_PENDING_IRQ_AFTER_IRET
-    lock    or dword [ss:PATM_PENDINGACTION], eax
-    mov     ecx, PATM_ACTION_MAGIC
-    mov     edi, PATM_CURINSTRADDR
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
+    mov     ecx, PATM_ACTION_MAGIC
+    mov     edi, PATM_ASMFIX_CURINSTRADDR
 
     popfd
@@ -1485 +1485 @@
     mov     eax, dword [esp+16]
     and     eax, X86_EFL_IOPL
-    and     dword [ss:PATM_VMFLAGS], ~X86_EFL_IOPL
-    or      dword [ss:PATM_VMFLAGS], eax
+    and     dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IOPL
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], eax
     pop     eax
     and     dword [esp+12], ~X86_EFL_IOPL
 
     ; Set IF again; below we make sure this won't cause problems.
-    or      dword [ss:PATM_VMFLAGS], X86_EFL_IF
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF
 
     ; make sure iret is executed fully (including the iret below; cli ... iret can otherwise be interrupted)
-    mov     dword [ss:PATM_INHIBITIRQADDR], PATM_CURINSTRADDR
-
-    popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INHIBITIRQADDR], PATM_ASMFIX_CURINSTRADDR
+
+    popfd
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     iretd
     PATM_INT3
@@ -1503 +1503 @@
 iretring1_fault:
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -1509 +1509 @@
     nop
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -1516 +1516 @@
     pushfd
     push    eax
-    push    PATM_FIXUP
+    push    PATM_ASMFIX_FIXUP
     DB      0E8h                    ; call
-    DD      PATM_IRET_FUNCTION
+    DD      PATM_ASMFIX_IRET_FUNCTION
     add     esp, 4                  ; pushed address of jump table
 
@@ -1535 +1535 @@
     mov     eax, dword [esp+16]
     and     eax, X86_EFL_IOPL
-    and     dword [ss:PATM_VMFLAGS], ~X86_EFL_IOPL
-    or      dword [ss:PATM_VMFLAGS], eax
+    and     dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IOPL
+    or      dword [ss:PATM_ASMFIX_VMFLAGS], eax
     pop     eax
     and     dword [esp+12], ~X86_EFL_IOPL
 
     ; Clear IF
-    and     dword [ss:PATM_VMFLAGS], ~X86_EFL_IF
+    and     dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IF
     popfd
 
@@ -1553 +1553 @@
     and     dword [esp+20], ~1      ; SS
     or      dword [esp+20], 2
-                                                ; the patched destination code will set PATM_INTERRUPTFLAG after the return!
+                                                ; the patched destination code will set PATM_ASMFIX_INTERRUPTFLAG after the return!
     iretd
 
@@ -1559 +1559 @@
     ; force ring 1 CS RPL
     or      dword [esp+8], 1
-                                                ; the patched destination code will set PATM_INTERRUPTFLAG after the return!
+                                                ; the patched destination code will set PATM_ASMFIX_INTERRUPTFLAG after the return!
     iretd
 
@@ -1567 +1567 @@
 
     ; Go to our hypervisor trap handler to perform the iret to v86 code
-    mov     dword [ss:PATM_TEMP_EAX], eax
-    mov     dword [ss:PATM_TEMP_ECX], ecx
-    mov     dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX
+    mov     dword [ss:PATM_ASMFIX_TEMP_EAX], eax
+    mov     dword [ss:PATM_ASMFIX_TEMP_ECX], ecx
+    mov     dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX
     mov     eax, PATM_ACTION_DO_V86_IRET
-    lock    or dword [ss:PATM_PENDINGACTION], eax
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], eax
     mov     ecx, PATM_ACTION_MAGIC
 
@@ -1603 +1603 @@
     PATCHASMRECORD_INIT PATMIretRing1Replacement, 25
 %endif
-    DD      PATM_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
 %ifdef PATM_LOG_PATCHIRET            
-    DD      PATM_PENDINGACTION,      0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
 %endif                               
-    DD      PATM_VM_FORCEDACTIONS,   0
-    DD      PATM_TEMP_EAX,           0
-    DD      PATM_TEMP_ECX,           0
-    DD      PATM_TEMP_EDI,           0
-    DD      PATM_TEMP_RESTORE_FLAGS, 0
-    DD      PATM_PENDINGACTION,      0
-    DD      PATM_CURINSTRADDR,       0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_INHIBITIRQADDR,     0
-    DD      PATM_CURINSTRADDR,       0
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      PATM_INTERRUPTFLAG,      0
-    DD      PATM_FIXUP,              PATMIretRing1Table - NAME(PATMIretRing1Replacement)
-    DD      PATM_IRET_FUNCTION,      0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_VMFLAGS,            0
-    DD      PATM_TEMP_EAX,           0
-    DD      PATM_TEMP_ECX,           0
-    DD      PATM_TEMP_RESTORE_FLAGS, 0
-    DD      PATM_PENDINGACTION,      0
+    DD      PATM_ASMFIX_VM_FORCEDACTIONS,   0
+    DD      PATM_ASMFIX_TEMP_EAX,           0
+    DD      PATM_ASMFIX_TEMP_ECX,           0
+    DD      PATM_ASMFIX_TEMP_EDI,           0
+    DD      PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
+    DD      PATM_ASMFIX_CURINSTRADDR,       0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_INHIBITIRQADDR,     0
+    DD      PATM_ASMFIX_CURINSTRADDR,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,      0
+    DD      PATM_ASMFIX_FIXUP,              PATMIretRing1Table - NAME(PATMIretRing1Replacement)
+    DD      PATM_ASMFIX_IRET_FUNCTION,      0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_VMFLAGS,            0
+    DD      PATM_ASMFIX_TEMP_EAX,           0
+    DD      PATM_ASMFIX_TEMP_ECX,           0
+    DD      PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0
+    DD      PATM_ASMFIX_PENDINGACTION,      0
     DD      0ffffffffh,              0ffffffffh
 
@@ -1644 +1644 @@
 ;( +  0 return address )
 ;
-; @note assumes PATM_INTERRUPTFLAG is zero
+; @note assumes PATM_ASMFIX_INTERRUPTFLAG is zero
 ; @note assumes it can trash eax and eflags
 ;
@@ -1680 +1680 @@
     ; 2) Query return patch address from the hypervisor
     ; @todo private ugly interface, since we have nothing generic at the moment
-    lock    or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS
     mov     eax, PATM_ACTION_LOOKUP_ADDRESS
     mov     ecx, PATM_ACTION_MAGIC
@@ -1696 +1696 @@
     jz      PATMIretFunction_Failure
 
-    add     eax, PATM_PATCHBASE
+    add     eax, PATM_ASMFIX_PATCHBASE
 
     pop     edi
@@ -1715 +1715 @@
 GLOBALNAME g_patmIretFunctionRecord
     PATCHASMRECORD_INIT PATMIretFunction, 2
-    DD      PATM_PENDINGACTION, 0
-    DD      PATM_PATCHBASE,     0
+    DD      PATM_ASMFIX_PENDINGACTION, 0
+    DD      PATM_ASMFIX_PATCHBASE,     0
     DD      0ffffffffh, 0ffffffffh
 
@@ -1732 +1732 @@
     not     dword [esp-32]
 
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
-PATCH_FIXUP PATM_INTERRUPTFLAG
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
+PATCH_FIXUP PATM_ASMFIX_INTERRUPTFLAG
     pushf
 
@@ -1741 +1741 @@
 
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
-PATCH_FIXUP PATM_INTERRUPTFLAG
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
+PATCH_FIXUP PATM_ASMFIX_INTERRUPTFLAG
 END_PATCH g_patmCpuidRecord, PATMCpuidReplacement
 
@@ -1751 +1751 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMJEcxReplacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushfd
 PATMJEcxSizeOverride:
@@ -1759 +1759 @@
 
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMJEcxJump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 
 PATMJEcxContinue:
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC PATMJEcxReplacement
 
@@ -1773 +1773 @@
 GLOBALNAME g_patmJEcxRecord 
     PATCHASMRECORD_INIT_EX PATMJEcxReplacement, , PATMJEcxJump, PATMJEcxSizeOverride, 3
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -1784 +1784 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMLoopReplacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushfd
 PATMLoopSizeOverride:
@@ -1792 +1792 @@
 
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMLoopJump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 
 PATMLoopContinue:
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC PATMLoopReplacement
 
@@ -1806 +1806 @@
 GLOBALNAME g_patmLoopRecord
     PATCHASMRECORD_INIT_EX PATMLoopReplacement, , PATMLoopJump, PATMLoopSizeOverride, 3
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -1817 +1817 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMLoopZReplacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     jnz     NAME(PATMLoopZReplacement_EndProc)
     pushfd
@@ -1826 +1826 @@
 
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMLoopZJump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 
 PATMLoopZContinue:
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC PATMLoopZReplacement
 
@@ -1840 +1840 @@
 GLOBALNAME g_patmLoopZRecord
     PATCHASMRECORD_INIT_EX PATMLoopZReplacement, , PATMLoopZJump, PATMLoopZSizeOverride, 3
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -1851 +1851 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMLoopNZReplacement
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     jz      NAME(PATMLoopNZReplacement_EndProc)
     pushfd
@@ -1860 +1860 @@
 
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMLoopNZJump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 
 PATMLoopNZContinue:
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
 ENDPROC PATMLoopNZReplacement
 
@@ -1874 +1874 @@
 GLOBALNAME g_patmLoopNZRecord
     PATCHASMRECORD_INIT_EX PATMLoopNZReplacement, , PATMLoopNZJump, PATMLoopNZSizeOverride, 3
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -1882 +1882 @@
 ;
 ; Global patch function for indirect calls
-; Caller is responsible for clearing PATM_INTERRUPTFLAG and doing:
+; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and doing:
 ;  + 20 push    [pTargetGC]
 ;  + 16 pushfd
@@ -1900 +1900 @@
 
     mov     eax, dword [esp+16+4]                   ; guest return address
-    mov     dword [ss:PATM_CALL_RETURN_ADDR], eax                               ; temporary storage
+    mov     dword [ss:PATM_ASMFIX_CALL_RETURN_ADDR], eax                               ; temporary storage
 
     mov     edx, dword [esp+16+20]  ; pushed target address
@@ -1920 +1920 @@
     ; nothing found -> let our trap handler try to find it
     ; @todo private ugly interface, since we have nothing generic at the moment
-    lock    or  dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS
+    lock    or  dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS
     mov     eax, PATM_ACTION_LOOKUP_ADDRESS
     mov     ecx, PATM_ACTION_MAGIC
@@ -1947 +1947 @@
 
     mov     ecx, eax                            ; ECX = target address (relative!)
-    add     ecx, PATM_PATCHBASE                 ; Make it absolute
-
-    mov     edx, dword PATM_STACKPTR
+    add     ecx, PATM_ASMFIX_PATCHBASE                 ; Make it absolute
+
+    mov     edx, dword PATM_ASMFIX_STACKPTR
     cmp     dword [ss:edx], PATM_STACK_SIZE
     ja      near PATMLookupAndCall_Failure                    ; should never happen actually!!!
@@ -1957 +1957 @@
     ; save the patch return address on our private stack
     sub     dword [ss:edx], 4                   ; sizeof(RTGCPTR)
-    mov     eax, dword PATM_STACKBASE
+    mov     eax, dword PATM_ASMFIX_STACKBASE
     add     eax, dword [ss:edx]                 ; stack base + stack position
     mov     edi, dword [esp+16+8]               ; PATM return address
@@ -1963 +1963 @@
 
     ; save the original return address as well (checked by ret to make sure the guest hasn't messed around with the stack)
-    mov     edi, dword PATM_STACKBASE_GUEST
+    mov     edi, dword PATM_ASMFIX_STACKBASE_GUEST
     add     edi, dword [ss:edx]                 ; stack base (guest) + stack position
     mov     eax, dword [esp+16+4]               ; guest return address
     mov     dword [ss:edi], eax
 
-    mov     dword [ss:PATM_CALL_PATCH_TARGET_ADDR], ecx       ; temporarily store the target address
+    mov     dword [ss:PATM_ASMFIX_CALL_PATCH_TARGET_ADDR], ecx       ; temporarily store the target address
     pop     ecx
     pop     edi
@@ -1980 +1980 @@
     push    edx
     lea     edx, [esp + 12 - 4]                 ; stack address to store return address
-    lock    or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOG_CALL
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOG_CALL
     mov     eax, PATM_ACTION_LOG_CALL
     mov     ecx, PATM_ACTION_MAGIC
@@ -1989 +1989 @@
 %endif
 
-    push    dword [ss:PATM_CALL_RETURN_ADDR]   ; push original guest return address
-
-    ; the called function will set PATM_INTERRUPTFLAG (!!)
-    jmp     dword [ss:PATM_CALL_PATCH_TARGET_ADDR]
+    push    dword [ss:PATM_ASMFIX_CALL_RETURN_ADDR]   ; push original guest return address
+
+    ; the called function will set PATM_ASMFIX_INTERRUPTFLAG (!!)
+    jmp     dword [ss:PATM_ASMFIX_CALL_PATCH_TARGET_ADDR]
     ; returning here -> do not add code here or after the jmp!!!!!
 ENDPROC PATMLookupAndCall
@@ -2004 +2004 @@
     PATCHASMRECORD_INIT PATMLookupAndCall, 9
 %endif
-    DD      PATM_CALL_RETURN_ADDR,       0
-    DD      PATM_PENDINGACTION,          0
-    DD      PATM_PATCHBASE,              0
-    DD      PATM_STACKPTR,               0
-    DD      PATM_STACKBASE,              0
-    DD      PATM_STACKBASE_GUEST,        0
-    DD      PATM_CALL_PATCH_TARGET_ADDR, 0
+    DD      PATM_ASMFIX_CALL_RETURN_ADDR,       0
+    DD      PATM_ASMFIX_PENDINGACTION,          0
+    DD      PATM_ASMFIX_PATCHBASE,              0
+    DD      PATM_ASMFIX_STACKPTR,               0
+    DD      PATM_ASMFIX_STACKBASE,              0
+    DD      PATM_ASMFIX_STACKBASE_GUEST,        0
+    DD      PATM_ASMFIX_CALL_PATCH_TARGET_ADDR, 0
 %ifdef PATM_LOG_PATCHINSTR               
-    DD      PATM_PENDINGACTION,          0
+    DD      PATM_ASMFIX_PENDINGACTION,          0
 %endif                                   
-    DD      PATM_CALL_RETURN_ADDR,       0
-    DD      PATM_CALL_PATCH_TARGET_ADDR, 0
+    DD      PATM_ASMFIX_CALL_RETURN_ADDR,       0
+    DD      PATM_ASMFIX_CALL_PATCH_TARGET_ADDR, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -2021 +2021 @@
 ;
 ; Global patch function for indirect jumps
-; Caller is responsible for clearing PATM_INTERRUPTFLAG and doing:
+; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and doing:
 ;  +  8 push    [pTargetGC]
 ;  +  4 push    [JumpTableAddress]
 ;( +  0 return address )
-; And saving eflags in PATM_TEMP_EFLAGS
+; And saving eflags in PATM_ASMFIX_TEMP_EFLAGS
 ;
 ; @note NEVER change this without bumping the SSM version
@@ -2054 +2054 @@
     ; nothing found -> let our trap handler try to find it
     ; @todo private ugly interface, since we have nothing generic at the moment
-    lock    or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS
     mov     eax, PATM_ACTION_LOOKUP_ADDRESS
     mov     ecx, PATM_ACTION_MAGIC
@@ -2081 +2081 @@
 
     mov     ecx, eax                            ; ECX = target address (relative!)
-    add     ecx, PATM_PATCHBASE                 ; Make it absolute
+    add     ecx, PATM_ASMFIX_PATCHBASE                 ; Make it absolute
 
     ; save jump patch target
-    mov     dword [ss:PATM_TEMP_EAX], ecx
+    mov     dword [ss:PATM_ASMFIX_TEMP_EAX], ecx
     pop     ecx
     pop     edi
@@ -2091 +2091 @@
     add     esp, 12                             ; parameters + return address pushed by caller
     ; restore flags (just to be sure)
-    push    dword [ss:PATM_TEMP_EFLAGS]
-    popfd
-
-    ; the jump destination will set PATM_INTERRUPTFLAG (!!)
-    jmp     dword [ss:PATM_TEMP_EAX]                      ; call duplicated patch destination address
+    push    dword [ss:PATM_ASMFIX_TEMP_EFLAGS]
+    popfd
+
+    ; the jump destination will set PATM_ASMFIX_INTERRUPTFLAG (!!)
+    jmp     dword [ss:PATM_ASMFIX_TEMP_EAX]                      ; call duplicated patch destination address
 ENDPROC PATMLookupAndJump
 
@@ -2102 +2102 @@
 GLOBALNAME g_patmLookupAndJumpRecord
     PATCHASMRECORD_INIT PATMLookupAndJump, 5
-    DD      PATM_PENDINGACTION, 0
-    DD      PATM_PATCHBASE,     0
-    DD      PATM_TEMP_EAX,      0
-    DD      PATM_TEMP_EFLAGS,   0
-    DD      PATM_TEMP_EAX,      0
+    DD      PATM_ASMFIX_PENDINGACTION, 0
+    DD      PATM_ASMFIX_PATCHBASE,     0
+    DD      PATM_ASMFIX_TEMP_EAX,      0
+    DD      PATM_ASMFIX_TEMP_EFLAGS,   0
+    DD      PATM_ASMFIX_TEMP_EAX,      0
     DD      0ffffffffh, 0ffffffffh
 
@@ -2112 +2112 @@
 ; Patch function for static calls
 ; @note static calls have only one lookup slot!
-; Caller is responsible for clearing PATM_INTERRUPTFLAG and adding:
+; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and adding:
 ;   push    [pTargetGC]
 ;
@@ -2118 +2118 @@
 BEGINPROC PATMCall
     pushfd
-    push    PATM_FIXUP              ; fixup for jump table below
-    push    PATM_PATCHNEXTBLOCK
-    push    PATM_RETURNADDR
+    push    PATM_ASMFIX_FIXUP              ; fixup for jump table below
+    push    PATM_ASMFIX_PATCHNEXTBLOCK
+    push    PATM_ASMFIX_RETURNADDR
     DB      0E8h                    ; call
-    DD      PATM_LOOKUP_AND_CALL_FUNCTION
+    DD      PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION
     ; we only return in case of a failure
     add     esp, 12                 ; pushed address of jump table
     popfd
     add     esp, 4                  ; pushed by caller (changes the flags, but that shouldn't matter (@todo))
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 %ifdef DEBUG
@@ -2148 +2148 @@
 GLOBALNAME g_patmCallRecord
     PATCHASMRECORD_INIT PATMCall, 5
-    DD      PATM_FIXUP,                     PATMCallTable - NAME(PATMCall)
-    DD      PATM_PATCHNEXTBLOCK,            0
-    DD      PATM_RETURNADDR,                0
-    DD      PATM_LOOKUP_AND_CALL_FUNCTION,  0
-    DD      PATM_INTERRUPTFLAG,             0
+    DD      PATM_ASMFIX_FIXUP,                     PATMCallTable - NAME(PATMCall)
+    DD      PATM_ASMFIX_PATCHNEXTBLOCK,            0
+    DD      PATM_ASMFIX_RETURNADDR,                0
+    DD      PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION,  0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,             0
     DD      0ffffffffh, 0ffffffffh
 
 
 ; Patch function for indirect calls
-; Caller is responsible for clearing PATM_INTERRUPTFLAG and adding:
+; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and adding:
 ;   push    [pTargetGC]
 ;
@@ -2163 +2163 @@
 BEGINPROC PATMCallIndirect
     pushfd
-    push    PATM_FIXUP              ; fixup for jump table below
-    push    PATM_PATCHNEXTBLOCK
-    push    PATM_RETURNADDR
+    push    PATM_ASMFIX_FIXUP              ; fixup for jump table below
+    push    PATM_ASMFIX_PATCHNEXTBLOCK
+    push    PATM_ASMFIX_RETURNADDR
     DB      0E8h                    ; call
-    DD      PATM_LOOKUP_AND_CALL_FUNCTION
+    DD      PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION
     ; we only return in case of a failure
     add     esp, 12                 ; pushed address of jump table
     popfd
     add     esp, 4                  ; pushed by caller (changes the flags, but that shouldn't matter (@todo))
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 %ifdef DEBUG
@@ -2193 +2193 @@
 GLOBALNAME g_patmCallIndirectRecord
     PATCHASMRECORD_INIT PATMCallIndirect, 5
-    DD      PATM_FIXUP,                     PATMCallIndirectTable - NAME(PATMCallIndirect)
-    DD      PATM_PATCHNEXTBLOCK,            0
-    DD      PATM_RETURNADDR,                0
-    DD      PATM_LOOKUP_AND_CALL_FUNCTION,  0
-    DD      PATM_INTERRUPTFLAG,             0
+    DD      PATM_ASMFIX_FIXUP,                     PATMCallIndirectTable - NAME(PATMCallIndirect)
+    DD      PATM_ASMFIX_PATCHNEXTBLOCK,            0
+    DD      PATM_ASMFIX_RETURNADDR,                0
+    DD      PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION,  0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,             0
     DD      0ffffffffh, 0ffffffffh
 
@@ -2203 +2203 @@
 ;
 ; Patch function for indirect jumps
-; Caller is responsible for clearing PATM_INTERRUPTFLAG and adding:
+; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and adding:
 ;   push    [pTargetGC]
 ;
@@ -2210 +2210 @@
     ; save flags (just to be sure)
     pushfd
-    pop     dword [ss:PATM_TEMP_EFLAGS]
-
-    push    PATM_FIXUP              ; fixup for jump table below
+    pop     dword [ss:PATM_ASMFIX_TEMP_EFLAGS]
+
+    push    PATM_ASMFIX_FIXUP              ; fixup for jump table below
     DB      0E8h                    ; call
-    DD      PATM_LOOKUP_AND_JUMP_FUNCTION
+    DD      PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION
     ; we only return in case of a failure
     add     esp, 8                  ; pushed address of jump table + pushed target address
 
     ; restore flags (just to be sure)
-    push    dword [ss:PATM_TEMP_EFLAGS]
-    popfd
-
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    push    dword [ss:PATM_ASMFIX_TEMP_EFLAGS]
+    popfd
+
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -2244 +2244 @@
 GLOBALNAME g_patmJumpIndirectRecord
     PATCHASMRECORD_INIT PATMJumpIndirect, 5
-    DD      PATM_TEMP_EFLAGS,               0
-    DD      PATM_FIXUP,                     PATMJumpIndirectTable - NAME(PATMJumpIndirect)
-    DD      PATM_LOOKUP_AND_JUMP_FUNCTION,  0
-    DD      PATM_TEMP_EFLAGS,               0
-    DD      PATM_INTERRUPTFLAG,             0
+    DD      PATM_ASMFIX_TEMP_EFLAGS,               0
+    DD      PATM_ASMFIX_FIXUP,                     PATMJumpIndirectTable - NAME(PATMJumpIndirect)
+    DD      PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION,  0
+    DD      PATM_ASMFIX_TEMP_EFLAGS,               0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,             0
     DD      0ffffffffh, 0ffffffffh
 
@@ -2260 +2260 @@
     not     dword [esp-32]
     not     dword [esp-32]
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushfd
     push    eax
-    push    PATM_FIXUP
+    push    PATM_ASMFIX_FIXUP
     DB      0E8h                    ; call
-    DD      PATM_RETURN_FUNCTION
+    DD      PATM_ASMFIX_RETURN_FUNCTION
     add     esp, 4                  ; pushed address of jump table
 
@@ -2273 +2273 @@
     pop     eax
     popfd
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -2292 +2292 @@
     popf
                                                 ; caller will duplicate the ret or ret n instruction
-                                                ; the patched call will set PATM_INTERRUPTFLAG after the return!
+                                                ; the patched call will set PATM_ASMFIX_INTERRUPTFLAG after the return!
 ENDPROC     PATMRet
 
@@ -2298 +2298 @@
 GLOBALNAME g_patmRetRecord
     PATCHASMRECORD_INIT PATMRet, 4
-    DD      PATM_INTERRUPTFLAG,   0
-    DD      PATM_FIXUP,           PATMRetTable - NAME(PATMRet)
-    DD      PATM_RETURN_FUNCTION, 0
-    DD      PATM_INTERRUPTFLAG,   0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,   0
+    DD      PATM_ASMFIX_FIXUP,           PATMRetTable - NAME(PATMRet)
+    DD      PATM_ASMFIX_RETURN_FUNCTION, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG,   0
     DD      0ffffffffh, 0ffffffffh
 
@@ -2315 +2315 @@
 ;( +  0 return address )
 ;
-; @note assumes PATM_INTERRUPTFLAG is zero
+; @note assumes PATM_ASMFIX_INTERRUPTFLAG is zero
 ; @note assumes it can trash eax and eflags
 ;
@@ -2337 +2337 @@
 
     ; 1) Check if the return patch address was pushed on the PATM stack
-    cmp     dword [ss:PATM_STACKPTR], PATM_STACK_SIZE
+    cmp     dword [ss:PATM_ASMFIX_STACKPTR], PATM_STACK_SIZE
     jae     near PATMRetFunction_FindReturnAddress
 
-    mov     edx, dword PATM_STACKPTR
+    mov     edx, dword PATM_ASMFIX_STACKPTR
 
     ; check if the return address is what we expect it to be
-    mov     eax, dword PATM_STACKBASE_GUEST
+    mov     eax, dword PATM_ASMFIX_STACKBASE_GUEST
     add     eax, dword [ss:edx]                 ; stack base + stack position
     mov     eax, dword [ss:eax]                 ; original return address
@@ -2353 +2353 @@
 
     ; found it, convert relative to absolute patch address and return the result to the caller
-    mov     eax, dword PATM_STACKBASE
+    mov     eax, dword PATM_ASMFIX_STACKBASE
     add     eax, dword [ss:edx]                 ; stack base + stack position
     mov     eax, dword [ss:eax]                 ; relative patm return address
-    add     eax, PATM_PATCHBASE
+    add     eax, PATM_ASMFIX_PATCHBASE
 
 %ifdef PATM_LOG_PATCHINSTR
@@ -2365 +2365 @@
     mov     edx, eax                            ; return address
     lea     ebx, [esp+16+12+16]                 ; stack address containing the return address
-    lock    or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOG_RET
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOG_RET
     mov     eax, PATM_ACTION_LOG_RET
     mov     ecx, PATM_ACTION_MAGIC
@@ -2402 +2402 @@
     ; 3) Query return patch address from the hypervisor
     ; @todo private ugly interface, since we have nothing generic at the moment
-    lock    or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS
     mov     eax, PATM_ACTION_LOOKUP_ADDRESS
     mov     ecx, PATM_ACTION_MAGIC
@@ -2418 +2418 @@
     jz      PATMRetFunction_Failure
 
-    add     eax, PATM_PATCHBASE
+    add     eax, PATM_ASMFIX_PATCHBASE
 
 %ifdef PATM_LOG_PATCHINSTR
@@ -2427 +2427 @@
     mov     edx, eax                            ; return address
     lea     ebx, [esp+16+12+16]                 ; stack address containing the return address
-    lock    or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOG_RET
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOG_RET
     mov     eax, PATM_ACTION_LOG_RET
     mov     ecx, PATM_ACTION_MAGIC
@@ -2458 +2458 @@
     PATCHASMRECORD_INIT PATMRetFunction, 7
 %endif
-    DD      PATM_STACKPTR,        0
-    DD      PATM_STACKPTR,        0
-    DD      PATM_STACKBASE_GUEST, 0
-    DD      PATM_STACKBASE,       0
-    DD      PATM_PATCHBASE,       0
+    DD      PATM_ASMFIX_STACKPTR,        0
+    DD      PATM_ASMFIX_STACKPTR,        0
+    DD      PATM_ASMFIX_STACKBASE_GUEST, 0
+    DD      PATM_ASMFIX_STACKBASE,       0
+    DD      PATM_ASMFIX_PATCHBASE,       0
 %ifdef PATM_LOG_PATCHINSTR        
-    DD      PATM_PENDINGACTION,   0
+    DD      PATM_ASMFIX_PENDINGACTION,   0
 %endif                            
-    DD      PATM_PENDINGACTION,   0
-    DD      PATM_PATCHBASE,       0
+    DD      PATM_ASMFIX_PENDINGACTION,   0
+    DD      PATM_ASMFIX_PATCHBASE,       0
 %ifdef PATM_LOG_PATCHINSTR        
-    DD      PATM_PENDINGACTION,   0
+    DD      PATM_ASMFIX_PENDINGACTION,   0
 %endif
     DD      0ffffffffh, 0ffffffffh
@@ -2479 +2479 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMCheckIF
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushf
-    test    dword [ss:PATM_VMFLAGS], X86_EFL_IF
+    test    dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF
     jnz     PATMCheckIF_Safe
     nop
@@ -2487 +2487 @@
     ; IF=0 -> unsafe, so we must call the duplicated function (which we don't do here)
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     jmp     NAME(PATMCheckIF_EndProc)
 
 PATMCheckIF_Safe:
     ; invalidate the PATM stack as we'll jump back to guest code
-    mov     dword [ss:PATM_STACKPTR], PATM_STACK_SIZE
+    mov     dword [ss:PATM_ASMFIX_STACKPTR], PATM_STACK_SIZE
 
 %ifdef PATM_LOG_PATCHINSTR
     push    eax
     push    ecx
-    lock    or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOG_IF1
+    lock    or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOG_IF1
     mov     eax, PATM_ACTION_LOG_IF1
     mov     ecx, PATM_ACTION_MAGIC
@@ -2505 +2505 @@
 %endif
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     ; IF=1 -> we can safely jump back to the original instruction
     DB      0xE9
 PATMCheckIF_Jump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 ENDPROC     PATMCheckIF
 
@@ -2520 +2520 @@
     PATCHASMRECORD_INIT_JUMP PATMCheckIF, PATMCheckIF_Jump, 5
 %endif
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_VMFLAGS,       0
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_STACKPTR,      0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_VMFLAGS,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_STACKPTR,      0
 %ifdef PATM_LOG_PATCHINSTR      
-    DD      PATM_PENDINGACTION, 0
+    DD      PATM_ASMFIX_PENDINGACTION, 0
 %endif                          
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 
@@ -2536 +2536 @@
 BEGIN_PATCH_CODE_SECTION
 BEGINPROC   PATMJumpToGuest_IF1
-    mov     dword [ss:PATM_INTERRUPTFLAG], 0
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0
     pushf
-    test    dword [ss:PATM_VMFLAGS], X86_EFL_IF
+    test    dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF
     jnz     PATMJumpToGuest_IF1_Safe
     nop
@@ -2544 +2544 @@
     ; IF=0 -> unsafe, so fault
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     PATM_INT3
 
@@ -2550 +2550 @@
     ; IF=1 -> we can safely jump back to the original instruction
     popf
-    mov     dword [ss:PATM_INTERRUPTFLAG], 1
+    mov     dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1
     DB      0xE9
 PATMJumpToGuest_IF1_Jump:
-    DD      PATM_JUMPDELTA
+    DD      PATM_ASMFIX_JUMPDELTA
 ENDPROC     PATMJumpToGuest_IF1
 
@@ -2560 +2560 @@
 GLOBALNAME PATMJumpToGuest_IF1Record
     PATCHASMRECORD_INIT_JUMP PATMJumpToGuest_IF1, PATMJumpToGuest_IF1_Jump, 4
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_VMFLAGS,       0
-    DD      PATM_INTERRUPTFLAG, 0
-    DD      PATM_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_VMFLAGS,       0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
+    DD      PATM_ASMFIX_INTERRUPTFLAG, 0
     DD      0ffffffffh, 0ffffffffh
 

trunk/src/VBox/VMM/VMMR3/PATMA.mac

@@ -22 +22 @@
 ; @remarks These fixups types are part of the saved state.
 ; @{
-%define PATM_VMFLAGS                            0xF1ABCD00
+%define PATM_ASMFIX_VMFLAGS                     0xF1ABCD00
 %ifdef VBOX_WITH_STATISTICS
- %define PATM_ALLPATCHCALLS                     0xF1ABCD01
- %define PATM_PERPATCHCALLS                     0xF1ABCD02
+ %define PATM_ASMFIX_ALLPATCHCALLS              0xF1ABCD01
+ %define PATM_ASMFIX_PERPATCHCALLS              0xF1ABCD02
 %endif
-%define PATM_JUMPDELTA                          0xF1ABCD03
+%define PATM_ASMFIX_JUMPDELTA                   0xF1ABCD03
 %ifdef VBOX_WITH_STATISTICS
- %define PATM_IRETEFLAGS                        0xF1ABCD04
- %define PATM_IRETCS                            0xF1ABCD05
- %define PATM_IRETEIP                           0xF1ABCD06
+ %define PATM_ASMFIX_IRETEFLAGS                 0xF1ABCD04
+ %define PATM_ASMFIX_IRETCS                     0xF1ABCD05
+ %define PATM_ASMFIX_IRETEIP                    0xF1ABCD06
 %endif
-%define PATM_FIXUP                              0xF1ABCD07
-%define PATM_PENDINGACTION                      0xF1ABCD08
-%define PATM_CPUID_STD_PTR                      0xF1ABCD09
-%define PATM_CPUID_EXT_PTR                      0xF1ABCD0a
-%define PATM_CPUID_DEF_PTR                      0xF1ABCD0b
-%define PATM_STACKBASE                          0xF1ABCD0c  ;;< Stack to store our private patch return addresses
-%define PATM_STACKBASE_GUEST                    0xF1ABCD0d  ;;< Stack to store guest return addresses 
-%define PATM_STACKPTR                           0xF1ABCD0e
-%define PATM_PATCHBASE                          0xF1ABCD0f
-%define PATM_INTERRUPTFLAG                      0xF1ABCD10
-%define PATM_INHIBITIRQADDR                     0xF1ABCD11
-%define PATM_VM_FORCEDACTIONS                   0xF1ABCD12
-%define PATM_TEMP_EAX                           0xF1ABCD13  ;;< Location for original EAX register
-%define PATM_TEMP_ECX                           0xF1ABCD14  ;;< Location for original ECX register
-%define PATM_TEMP_EDI                           0xF1ABCD15  ;;< Location for original EDI register
-%define PATM_TEMP_EFLAGS                        0xF1ABCD16  ;;< Location for original eflags
-%define PATM_TEMP_RESTORE_FLAGS                 0xF1ABCD17  ;;< Which registers to restore
-%define PATM_CALL_PATCH_TARGET_ADDR             0xF1ABCD18
-%define PATM_CALL_RETURN_ADDR                   0xF1ABCD19
-%define PATM_CPUID_CENTAUR_PTR                  0xF1ABCD1a
+%define PATM_ASMFIX_FIXUP                       0xF1ABCD07
+%define PATM_ASMFIX_PENDINGACTION               0xF1ABCD08
+%define PATM_ASMFIX_CPUID_STD_PTR               0xF1ABCD09
+%define PATM_ASMFIX_CPUID_EXT_PTR               0xF1ABCD0a
+%define PATM_ASMFIX_CPUID_DEF_PTR               0xF1ABCD0b
+%define PATM_ASMFIX_STACKBASE                   0xF1ABCD0c  ;;< Stack to store our private patch return addresses
+%define PATM_ASMFIX_STACKBASE_GUEST             0xF1ABCD0d  ;;< Stack to store guest return addresses
+%define PATM_ASMFIX_STACKPTR                    0xF1ABCD0e
+%define PATM_ASMFIX_PATCHBASE                   0xF1ABCD0f
+%define PATM_ASMFIX_INTERRUPTFLAG               0xF1ABCD10
+%define PATM_ASMFIX_INHIBITIRQADDR              0xF1ABCD11
+%define PATM_ASMFIX_VM_FORCEDACTIONS            0xF1ABCD12
+%define PATM_ASMFIX_TEMP_EAX                    0xF1ABCD13  ;;< Location for original EAX register
+%define PATM_ASMFIX_TEMP_ECX                    0xF1ABCD14  ;;< Location for original ECX register
+%define PATM_ASMFIX_TEMP_EDI                    0xF1ABCD15  ;;< Location for original EDI register
+%define PATM_ASMFIX_TEMP_EFLAGS                 0xF1ABCD16  ;;< Location for original eflags
+%define PATM_ASMFIX_TEMP_RESTORE_FLAGS          0xF1ABCD17  ;;< Which registers to restore
+%define PATM_ASMFIX_CALL_PATCH_TARGET_ADDR      0xF1ABCD18
+%define PATM_ASMFIX_CALL_RETURN_ADDR            0xF1ABCD19
+%define PATM_ASMFIX_CPUID_CENTAUR_PTR           0xF1ABCD1a
 %define PATM_ASMFIX_REUSE_LATER_0               0xF1ABCD1b
 %define PATM_ASMFIX_REUSE_LATER_1               0xF1ABCD1c
@@ -60 +60 @@
 
 ;/* Anything larger doesn't require a fixup */
-%define PATM_NO_FIXUP                           0xF1ABCE00
-%define PATM_CPUID_STD_MAX                      0xF1ABCE00
-%define PATM_CPUID_EXT_MAX                      0xF1ABCE01
-%define PATM_RETURNADDR                         0xF1ABCE02
-%define PATM_PATCHNEXTBLOCK                     0xF1ABCE03
-%define PATM_CALLTARGET                         0xF1ABCE04  ;;< relative call target 
-%define PATM_NEXTINSTRADDR                      0xF1ABCE05  ;;< absolute guest address of the next instruction 
-%define PATM_CURINSTRADDR                       0xF1ABCE06  ;;< absolute guest address of the current instruction 
-%define PATM_LOOKUP_AND_CALL_FUNCTION           0xF1ABCE07  ;;< Relative address of global PATM lookup and call function. 
-%define PATM_RETURN_FUNCTION                    0xF1ABCE08  ;;< Relative address of global PATM return function. 
-%define PATM_LOOKUP_AND_JUMP_FUNCTION           0xF1ABCE09  ;;< Relative address of global PATM lookup and jump function. 
-%define PATM_IRET_FUNCTION                      0xF1ABCE0A  ;;< Relative address of global PATM iret function. 
-%define PATM_CPUID_CENTAUR_MAX                  0xF1ABCE0B
+%define PATM_ASMFIX_NO_FIXUP                    0xF1ABCE00
+%define PATM_ASMFIX_CPUID_STD_MAX               0xF1ABCE00
+%define PATM_ASMFIX_CPUID_EXT_MAX               0xF1ABCE01
+%define PATM_ASMFIX_RETURNADDR                  0xF1ABCE02
+%define PATM_ASMFIX_PATCHNEXTBLOCK              0xF1ABCE03
+%define PATM_ASMFIX_CALLTARGET                  0xF1ABCE04  ;;< relative call target
+%define PATM_ASMFIX_NEXTINSTRADDR               0xF1ABCE05  ;;< absolute guest address of the next instruction
+%define PATM_ASMFIX_CURINSTRADDR                0xF1ABCE06  ;;< absolute guest address of the current instruction
+%define PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION    0xF1ABCE07  ;;< Relative address of global PATM lookup and call function.
+%define PATM_ASMFIX_RETURN_FUNCTION             0xF1ABCE08  ;;< Relative address of global PATM return function.
+%define PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION    0xF1ABCE09  ;;< Relative address of global PATM lookup and jump function.
+%define PATM_ASMFIX_IRET_FUNCTION               0xF1ABCE0A  ;;< Relative address of global PATM iret function.
+%define PATM_ASMFIX_CPUID_CENTAUR_MAX           0xF1ABCE0B
 ;; @}
 
@@ -108 +108 @@
 %define PATM_ACTION_MAGIC                       0xABCD4321
 
-;; @name PATM_TEMP_RESTORE_FLAGS
+;; @name PATM_ASMFIX_TEMP_RESTORE_FLAGS
 ;; @{
 %define PATM_RESTORE_EAX                        RT_BIT(0)

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

@@ -109 +109 @@
                    || uType == FIXUP_REL_HELPER_IN_PATCH_ASM_TMPL)
                && pSource == pDest
-               && PATM_IS_FIXUP_TYPE(pSource))
+               && PATM_IS_ASMFIX(pSource))
            || ((uType == FIXUP_REL_JMPTOPATCH || uType == FIXUP_REL_JMPTOGUEST) && pSource && pDest));
 
@@ -172 +172 @@
 
 #ifdef VBOX_STRICT
-                if (pAsmRecord->aRelocs[i].uType == PATM_FIXUP)
+                if (pAsmRecord->aRelocs[i].uType == PATM_ASMFIX_FIXUP)
                     Assert(pAsmRecord->aRelocs[i].uInfo != 0);
                 else
@@ -188 +188 @@
                      * PATMGCSTATE member fixups.
                      */
-                    case PATM_VMFLAGS:
+                    case PATM_ASMFIX_VMFLAGS:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uVMFlags);
                         break;
-                    case PATM_PENDINGACTION:
+                    case PATM_ASMFIX_PENDINGACTION:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uPendingAction);
                         break;
-                    case PATM_STACKPTR:
+                    case PATM_ASMFIX_STACKPTR:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Psp);
                         break;
-                    case PATM_INTERRUPTFLAG:
+                    case PATM_ASMFIX_INTERRUPTFLAG:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, fPIF);
                         break;
-                    case PATM_INHIBITIRQADDR:
+                    case PATM_ASMFIX_INHIBITIRQADDR:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, GCPtrInhibitInterrupts);
                         break;
-                    case PATM_TEMP_EAX:
+                    case PATM_ASMFIX_TEMP_EAX:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.uEAX);
                         break;
-                    case PATM_TEMP_ECX:
+                    case PATM_ASMFIX_TEMP_ECX:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.uECX);
                         break;
-                    case PATM_TEMP_EDI:
+                    case PATM_ASMFIX_TEMP_EDI:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.uEDI);
                         break;
-                    case PATM_TEMP_EFLAGS:
+                    case PATM_ASMFIX_TEMP_EFLAGS:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.eFlags);
                         break;
-                    case PATM_TEMP_RESTORE_FLAGS:
+                    case PATM_ASMFIX_TEMP_RESTORE_FLAGS:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.uFlags);
                         break;
-                    case PATM_CALL_PATCH_TARGET_ADDR:
+                    case PATM_ASMFIX_CALL_PATCH_TARGET_ADDR:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, GCCallPatchTargetAddr);
                         break;
-                    case PATM_CALL_RETURN_ADDR:
+                    case PATM_ASMFIX_CALL_RETURN_ADDR:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, GCCallReturnAddr);
                         break;
 #ifdef VBOX_WITH_STATISTICS
-                    case PATM_ALLPATCHCALLS:
+                    case PATM_ASMFIX_ALLPATCHCALLS:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uPatchCalls);
                         break;
-                    case PATM_IRETEFLAGS:
+                    case PATM_ASMFIX_IRETEFLAGS:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uIretEFlags);
                         break;
-                    case PATM_IRETCS:
+                    case PATM_ASMFIX_IRETCS:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uIretCS);
                         break;
-                    case PATM_IRETEIP:
+                    case PATM_ASMFIX_IRETEIP:
                         dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uIretEIP);
                         break;
@@ -240 +240 @@
 
 
-                    case PATM_FIXUP:
+                    case PATM_ASMFIX_FIXUP:
                         /* Offset in aRelocs[i].uInfo is from the base of the function. */
                         dest = (RTGCUINTPTR32)pVM->patm.s.pPatchMemGC + pAsmRecord->aRelocs[i].uInfo
@@ -247 +247 @@
 
 #ifdef VBOX_WITH_STATISTICS
-                    case PATM_PERPATCHCALLS:
+                    case PATM_ASMFIX_PERPATCHCALLS:
                         dest = patmPatchQueryStatAddress(pVM, pPatch);
                         break;
@@ -255 +255 @@
                      * part to store the original return addresses.
                      */
-                    case PATM_STACKBASE:
+                    case PATM_ASMFIX_STACKBASE:
                         dest = pVM->patm.s.pGCStackGC;
                         break;
 
-                    case PATM_STACKBASE_GUEST:
+                    case PATM_ASMFIX_STACKBASE_GUEST:
                         dest = pVM->patm.s.pGCStackGC + PATM_STACK_SIZE;
                         break;
 
-                    case PATM_RETURNADDR:   /* absolute guest address; no fixup required */
-                        Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_NO_FIXUP);
+                    case PATM_ASMFIX_RETURNADDR:   /* absolute guest address; no fixup required */
+                        Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_ASMFIX_NO_FIXUP);
                         dest = pCallInfo->pReturnGC;
                         break;
 
-                    case PATM_PATCHNEXTBLOCK:  /* relative address of instruction following this block */
-                        Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_NO_FIXUP);
+                    case PATM_ASMFIX_PATCHNEXTBLOCK:  /* relative address of instruction following this block */
+                        Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_ASMFIX_NO_FIXUP);
 
                         /** @note hardcoded assumption that we must return to the instruction following this block */
@@ -275 +275 @@
                         break;
 
-                    case PATM_CALLTARGET:   /* relative to patch address; no fixup required */
-                        Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_NO_FIXUP);
+                    case PATM_ASMFIX_CALLTARGET:   /* relative to patch address; no fixup required */
+                        Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_ASMFIX_NO_FIXUP);
 
                         /* Address must be filled in later. (see patmr3SetBranchTargets)  */
@@ -283 +283 @@
                         break;
 
-                    case PATM_PATCHBASE:    /* Patch GC base address */
+                    case PATM_ASMFIX_PATCHBASE:    /* Patch GC base address */
                         dest = pVM->patm.s.pPatchMemGC;
                         break;
 
-                    case PATM_NEXTINSTRADDR:
+                    case PATM_ASMFIX_NEXTINSTRADDR:
                         Assert(pCallInfo);
                         /* pNextInstrGC can be 0 if several instructions, that inhibit irqs, follow each other */
@@ -293 +293 @@
                         break;
 
-                    case PATM_CURINSTRADDR:
+                    case PATM_ASMFIX_CURINSTRADDR:
                         Assert(pCallInfo);
                         dest = pCallInfo->pCurInstrGC;
@@ -299 +299 @@
 
                     /* Relative address of global patm lookup and call function. */
-                    case PATM_LOOKUP_AND_CALL_FUNCTION:
+                    case PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION:
                     {
                         RTRCPTR pInstrAfterCall = pVM->patm.s.pPatchMemGC
@@ -311 +311 @@
                     }
 
-                    case PATM_RETURN_FUNCTION:
+                    case PATM_ASMFIX_RETURN_FUNCTION:
                     {
                         RTRCPTR pInstrAfterCall = pVM->patm.s.pPatchMemGC
@@ -323 +323 @@
                     }
 
-                    case PATM_IRET_FUNCTION:
+                    case PATM_ASMFIX_IRET_FUNCTION:
                     {
                         RTRCPTR pInstrAfterCall = pVM->patm.s.pPatchMemGC
@@ -335 +335 @@
                     }
 
-                    case PATM_LOOKUP_AND_JUMP_FUNCTION:
+                    case PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION:
                     {
                         RTRCPTR pInstrAfterCall = pVM->patm.s.pPatchMemGC
@@ -347 +347 @@
                     }
 
-                    case PATM_CPUID_STD_MAX: /* saved state only */
+                    case PATM_ASMFIX_CPUID_STD_MAX: /* saved state only */
                         dest = CPUMR3GetGuestCpuIdPatmStdMax(pVM);
                         break;
-                    case PATM_CPUID_EXT_MAX: /* saved state only */
+                    case PATM_ASMFIX_CPUID_EXT_MAX: /* saved state only */
                         dest = CPUMR3GetGuestCpuIdPatmExtMax(pVM);
                         break;
-                    case PATM_CPUID_CENTAUR_MAX: /* saved state only */
+                    case PATM_ASMFIX_CPUID_CENTAUR_MAX: /* saved state only */
                         dest = CPUMR3GetGuestCpuIdPatmCentaurMax(pVM);
                         break;
@@ -361 +361 @@
                      * Note! Earlier saved state versions had different hacks for detecting some of these.
                      */
-                    case PATM_VM_FORCEDACTIONS:
+                    case PATM_ASMFIX_VM_FORCEDACTIONS:
                         dest = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
                         break;
 
-                    case PATM_CPUID_DEF_PTR: /* saved state only */
+                    case PATM_ASMFIX_CPUID_DEF_PTR: /* saved state only */
                         dest = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM);
                         break;
-                    case PATM_CPUID_STD_PTR: /* saved state only */
+                    case PATM_ASMFIX_CPUID_STD_PTR: /* saved state only */
                         dest = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM);
                         break;
-                    case PATM_CPUID_EXT_PTR: /* saved state only */
+                    case PATM_ASMFIX_CPUID_EXT_PTR: /* saved state only */
                         dest = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM);
                         break;
-                    case PATM_CPUID_CENTAUR_PTR: /* saved state only */
+                    case PATM_ASMFIX_CPUID_CENTAUR_PTR: /* saved state only */
                         dest = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM);
                         break;
@@ -412 +412 @@
                 *(PRTRCPTR)&pPB[j] = dest;
 
-                if (pAsmRecord->aRelocs[i].uType < PATM_NO_FIXUP)
+                if (pAsmRecord->aRelocs[i].uType < PATM_ASMFIX_NO_FIXUP)
                 {
                     patmPatchAddReloc32(pVM, pPatch, &pPB[j], uRelocType,
@@ -797 +797 @@
     PATCHGEN_EPILOG(pPatch, size);
 
-    /* Need to set PATM_INTERRUPTFLAG after the patched ret returns here. */
+    /* Need to set PATM_ASMFIX_INTERRUPTFLAG after the patched ret returns here. */
     rc = patmPatchGenSetPIF(pVM, pPatch, pCurInstrGC);
     if (rc == VERR_NO_MEMORY)

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

@@ -1111 +1111 @@
     {
         Assert(   pRec->uType != PATM_SAVED_STATE_VERSION_NO_RAW_MEM
-               || (pRec->pSource == pRec->pDest && PATM_IS_FIXUP_TYPE(pRec->pSource)) );
+               || (pRec->pSource == pRec->pDest && PATM_IS_ASMFIX(pRec->pSource)) );
 
         /* bird: What is this for exactly?  Only the MMIO fixups used to have pSource set. */
@@ -1266 +1266 @@
             LogFlow(("Changing fLocalForcedActions fixup from %RRv to %RRv\n", uFixup, pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions)));
             *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
-            pRec->pSource = pRec->pDest = PATM_VM_FORCEDACTIONS;
+            pRec->pSource = pRec->pDest = PATM_ASMFIX_VM_FORCEDACTIONS;
             pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
         }
@@ -1279 +1279 @@
             case 0:
                 *pFixup = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM);
-                pRec->pSource = pRec->pDest = PATM_CPUID_DEF_PTR;
+                pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_DEF_PTR;
                 pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
                 break;
             case 1:
                 *pFixup = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM);
-                pRec->pSource = pRec->pDest = PATM_CPUID_STD_PTR;
+                pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_STD_PTR;
                 pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
                 break;
             case 2:
                 *pFixup = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM);
-                pRec->pSource = pRec->pDest = PATM_CPUID_EXT_PTR;
+                pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_EXT_PTR;
                 pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
                 break;
             case 3:
                 *pFixup = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM);
-                pRec->pSource = pRec->pDest = PATM_CPUID_CENTAUR_PTR;
+                pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_CENTAUR_PTR;
                 pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
                 break;
@@ -1313 +1313 @@
             case PATM_FIXUP_CPU_FF_ACTION:
                 *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
-                pRec->pSource = pRec->pDest = PATM_VM_FORCEDACTIONS;
+                pRec->pSource = pRec->pDest = PATM_ASMFIX_VM_FORCEDACTIONS;
                 pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
                 LogFlow(("Changing cpu ff action fixup from %x to %x\n", uFixup, *pFixup));
@@ -1319 +1319 @@
             case PATM_FIXUP_CPUID_DEFAULT:
                 *pFixup = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM);
-                pRec->pSource = pRec->pDest = PATM_CPUID_DEF_PTR;
+                pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_DEF_PTR;
                 pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
                 LogFlow(("Changing cpuid def fixup from %x to %x\n", uFixup, *pFixup));
@@ -1325 +1325 @@
             case PATM_FIXUP_CPUID_STANDARD:
                 *pFixup = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM);
-                pRec->pSource = pRec->pDest = PATM_CPUID_STD_PTR;
+                pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_STD_PTR;
                 pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
                 LogFlow(("Changing cpuid std fixup from %x to %x\n", uFixup, *pFixup));
@@ -1331 +1331 @@
             case PATM_FIXUP_CPUID_EXTENDED:
                 *pFixup = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM);
-                pRec->pSource = pRec->pDest = PATM_CPUID_EXT_PTR;
+                pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_EXT_PTR;
                 pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
                 LogFlow(("Changing cpuid ext fixup from %x to %x\n", uFixup, *pFixup));
@@ -1337 +1337 @@
             case PATM_FIXUP_CPUID_CENTAUR:
                 *pFixup = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM);
-                pRec->pSource = pRec->pDest = PATM_CPUID_CENTAUR_PTR;
+                pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_CENTAUR_PTR;
                 pRec->uType   = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
                 LogFlow(("Changing cpuid centaur fixup from %x to %x\n", uFixup, *pFixup));
@@ -1353 +1353 @@
                  && pRec->uType == FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL)
         {
-            Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_FIXUP_TYPE(pRec->pSource));
+            Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_ASMFIX(pRec->pSource));
             switch (pRec->pSource)
             {
-                case PATM_VM_FORCEDACTIONS:
+                case PATM_ASMFIX_VM_FORCEDACTIONS:
                     *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
                     break;
-                case PATM_CPUID_DEF_PTR:
+                case PATM_ASMFIX_CPUID_DEF_PTR:
                     *pFixup = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM);
                     break;
-                case PATM_CPUID_STD_PTR: /* Saved again patches only. */
+                case PATM_ASMFIX_CPUID_STD_PTR: /* Saved again patches only. */
                     *pFixup = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM);
                     break;
-                case PATM_CPUID_EXT_PTR: /* Saved again patches only. */
+                case PATM_ASMFIX_CPUID_EXT_PTR: /* Saved again patches only. */
                     *pFixup = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM);
                     break;
-                case PATM_CPUID_CENTAUR_PTR: /* Saved again patches only. */
+                case PATM_ASMFIX_CPUID_CENTAUR_PTR: /* Saved again patches only. */
                     *pFixup = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM);
                     break;
@@ -1384 +1384 @@
         {
             AssertLogRelReturn(uVersion > PATM_SAVED_STATE_VERSION_NO_RAW_MEM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
-            Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_FIXUP_TYPE(pRec->pSource));
+            Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_ASMFIX(pRec->pSource));
             switch (pRec->pSource)
             {
@@ -1406 +1406 @@
         {
             AssertLogRelReturn(uVersion > PATM_SAVED_STATE_VERSION_NO_RAW_MEM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
-            Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_FIXUP_TYPE(pRec->pSource));
+            Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_ASMFIX(pRec->pSource));
             int     rc;
             RTRCPTR uRCPtrDest;

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

@@ -22 +22 @@
  * @remarks These fixups types are part of the saved state.
  * @{ */
-#define PATM_VMFLAGS                            0xF1ABCD00
+#define PATM_ASMFIX_VMFLAGS                     0xF1ABCD00
 #ifdef VBOX_WITH_STATISTICS
-# define PATM_ALLPATCHCALLS                     0xF1ABCD01
-# define PATM_PERPATCHCALLS                     0xF1ABCD02
+# define PATM_ASMFIX_ALLPATCHCALLS              0xF1ABCD01
+# define PATM_ASMFIX_PERPATCHCALLS              0xF1ABCD02
 #endif
-#define PATM_JUMPDELTA                          0xF1ABCD03
+#define PATM_ASMFIX_JUMPDELTA                   0xF1ABCD03
 #ifdef VBOX_WITH_STATISTICS
-# define PATM_IRETEFLAGS                        0xF1ABCD04
-# define PATM_IRETCS                            0xF1ABCD05
-# define PATM_IRETEIP                           0xF1ABCD06
+# define PATM_ASMFIX_IRETEFLAGS                 0xF1ABCD04
+# define PATM_ASMFIX_IRETCS                     0xF1ABCD05
+# define PATM_ASMFIX_IRETEIP                    0xF1ABCD06
 #endif
-#define PATM_FIXUP                              0xF1ABCD07
-#define PATM_PENDINGACTION                      0xF1ABCD08
-#define PATM_CPUID_STD_PTR                      0xF1ABCD09  /**< Legacy, saved state only. */
-#define PATM_CPUID_EXT_PTR                      0xF1ABCD0a  /**< Legacy, saved state only. */
-#define PATM_CPUID_DEF_PTR                      0xF1ABCD0b  /**< Legacy, saved state only. */
-#define PATM_STACKBASE                          0xF1ABCD0c  /**< Stack to store our private patch return addresses */
-#define PATM_STACKBASE_GUEST                    0xF1ABCD0d  /**< Stack to store guest return addresses */
-#define PATM_STACKPTR                           0xF1ABCD0e
-#define PATM_PATCHBASE                          0xF1ABCD0f
-#define PATM_INTERRUPTFLAG                      0xF1ABCD10
-#define PATM_INHIBITIRQADDR                     0xF1ABCD11
-#define PATM_VM_FORCEDACTIONS                   0xF1ABCD12
-#define PATM_TEMP_EAX                           0xF1ABCD13  /**< Location for original EAX register */
-#define PATM_TEMP_ECX                           0xF1ABCD14  /**< Location for original ECX register */
-#define PATM_TEMP_EDI                           0xF1ABCD15  /**< Location for original EDI register */
-#define PATM_TEMP_EFLAGS                        0xF1ABCD16  /**< Location for original eflags */
-#define PATM_TEMP_RESTORE_FLAGS                 0xF1ABCD17  /**< Which registers to restore */
-#define PATM_CALL_PATCH_TARGET_ADDR             0xF1ABCD18
-#define PATM_CALL_RETURN_ADDR                   0xF1ABCD19
-#define PATM_CPUID_CENTAUR_PTR                  0xF1ABCD1a  /**< Legacy, saved state only. */
+#define PATM_ASMFIX_FIXUP                       0xF1ABCD07
+#define PATM_ASMFIX_PENDINGACTION               0xF1ABCD08
+#define PATM_ASMFIX_CPUID_STD_PTR               0xF1ABCD09  /**< Legacy, saved state only. */
+#define PATM_ASMFIX_CPUID_EXT_PTR               0xF1ABCD0a  /**< Legacy, saved state only. */
+#define PATM_ASMFIX_CPUID_DEF_PTR               0xF1ABCD0b  /**< Legacy, saved state only. */
+#define PATM_ASMFIX_STACKBASE                   0xF1ABCD0c  /**< Stack to store our private patch return addresses */
+#define PATM_ASMFIX_STACKBASE_GUEST             0xF1ABCD0d  /**< Stack to store guest return addresses */
+#define PATM_ASMFIX_STACKPTR                    0xF1ABCD0e
+#define PATM_ASMFIX_PATCHBASE                   0xF1ABCD0f
+#define PATM_ASMFIX_INTERRUPTFLAG               0xF1ABCD10
+#define PATM_ASMFIX_INHIBITIRQADDR              0xF1ABCD11
+#define PATM_ASMFIX_VM_FORCEDACTIONS            0xF1ABCD12
+#define PATM_ASMFIX_TEMP_EAX                    0xF1ABCD13  /**< Location for original EAX register */
+#define PATM_ASMFIX_TEMP_ECX                    0xF1ABCD14  /**< Location for original ECX register */
+#define PATM_ASMFIX_TEMP_EDI                    0xF1ABCD15  /**< Location for original EDI register */
+#define PATM_ASMFIX_TEMP_EFLAGS                 0xF1ABCD16  /**< Location for original eflags */
+#define PATM_ASMFIX_TEMP_RESTORE_FLAGS          0xF1ABCD17  /**< Which registers to restore */
+#define PATM_ASMFIX_CALL_PATCH_TARGET_ADDR      0xF1ABCD18
+#define PATM_ASMFIX_CALL_RETURN_ADDR            0xF1ABCD19
+#define PATM_ASMFIX_CPUID_CENTAUR_PTR           0xF1ABCD1a  /**< Legacy, saved state only. */
 #define PATM_ASMFIX_REUSE_LATER_0               0xF1ABCD1b
 #define PATM_ASMFIX_REUSE_LATER_1               0xF1ABCD1c
@@ -60 +60 @@
 
 /* Anything larger doesn't require a fixup */
-#define PATM_NO_FIXUP                           0xF1ABCE00
-#define PATM_CPUID_STD_MAX                      0xF1ABCE00
-#define PATM_CPUID_EXT_MAX                      0xF1ABCE01
-#define PATM_RETURNADDR                         0xF1ABCE02
-#define PATM_PATCHNEXTBLOCK                     0xF1ABCE03
-#define PATM_CALLTARGET                         0xF1ABCE04  /**< relative call target */
-#define PATM_NEXTINSTRADDR                      0xF1ABCE05  /**< absolute guest address of the next instruction */
-#define PATM_CURINSTRADDR                       0xF1ABCE06  /**< absolute guest address of the current instruction */
-#define PATM_LOOKUP_AND_CALL_FUNCTION           0xF1ABCE07  /**< Relative address of global PATM lookup and call function. */
-#define PATM_RETURN_FUNCTION                    0xF1ABCE08  /**< Relative address of global PATM return function. */
-#define PATM_LOOKUP_AND_JUMP_FUNCTION           0xF1ABCE09  /**< Relative address of global PATM lookup and jump function. */
-#define PATM_IRET_FUNCTION                      0xF1ABCE0A  /**< Relative address of global PATM iret function. */
-#define PATM_CPUID_CENTAUR_MAX                  0xF1ABCE0B
+#define PATM_ASMFIX_NO_FIXUP                    0xF1ABCE00
+#define PATM_ASMFIX_CPUID_STD_MAX               0xF1ABCE00
+#define PATM_ASMFIX_CPUID_EXT_MAX               0xF1ABCE01
+#define PATM_ASMFIX_RETURNADDR                  0xF1ABCE02
+#define PATM_ASMFIX_PATCHNEXTBLOCK              0xF1ABCE03
+#define PATM_ASMFIX_CALLTARGET                  0xF1ABCE04  /**< relative call target */
+#define PATM_ASMFIX_NEXTINSTRADDR               0xF1ABCE05  /**< absolute guest address of the next instruction */
+#define PATM_ASMFIX_CURINSTRADDR                0xF1ABCE06  /**< absolute guest address of the current instruction */
+#define PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION    0xF1ABCE07  /**< Relative address of global PATM lookup and call function. */
+#define PATM_ASMFIX_RETURN_FUNCTION             0xF1ABCE08  /**< Relative address of global PATM return function. */
+#define PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION    0xF1ABCE09  /**< Relative address of global PATM lookup and jump function. */
+#define PATM_ASMFIX_IRET_FUNCTION               0xF1ABCE0A  /**< Relative address of global PATM iret function. */
+#define PATM_ASMFIX_CPUID_CENTAUR_MAX           0xF1ABCE0B
 
 /** Identifies an patch fixup type value (with reasonable accuracy). */
-#define PATM_IS_FIXUP_TYPE(a_uValue) \
+#define PATM_IS_ASMFIX(a_uValue) \
     ( ((a_uValue) & UINT32_C(0xfffffC00)) == UINT32_C(0xF1ABCC00) && ((a_uValue) & UINT32_C(0xff)) < UINT32_C(0x30) )
 /** @} */
@@ -113 +113 @@
 #define PATM_ACTION_MAGIC                       0xABCD4321
 
-/** @name PATM_TEMP_RESTORE_FLAGS
+/** @name PATM_ASMFIX_TEMP_RESTORE_FLAGS
  * @{ */
 #define PATM_RESTORE_EAX                        RT_BIT(0)

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

@@ -70 +70 @@
 #define PATMFL_CALLABLE_AS_FUNCTION         RT_BIT_64(25) /** cli and pushf blocks can be used as callable functions. */
 #define PATMFL_GLOBAL_FUNCTIONS             RT_BIT_64(26) /** fake patch for global patm functions. */
-#define PATMFL_TRAMPOLINE                   RT_BIT_64(27) /** trampoline patch that clears PATM_INTERRUPTFLAG and jumps to patch destination */
+#define PATMFL_TRAMPOLINE                   RT_BIT_64(27) /** trampoline patch that clears PATM_ASMFIX_INTERRUPTFLAG and jumps to patch destination */
 #define PATMFL_GENERATE_SETPIF              RT_BIT_64(28) /** generate set PIF for the next instruction */
 #define PATMFL_INSTR_HINT                   RT_BIT_64(29) /** Generate patch, but don't activate it. */
@@ -112 +112 @@
  *
  * The source and desination addresses both set to the patch fixup type (see
- * PATM_IS_FIXUP_TYPE and friends in PATMA.h).  This is recent addition (CPUID
+ * PATM_IS_ASMFIX and friends in PATMA.h).  This is recent addition (CPUID
  * subleaf code), so when loading older saved states this is usally represented
  * as FIXUP_ABSOLUTE. */