VirtualBox

Changeset 13839

Show
Ignore:
Timestamp:
11/05/08 04:27:47 (2 months ago)
Author:
vboxsync
Message:

And yet more %V* -> %R* changes...

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/VBox/Additions/common/VBoxGuestLib/SysHlp.cpp

    r11922 r13839  
    4242    { 
    4343        rc = VERR_NOT_SUPPORTED; 
    44         AssertMsgFailed(("IoAllocateMdl %VGv %x failed!!\n", pv, u32Size)); 
     44        AssertMsgFailed(("IoAllocateMdl %p %x failed!!\n", pv, u32Size)); 
    4545    } 
    4646    else 
     
    5858            IoFreeMdl (pMdl); 
    5959            rc = VERR_INVALID_PARAMETER; 
    60             AssertMsgFailed(("MmProbeAndLockPages %VGv %x failed!!\n", pv, u32Size)); 
     60            AssertMsgFailed(("MmProbeAndLockPages %p %x failed!!\n", pv, u32Size)); 
    6161        } 
    6262    } 
     
    280280 
    281281    irp->AssociatedIrp.SystemBuffer = pvData; /* Output buffer. */ 
    282     irp->MdlAddress = NULL;     
     282    irp->MdlAddress = NULL; 
    283283 
    284284    /* A completion routine is required to signal the Event. */ 
  • trunk/src/VBox/Disassembler/DisasmReg.cpp

    r13836 r13839  
    721721            pParamVal->size   = sizeof(uint16_t); 
    722722            pParamVal->val.val16 = (uint16_t)pParam->parval; 
    723             AssertMsg(pParamVal->size == pParam->size || ((pParam->size == 1) && (pParam->flags & USE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%VGv\n", pParamVal->size, pParam->size, pCtx->eip) ); 
     723            AssertMsg(pParamVal->size == pParam->size || ((pParam->size == 1) && (pParam->flags & USE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%RX32\n", pParamVal->size, pParam->size, pCtx->eip) ); 
    724724        } 
    725725        else 
  • trunk/src/VBox/HostDrivers/Support/SUPDrv.c

    r13836 r13839  
    21542154                { 
    21552155                    paPages[iPage] = RTR0MemObjGetPagePhysAddr(Mem.MemObj, iPage); 
    2156                     AssertMsg(!(paPages[iPage] & (PAGE_SIZE - 1)), ("iPage=%d Phys=%VHp\n", paPages[iPage])); 
     2156                    AssertMsg(!(paPages[iPage] & (PAGE_SIZE - 1)), ("iPage=%d Phys=%RHp\n", paPages[iPage])); 
    21572157                } 
    21582158                *ppvR0 = RTR0MemObjAddress(Mem.MemObj); 
  • trunk/src/VBox/HostDrivers/Support/testcase/tstPin.cpp

    r11822 r13839  
    9696                    if (aPinnings[i].aPages[j].Phys >= _4G) 
    9797                    { 
    98                         RTPrintf("%2d: vrt=%p phys=%VHp\n", j, (char *)aPinnings[i].pvAligned + (j << PAGE_SHIFT), aPinnings[i].aPages[j].Phys); 
     98                        RTPrintf("%2d: vrt=%p phys=%RHp\n", j, (char *)aPinnings[i].pvAligned + (j << PAGE_SHIFT), aPinnings[i].aPages[j].Phys); 
    9999                        c4GPluss++; 
    100100                    } 
  • trunk/src/VBox/HostServices/SharedOpenGL/vboxgl.cpp

    r8155 r13839  
    121121 
    122122#ifdef DEBUG 
    123     Log(("Flush: last return value=%VX64\n", *pLastRetVal)); 
     123    Log(("Flush: last return value=%RX64\n", *pLastRetVal)); 
    124124    switch(*pLastError) 
    125125    { 
  • trunk/src/VBox/Runtime/r0drv/darwin/memobj-r0drv-darwin.cpp

    r9063 r13839  
    695695        AssertMsgReturn(Addr, ("iPage=%u\n", iPage), NIL_RTHCPHYS); 
    696696        PhysAddr = Addr; 
    697         AssertMsgReturn(PhysAddr == Addr, ("PhysAddr=%VHp Addr=%RX64\n", PhysAddr, (uint64_t)Addr), NIL_RTHCPHYS); 
     697        AssertMsgReturn(PhysAddr == Addr, ("PhysAddr=%RHp Addr=%RX64\n", PhysAddr, (uint64_t)Addr), NIL_RTHCPHYS); 
    698698    } 
    699699 
  • trunk/src/VBox/Runtime/r0drv/os2/memobj-r0drv-os2.cpp

    r8245 r13839  
    197197int rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest) 
    198198{ 
    199     AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%VHp\n", PhysHighest), VERR_NOT_IMPLEMENTED); 
     199    AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%RHp\n", PhysHighest), VERR_NOT_IMPLEMENTED); 
    200200 
    201201    /* create the object. */ 
  • trunk/src/VBox/Runtime/r0drv/solaris/memobj-r0drv-solaris.c

    r10457 r13839  
    237237int rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest) 
    238238{ 
    239     AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%VHp\n", PhysHighest), VERR_NOT_IMPLEMENTED); 
     239    AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%RHp\n", PhysHighest), VERR_NOT_IMPLEMENTED); 
    240240 
    241241    return rtR0MemObjNativeAllocCont(ppMem, cb, false); 
     
    305305    pMemSolaris->ppShadowPages = NULL; 
    306306    *ppMem = &pMemSolaris->Core; 
    307     return VINF_SUCCESS;     
     307    return VINF_SUCCESS; 
    308308} 
    309309 
  • trunk/src/VBox/Runtime/r0drv/solaris/vbi/memobj-r0drv-solaris.c

    r9176 r13839  
    175175int rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest) 
    176176{ 
    177     AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%VHp\n", PhysHighest), VERR_NOT_IMPLEMENTED); 
     177    AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%RHp\n", PhysHighest), VERR_NOT_IMPLEMENTED); 
    178178 
    179179    return rtR0MemObjNativeAllocCont(ppMem, cb, false); 
  • trunk/src/VBox/Runtime/testcase/tstLog.cpp

    r13837 r13839  
    4747    RTLogPrintf("%%Rra %d: %Rra\n", VERR_INVALID_PARAMETER, VERR_INVALID_PARAMETER); 
    4848 
    49     RTLogPrintf("%%Vt: %Vt\n"); 
     49    RTLogPrintf("%%Rt: %Rt\n"); 
    5050 
    5151    static uint8_t au8Hex[256]; 
    5252    for (unsigned iHex = 0; iHex < sizeof(au8Hex); iHex++) 
    5353        au8Hex[iHex] = (uint8_t)iHex; 
    54     RTLogPrintf("%%Vhxs   : %Vhxs\n", &au8Hex[0]); 
     54    RTLogPrintf("%%Rhxs   : %Rhxs\n", &au8Hex[0]); 
    5555    RTLogPrintf("%%.32Vhxs: %.32Vhxs\n", &au8Hex[0]); 
    5656 
    57     RTLogPrintf("%%Vhxd   :\n%Vhxd\n", &au8Hex[0]); 
     57    RTLogPrintf("%%Rhxd   :\n%Rhxd\n", &au8Hex[0]); 
    5858    RTLogPrintf("%%.64Vhxd:\n%.64Vhxd\n", &au8Hex[0]); 
    5959    RTLogPrintf("%%.*Vhxd:\n%.*Vhxd\n", 64, &au8Hex[0]); 
     
    6464    RTLogPrintf("%%*.*Vhxd : \n%*.*Vhxd\n", 7, 32, &au8Hex[0]); 
    6565 
    66     RTLogPrintf("%%VGp: %VGp\n", (RTGCPHYS)0x87654321); 
    67     RTLogPrintf("%%VGv: %VGv\n", (RTGCPTR)0x87654321); 
    68     RTLogPrintf("%%VHp: %VHp\n", (RTGCPHYS)0x87654321); 
    69     RTLogPrintf("%%VHv: %VHv\n", (RTGCPTR)0x87654321); 
     66    RTLogPrintf("%%RGp: %RGp\n", (RTGCPHYS)0x87654321); 
     67    RTLogPrintf("%%RGv: %RGv\n", (RTGCPTR)0x87654321); 
     68    RTLogPrintf("%%RHp: %RHp\n", (RTGCPHYS)0x87654321); 
     69    RTLogPrintf("%%RHv: %RHv\n", (RTGCPTR)0x87654321); 
    7070 
    71     RTLogPrintf("%%VI8 : %VI8\n", (uint8_t)808); 
    72     RTLogPrintf("%%VI16: %VI16\n", (uint16_t)16016); 
    73     RTLogPrintf("%%VI32: %VI32\n", _1G); 
    74     RTLogPrintf("%%VI64: %VI64\n", _1E); 
     71    RTLogPrintf("%%RI8 : %RI8\n", (uint8_t)808); 
     72    RTLogPrintf("%%RI16: %RI16\n", (uint16_t)16016); 
     73    RTLogPrintf("%%RI32: %RI32\n", _1G); 
     74    RTLogPrintf("%%RI64: %RI64\n", _1E); 
    7575 
    76     RTLogPrintf("%%VU8 : %VU8\n", (uint8_t)808); 
    77     RTLogPrintf("%%VU16: %VU16\n", (uint16_t)16016); 
    78     RTLogPrintf("%%VU32: %VU32\n", _2G32); 
    79     RTLogPrintf("%%VU64: %VU64\n", _2E); 
     76    RTLogPrintf("%%RU8 : %RU8\n", (uint8_t)808); 
     77    RTLogPrintf("%%RU16: %RU16\n", (uint16_t)16016); 
     78    RTLogPrintf("%%RU32: %RU32\n", _2G32); 
     79    RTLogPrintf("%%RU64: %RU64\n", _2E); 
    8080 
    81     RTLogPrintf("%%VX8 : %VX8 %#VX8\n",   (uint8_t)808, (uint8_t)808); 
    82     RTLogPrintf("%%VX16: %VX16 %#VX16\n", (uint16_t)16016, (uint16_t)16016); 
    83     RTLogPrintf("%%VX32: %VX32 %#VX32\n", _2G32, _2G32); 
    84     RTLogPrintf("%%VX64: %VX64 %#VX64\n", _2E, _2E); 
     81    RTLogPrintf("%%RX8 : %RX8 %#VX8\n",   (uint8_t)808, (uint8_t)808); 
     82    RTLogPrintf("%%RX16: %RX16 %#VX16\n", (uint16_t)16016, (uint16_t)16016); 
     83    RTLogPrintf("%%RX32: %RX32 %#VX32\n", _2G32, _2G32); 
     84    RTLogPrintf("%%RX64: %RX64 %#VX64\n", _2E, _2E); 
    8585 
    8686    RTLogFlush(NULL); 
  • trunk/src/recompiler/cpu-all.h

    r11982 r13839  
    10661066    if (RT_UNLIKELY((addr >> TARGET_PAGE_BITS) >= phys_ram_dirty_size)) 
    10671067    { 
    1068         Log(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr)); 
    1069         /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr));*/ 
     1068        Log(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr)); 
     1069        /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr));*/ 
    10701070        return 0; 
    10711071    } 
     
    10801080    if (RT_UNLIKELY((addr >> TARGET_PAGE_BITS) >= phys_ram_dirty_size)) 
    10811081    { 
    1082         Log(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr)); 
    1083         /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr));*/ 
     1082        Log(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr)); 
     1083        /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr));*/ 
    10841084        return 0xff & dirty_flags; /** @todo I don't think this is the right thing to return, fix! */ 
    10851085    } 
     
    10931093    if (RT_UNLIKELY((addr >> TARGET_PAGE_BITS) >= phys_ram_dirty_size)) 
    10941094    { 
    1095         Log(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr)); 
    1096         /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr));*/ 
     1095        Log(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr)); 
     1096        /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr));*/ 
    10971097        return; 
    10981098    } 
  • trunk/src/recompiler/cpu-exec.c

    r13117 r13839  
    362362                       double or triple faults yet. */ 
    363363                    RAWEx_ProfileStart(env, STATS_IRQ_HANDLING); 
    364                     Log(("do_interrupt %d %d %VGv\n", env->exception_index, env->exception_is_int, env->exception_next_eip)); 
     364                    Log(("do_interrupt %d %d %RGv\n", env->exception_index, env->exception_is_int, env->exception_next_eip)); 
    365365                    do_interrupt(env->exception_index, 
    366366                                 env->exception_is_int, 
     
    388388                            env->exception_index = EXCP_SINGLE_INSTR; 
    389389                            if (emulate_single_instr(env) == -1) 
    390                                 AssertMsgFailed(("REM: emulate_single_instr failed for EIP=%VGv!!\n", env->eip)); 
     390                                AssertMsgFailed(("REM: emulate_single_instr failed for EIP=%RGv!!\n", env->eip)); 
    391391 
    392392                            /* When we receive an external interrupt during execution of this single 
     
    497497                    if(!(env->state & CPU_EMULATE_SINGLE_STEP)) 
    498498                    { 
    499                         Log(("EMR0: %VGv ESP=%VGv IF=%d TF=%d CPL=%d\n", env->eip, ESP, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3)); 
     499                        Log(("EMR0: %RGv ESP=%RGv IF=%d TF=%d CPL=%d\n", env->eip, ESP, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3)); 
    500500                    } 
    501501                } 
     
    507507                        if(env->eflags & VM_MASK) 
    508508                        { 
    509                             Log(("EMV86: %04X:%VGv IF=%d TF=%d CPL=%d CR0=%RGr\n", env->segs[R_CS].selector, env->eip, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, env->cr[0])); 
     509                            Log(("EMV86: %04X:%RGv IF=%d TF=%d CPL=%d CR0=%RGr\n", env->segs[R_CS].selector, env->eip, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, env->cr[0])); 
    510510                        } 
    511511                        else 
    512512                        { 
    513                             Log(("EMR3: %VGv ESP=%VGv IF=%d TF=%d CPL=%d IOPL=%d CR0=%RGr\n", env->eip, ESP, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, ((env->eflags >> IOPL_SHIFT) & 3), env->cr[0])); 
     513                            Log(("EMR3: %RGv ESP=%RGv IF=%d TF=%d CPL=%d IOPL=%d CR0=%RGr\n", env->eip, ESP, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, ((env->eflags >> IOPL_SHIFT) & 3), env->cr[0])); 
    514514                        } 
    515515                    } 
     
    518518                { 
    519519                    /* Seriously slows down realmode booting. */ 
    520                     LogFlow(("EMRM: %04X:%VGv SS:ESP=%04X:%VGv IF=%d TF=%d CPL=%d PE=%d PG=%d\n", env->segs[R_CS].selector, env->eip, env->segs[R_SS].selector, ESP, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, env->cr[0] & X86_CR0_PE, env->cr[0] & X86_CR0_PG)); 
     520                    LogFlow(("EMRM: %04X:%RGv SS:ESP=%04X:%RGv IF=%d TF=%d CPL=%d PE=%d PG=%d\n", env->segs[R_CS].selector, env->eip, env->segs[R_SS].selector, ESP, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, env->cr[0] & X86_CR0_PE, env->cr[0] & X86_CR0_PG)); 
    521521                } 
    522522#endif /* !DEBUG_bird */ 
     
    542542                    if(emulate_single_instr(env) == -1) 
    543543                    { 
    544                         Log(("emulate_single_instr failed for EIP=%VGv!!\n", env->eip)); 
     544                        Log(("emulate_single_instr failed for EIP=%RGv!!\n", env->eip)); 
    545545                    } 
    546546                } 
     
    802802                            env->exception_index = EXCP_SINGLE_INSTR; 
    803803                            if (emulate_single_instr(env) == -1) 
    804                                 AssertMsgFailed(("REM: emulate_single_instr failed for EIP=%VGv!!\n", env->eip)); 
     804                                AssertMsgFailed(("REM: emulate_single_instr failed for EIP=%RGv!!\n", env->eip)); 
    805805 
    806806                            /* When we receive an external interrupt during execution of this single 
     
    12011201                    if(!(env->state & CPU_EMULATE_SINGLE_STEP)) 
    12021202                    { 
    1203                         Log(("EMR0: %VGv IF=%d TF=%d CPL=%d\n", env->eip, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3)); 
     1203                        Log(("EMR0: %RGv IF=%d TF=%d CPL=%d\n", env->eip, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3)); 
    12041204                    } 
    12051205                } 
     
    12111211                        if(env->eflags & VM_MASK) 
    12121212                        { 
    1213                             Log(("EMV86: %VGv IF=%d TF=%d CPL=%d flags=%08X CR0=%RGr\n", env->eip, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, flags, env->cr[0])); 
     1213                            Log(("EMV86: %RGv IF=%d TF=%d CPL=%d flags=%08X CR0=%RGr\n", env->eip, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, flags, env->cr[0])); 
    12141214                        } 
    12151215                        else 
    12161216                        { 
    1217                             Log(("EMR3: %VGv IF=%d TF=%d CPL=%d IOPL=%d flags=%08X CR0=%RGr\n", env->eip, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, ((env->eflags >> IOPL_SHIFT) & 3), flags, env->cr[0])); 
     1217                            Log(("EMR3: %RGv IF=%d TF=%d CPL=%d IOPL=%d flags=%08X CR0=%RGr\n", env->eip, (env->eflags & IF_MASK) ? 1 : 0, (env->eflags & TF_MASK) ? 1 : 0, (env->hflags >> HF_CPL_SHIFT) & 3, ((env->eflags >> IOPL_SHIFT) & 3), flags, env->cr[0])); 
    12181218                        } 
    12191219                    } 
     
    12401240                    if(emulate_single_instr(env) == -1) 
    12411241                    { 
    1242                         printf("emulate_single_instr failed for EIP=%VGv!!\n", env->eip); 
     1242                        printf("emulate_single_instr failed for EIP=%RGv!!\n", env->eip); 
    12431243                    } 
    12441244                } 
     
    14221422    if (ret == 1) { 
    14231423#if 0 
    1424         printf("PF exception: EIP=0x%VGv CR2=0x%VGv error=0x%x\n", 
     1424        printf("PF exception: EIP=0x%RGv CR2=0x%RGv error=0x%x\n", 
    14251425               env->eip, env->cr[2], env->error_code); 
    14261426#endif 
  • trunk/src/recompiler/target-i386/helper.c

    r13449 r13839  
    14101410{ 
    14111411#if defined(VBOX) && defined(DEBUG) 
    1412     NOT_DMIK(Log2(("raise_interrupt: %x %x %x %VGv\n", intno, is_int, error_code, env->eip + next_eip_addend))); 
     1412    NOT_DMIK(Log2(("raise_interrupt: %x %x %x %RGv\n", intno, is_int, error_code, env->eip + next_eip_addend))); 
    14131413#endif 
    14141414    env->exception_index = intno; 
     
    19781978    target_ulong ptr; 
    19791979#ifdef VBOX 
    1980     Log(("helper_lldt_T0: old ldtr=%RTsel {.base=%VGv, .limit=%VGv} new=%RTsel\n", 
     1980    Log(("helper_lldt_T0: old ldtr=%RTsel {.base=%RGv, .limit=%RGv} new=%RTsel\n", 
    19811981         (RTSEL)env->ldt.selector, (RTGCPTR)env->ldt.base, (RTGCPTR)env->ldt.limit, (RTSEL)(T0 & 0xffff))); 
    19821982#endif 
     
    20212021    env->ldt.selector = selector; 
    20222022#ifdef VBOX 
    2023     Log(("helper_lldt_T0: new ldtr=%RTsel {.base=%VGv, .limit=%VGv}\n", 
     2023    Log(("helper_lldt_T0: new ldtr=%RTsel {.base=%RGv, .limit=%RGv}\n", 
    20242024         (RTSEL)env->ldt.selector, (RTGCPTR)env->ldt.base, (RTGCPTR)env->ldt.limit)); 
    20252025#endif 
     
    20352035 
    20362036#ifdef VBOX 
    2037     Log(("helper_ltr_T0: old tr=%RTsel {.base=%VGv, .limit=%VGv, .flags=%RX32} new=%RTsel\n", 
     2037    Log(("helper_ltr_T0: old tr=%RTsel {.base=%RGv, .limit=%RGv, .flags=%RX32} new=%RTsel\n", 
    20382038         (RTSEL)env->tr.selector, (RTGCPTR)env->tr.base, (RTGCPTR)env->tr.limit, 
    20392039         env->tr.flags, (RTSEL)(T0 & 0xffff))); 
     
    20842084    env->tr.selector = selector; 
    20852085#ifdef VBOX 
    2086     Log(("helper_ltr_T0: new tr=%RTsel {.base=%VGv, .limit=%VGv, .flags=%RX32} new=%RTsel\n", 
     2086    Log(("helper_ltr_T0: new tr=%RTsel {.base=%RGv, .limit=%RGv, .flags=%RX32} new=%RTsel\n", 
    20872087         (RTSEL)env->tr.selector, (RTGCPTR)env->tr.base, (RTGCPTR)env->tr.limit, 
    20882088         env->tr.flags, (RTSEL)(T0 & 0xffff))); 
     
    46514651    if (env->hflags & HF_INHIBIT_IRQ_MASK) 
    46524652    { 
    4653         Log(("REM: Emulating next instruction due to instruction fusing (HF_INHIBIT_IRQ_MASK) at %VGv\n", env->eip)); 
     4653        Log(("REM: Emulating next instruction due to instruction fusing (HF_INHIBIT_IRQ_MASK) at %RGv\n", env->eip)); 
    46544654        env->hflags &= ~HF_INHIBIT_IRQ_MASK; 
    46554655        emulate_single_instr(env); 
  • trunk/src/recompiler/target-i386/translate.c

    r12421 r13839  
    33533353    /* illegal sequence. The s->pc is past the lock prefix and that 
    33543354       is sufficient for the TB, I think. */ 
    3355     Log(("illegal lock sequence %VGv (b=%#x)\n", pc_start, b)); 
     3355    Log(("illegal lock sequence %RGv (b=%#x)\n", pc_start, b)); 
    33563356    return true; 
    33573357} 
  • trunk/src/recompiler_new/cpu-all.h

    r13559 r13839  
    11921192 
    11931193/* MMIO pages are identified by a combination of an IO device index and 
    1194    3 flags.  The ROMD code stores the page ram offset in iotlb entry,  
     1194   3 flags.  The ROMD code stores the page ram offset in iotlb entry, 
    11951195   so only a limited number of ids are avaiable.  */ 
    11961196 
     
    12911291    if (RT_UNLIKELY((addr >> TARGET_PAGE_BITS) >= phys_ram_dirty_size)) 
    12921292    { 
    1293         Log(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr)); 
    1294         /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr));*/ 
     1293        Log(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr)); 
     1294        /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr));*/ 
    12951295        return 0; 
    12961296    } 
     
    13111311    if (RT_UNLIKELY((addr >> TARGET_PAGE_BITS) >= phys_ram_dirty_size)) 
    13121312    { 
    1313         Log(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr)); 
    1314         /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr));*/ 
     1313        Log(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr)); 
     1314        /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr));*/ 
    13151315        return 0xff & dirty_flags; /** @todo I don't think this is the right thing to return, fix! */ 
    13161316    } 
     
    13291329    if (RT_UNLIKELY((addr >> TARGET_PAGE_BITS) >= phys_ram_dirty_size)) 
    13301330    { 
    1331         Log(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr)); 
    1332         /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %VGp\n", (RTGCPHYS)addr));*/ 
     1331        Log(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr)); 
     1332        /*AssertMsgFailed(("cpu_physical_memory_is_dirty: %RGp\n", (RTGCPHYS)addr));*/ 
    13331333        return; 
    13341334    } 
  • trunk/src/recompiler_new/cpu-exec.c

    r13726 r13839  
    326326                       double or triple faults yet. */ 
    327327                    RAWEx_ProfileStart(env, STATS_IRQ_HANDLING); 
    328                     Log(("do_interrupt %d %d %VGv\n", env->exception_index, env->exception_is_int, env->exception_next_eip)); 
     328                    Log(("do_interrupt %d %d %RGv\n", env->exception_index, env->exception_is_int, env->exception_next_eip)); 
    329329                    do_interrupt(env->exception_index, 
    330330                                 env->exception_is_int, 
     
    360360                            env->exception_index = EXCP_SINGLE_INSTR; 
    361361                            if (emulate_single_instr(env) == -1) 
    362                                 AssertMsgFailed(("REM: emulate_single_instr failed for EIP=%VGv!!\n", env->eip)); 
     362                                AssertMsgFailed(("REM: emulate_single_instr failed for EIP=%RGv!!\n", env->eip)); 
    363363 
    364364                            /* When we receive an external interrupt during execution of this single 
     
    504504                     } 
    505505                } 
    506                      
     506 
    507507                /* reset soft MMU for next block (it can currently 
    508508                   only be set by a memory fault) */ 
     
    695695                            next_tb = 0; 
    696696                        } else if ((interrupt_request & CPU_INTERRUPT_HARD) && 
    697                                    (((env->hflags2 & HF2_VINTR_MASK) &&  
     697                                   (((env->hflags2 & HF2_VINTR_MASK) && 
    698698                                     (env->hflags2 & HF2_HIF_MASK)) || 
    699                                     (!(env->hflags2 & HF2_VINTR_MASK) &&  
    700                                      (env->eflags & IF_MASK &&  
     699                                    (!(env->hflags2 & HF2_VINTR_MASK) && 
     700                                     (env->eflags & IF_MASK && 
    701701                                      !(env->hflags & HF_INHIBIT_IRQ_MASK))))) { 
    702702                            int intno; 
     
    713713#if !defined(CONFIG_USER_ONLY) 
    714714                        } else if ((interrupt_request & CPU_INTERRUPT_VIRQ) && 
    715                                    (env->eflags & IF_MASK) &&  
     715                                   (env->eflags & IF_MASK) && 
    716716                                   !(env->hflags & HF_INHIBIT_IRQ_MASK)) { 
    717717                            int intno; 
     
    10961096    if (ret == 1) { 
    10971097#if 0 
    1098         printf("PF exception: EIP=0x%VGv CR2=0x%VGv error=0x%x\n", 
     1098        printf("PF exception: EIP=0x%RGv CR2=0x%RGv error=0x%x\n", 
    10991099               env->eip, env->cr[2], env->error_code); 
    11001100#endif 
  • trunk/src/recompiler_new/target-i386/translate.c

    r13672 r13839  
    519519} 
    520520#endif 
    521      
     521 
    522522static void gen_add_A0_im(DisasContext *s, int val) 
    523523{ 
     
    624624{ 
    625625    tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUState, regs[reg])); 
    626     if (shift != 0)  
     626    if (shift != 0) 
    627627        tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, shift); 
    628628    tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0); 
     
    690690{ 
    691691    tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUState, regs[reg])); 
    692     if (shift != 0)  
     692    if (shift != 0) 
    693693        tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, shift); 
    694694    tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0); 
     
    826826    int skip_label; 
    827827    TCGv t0; 
    828      
     828 
    829829    skip_label = gen_new_label(); 
    830830    /* t0 = tcg_temp_local_new(TCG_TYPE_TL); */ 
    831     t0 = cpu_tmp0;  
     831    t0 = cpu_tmp0; 
    832832 
    833833    tcg_gen_ld32u_tl(t0, cpu_env, offsetof(CPUState, interrupt_request)); 
    834834    /* Keep in sync with helper_check_external_event() */ 
    835     tcg_gen_andi_tl(t0, t0,  
     835    tcg_gen_andi_tl(t0, t0, 
    836836                    CPU_INTERRUPT_EXTERNAL_EXIT 
    837837                    | CPU_INTERRUPT_EXTERNAL_TIMER 
     
    923923 
    924924#ifndef VBOX 
    925 static inline void gen_op_movl_T0_Dshift(int ot)  
     925static inline void gen_op_movl_T0_Dshift(int ot) 
    926926#else /* VBOX */ 
    927 DECLINLINE(void) gen_op_movl_T0_Dshift(int ot)  
     927DECLINLINE(void) gen_op_movl_T0_Dshift(int ot) 
    928928#endif /* VBOX */ 
    929929{ 
     
    11091109#if TCG_TARGET_REG_BITS == 32 
    11101110    tcg_gen_shli_i32(cpu_tmp2_i32, cpu_cc_op, 3); 
    1111     tcg_gen_addi_i32(cpu_tmp2_i32, cpu_tmp2_i32,  
     1111    tcg_gen_addi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 
    11121112                     (long)cc_table + offsetof(CCTable, compute_c)); 
    11131113    tcg_gen_ld_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0); 
    1114     tcg_gen_call(&tcg_ctx, cpu_tmp2_i32, TCG_CALL_PURE,  
     1114    tcg_gen_call(&tcg_ctx, cpu_tmp2_i32, TCG_CALL_PURE, 
    11151115                 1, &cpu_tmp2_i32, 0, NULL); 
    11161116#else 
    11171117    tcg_gen_extu_i32_tl(cpu_tmp1_i64, cpu_cc_op); 
    11181118    tcg_gen_shli_i64(cpu_tmp1_i64, cpu_tmp1_i64, 4); 
    1119     tcg_gen_addi_i64(cpu_tmp1_i64, cpu_tmp1_i64,  
     1119    tcg_gen_addi_i64(cpu_tmp1_i64, cpu_tmp1_i64, 
    11201120                     (long)cc_table + offsetof(CCTable, compute_c)); 
    11211121    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_tmp1_i64, 0); 
    1122     tcg_gen_call(&tcg_ctx, cpu_tmp1_i64, TCG_CALL_PURE,  
     1122    tcg_gen_call(&tcg_ctx, cpu_tmp1_i64, TCG_CALL_PURE, 
    11231123                 1, &cpu_tmp2_i32, 0, NULL); 
    11241124#endif 
     
    11311131#if TCG_TARGET_REG_BITS == 32 
    11321132    tcg_gen_shli_i32(cpu_tmp2_i32, cpu_cc_op, 3); 
    1133     tcg_gen_addi_i32(cpu_tmp2_i32, cpu_tmp2_i32,  
     1133    tcg_gen_addi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 
    11341134                     (long)cc_table + offsetof(CCTable, compute_all)); 
    11351135    tcg_gen_ld_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0); 
    1136     tcg_gen_call(&tcg_ctx, cpu_tmp2_i32, TCG_CALL_PURE,  
     1136    tcg_gen_call(&tcg_ctx, cpu_tmp2_i32, TCG_CALL_PURE, 
    11371137                 1, &cpu_tmp2_i32, 0, NULL); 
    11381138#else 
    11391139    tcg_gen_extu_i32_tl(cpu_tmp1_i64, cpu_cc_op); 
    11401140    tcg_gen_shli_i64(cpu_tmp1_i64, cpu_tmp1_i64, 4); 
    1141     tcg_gen_addi_i64(cpu_tmp1_i64, cpu_tmp1_i64,  
     1141    tcg_gen_addi_i64(cpu_tmp1_i64, cpu_tmp1_i64, 
    11421142                     (long)cc_table + offsetof(CCTable, compute_all)); 
    11431143    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_tmp1_i64, 0); 
    1144     tcg_gen_call(&tcg_ctx, cpu_tmp1_i64, TCG_CALL_PURE,  
     1144    tcg_gen_call(&tcg_ctx, cpu_tmp1_i64, TCG_CALL_PURE, 
    11451145                 1, &cpu_tmp2_i32, 0, NULL); 
    11461146#endif 
     
    12771277    case CC_OP_SUBL: 
    12781278    case CC_OP_SUBQ: 
    1279          
     1279 
    12801280        size = cc_op - CC_OP_SUBB; 
    12811281        switch(jcc_op) { 
     
    13081308            case 0: 
    13091309                tcg_gen_andi_tl(cpu_tmp0, cpu_cc_dst, 0x80); 
    1310                 tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0,  
     1310                tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0, 
    13111311                                   0, l1); 
    13121312                break; 
    13131313            case 1: 
    13141314                tcg_gen_andi_tl(cpu_tmp0, cpu_cc_dst, 0x8000); 
    1315                 tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0,  
     1315                tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0, 
    13161316                                   0, l1); 
    13171317                break; 
     
    13191319            case 2: 
    13201320                tcg_gen_andi_tl(cpu_tmp0, cpu_cc_dst, 0x80000000); 
    1321                 tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0,  
     1321                tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0, 
    13221322                                   0, l1); 
    13231323                break; 
    13241324#endif 
    13251325            default: 
    1326                 tcg_gen_brcondi_tl(inv ? TCG_COND_GE : TCG_COND_LT, cpu_cc_dst,  
     1326                tcg_gen_brcondi_tl(inv ? TCG_COND_GE : TCG_COND_LT, cpu_cc_dst, 
    13271327                                   0, l1); 
    13281328                break; 
    13291329            } 
    13301330            break; 
    1331              
     1331 
    13321332        case JCC_B: 
    13331333            cond = inv ? TCG_COND_GEU : TCG_COND_LTU; 
     
    13611361            tcg_gen_brcond_tl(cond, cpu_tmp4, t0, l1); 
    13621362            break; 
    1363              
     1363 
    13641364        case JCC_L: 
    13651365            cond = inv ? TCG_COND_GE : TCG_COND_LT; 
     
    13931393            tcg_gen_brcond_tl(cond, cpu_tmp4, t0, l1); 
    13941394            break; 
    1395              
     1395 
    13961396        default: 
    13971397            goto slow_jcc; 
    13981398        } 
    13991399        break; 
    1400          
     1400 
    14011401        /* some jumps are easy to compute */ 
    14021402    case CC_OP_ADDB: 
     
    14041404    case CC_OP_ADDL: 
    14051405    case CC_OP_ADDQ: 
    1406          
     1406 
    14071407    case CC_OP_ADCB: 
    14081408    case CC_OP_ADCW: 
    14091409    case CC_OP_ADCL: 
    14101410    case CC_OP_ADCQ: 
    1411          
     1411 
    14121412    case CC_OP_SBBB: 
    14131413    case CC_OP_SBBW: 
    14141414    case CC_OP_SBBL: 
    14151415    case CC_OP_SBBQ: 
    1416          
     1416 
    14171417    case CC_OP_LOGICB: 
    14181418    case CC_OP_LOGICW: 
    14191419    case CC_OP_LOGICL: 
    14201420    case CC_OP_LOGICQ: 
    1421          
     1421 
    14221422    case CC_OP_INCB: 
    14231423    case CC_OP_INCW: 
    14241424    case CC_OP_INCL: 
    14251425    case CC_OP_INCQ: 
    1426          
     1426 
    14271427    case CC_OP_DECB: 
    14281428    case CC_OP_DECW: 
    14291429    case CC_OP_DECL: 
    14301430    case CC_OP_DECQ: 
    1431          
     1431 
    14321432    case CC_OP_SHLB: 
    14331433    case CC_OP_SHLW: 
    14341434    case CC_OP_SHLL: 
    14351435    case CC_OP_SHLQ: 
    1436          
     1436 
    14371437    case CC_OP_SARB: 
    14381438    case CC_OP_SARW: 
     
    14531453    slow_jcc: 
    14541454        gen_setcc_slow_T0(s, jcc_op); 
    1455         tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE,  
     1455        tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, 
    14561456                           cpu_T[0], 0, l1); 
    14571457        break; 
     
    18021802} 
    18031803 
    1804 static void gen_shift_rm_T1(DisasContext *s, int ot, int op1,  
     1804static void gen_shift_rm_T1(DisasContext *s, int ot, int op1, 
    18051805                            int is_right, int is_arith) 
    18061806{ 
     
    18441844    else 
    18451845        gen_op_mov_reg_T0(ot, op1); 
    1846          
     1846 
    18471847    /* update eflags if non zero shift */ 
    18481848    if (s->cc_op != CC_OP_DYNAMIC) 
     
    18651865    else 
    18661866        tcg_gen_movi_i32(cpu_cc_op, CC_OP_SHLB + ot); 
    1867          
     1867 
    18681868    gen_set_label(shift_label); 
    18691869    s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */ 
     
    18771877{ 
    18781878    int mask; 
    1879      
     1879 
    18801880    if (ot == OT_QUAD) 
    18811881        mask = 0x3f; 
     
    19121912    else 
    19131913        gen_op_mov_reg_T0(ot, op1); 
    1914          
     1914 
    19151915    /* update eflags if non zero shift */ 
    19161916    if (op2 != 0) { 
     
    19371937 
    19381938/* XXX: add faster immediate case */ 
    1939 static void gen_rot_rm_T1(DisasContext *s, int ot, int op1,  
     1939static void gen_rot_rm_T1(DisasContext *s, int ot, int op1, 
    19401940                          int is_right) 
    19411941{ 
     
    19711971    label1 = gen_new_label(); 
    19721972    tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, label1); 
    1973      
     1973 
    19741974    if (ot <= OT_WORD) 
    19751975        tcg_gen_andi_tl(cpu_tmp0, t1, (1 << (3 + ot)) - 1); 
    19761976    else 
    19771977        tcg_gen_mov_tl(cpu_tmp0, t1); 
    1978      
     1978 
    19791979    gen_extu(ot, t0); 
    19801980    tcg_gen_mov_tl(t2, t0); 
     
    20012001        gen_op_mov_reg_v(ot, op1, t0); 
    20022002    } 
    2003      
     2003 
    20042004    /* update eflags */ 
    20052005    if (s->cc_op != CC_OP_DYNAMIC) 
     
    20202020    tcg_gen_andi_tl(t0, t0, CC_C); 
    20212021    tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t0); 
    2022      
     2022 
    20232023    tcg_gen_discard_tl(cpu_cc_dst); 
    20242024    tcg_gen_movi_i32(cpu_cc_op, CC_OP_EFLAGS); 
    2025          
     2025 
    20262026    gen_set_label(label2); 
    20272027    s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */ 
     
    20452045 
    20462046/* XXX: add faster immediate = 1 case */ 
    2047 static void gen_rotc_rm_T1(DisasContext *s, int ot, int op1,  
     2047static void gen_rotc_rm_T1(DisasContext *s, int ot, int op1, 
    20482048                           int is_right) 
    20492049{ 
     
    20582058    else 
    20592059        gen_op_mov_TN_reg(ot, 0, op1); 
    2060      
     2060 
    20612061    tcg_gen_helper_1_2(helper_rotc[ot + (is_right * 4)], 
    20622062                       cpu_T[0], cpu_T[0], cpu_T[1]); 
     
    20742074    tcg_gen_discard_tl(cpu_cc_dst); 
    20752075    tcg_gen_movi_i32(cpu_cc_op, CC_OP_EFLAGS); 
    2076          
     2076 
    20772077    gen_set_label(label1); 
    20782078    s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */ 
     
    20802080 
    20812081/* XXX: add faster immediate case */ 
    2082 static void gen_shiftd_rm_T1_T3(DisasContext *s, int ot, int op1,  
     2082static void gen_shiftd_rm_T1_T3(DisasContext *s, int ot, int op1, 
    20832083                                int is_right) 
    20842084{ 
     
    21142114    label1 = gen_new_label(); 
    21152115    tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, label1); 
    2116      
     2116 
    21172117    tcg_gen_addi_tl(cpu_tmp5, t2, -1); 
    21182118    if (ot == OT_WORD) { 
     
    21252125 
    21262126            tcg_gen_shr_tl(cpu_tmp4, t0, cpu_tmp5); 
    2127              
     2127 
    21282128            /* only needed if count > 16, but a test would complicate */ 
    21292129            tcg_gen_sub_tl(cpu_tmp5, tcg_const_tl(32), t2); 
     
    21392139            tcg_gen_or_tl(t1, t1, t0); 
    21402140            tcg_gen_ext32u_tl(t1, t1); 
    2141              
     2141 
    21422142            tcg_gen_shl_tl(cpu_tmp4, t0, cpu_tmp5); 
    21432143            tcg_gen_sub_tl(cpu_tmp0, tcg_const_tl(32), cpu_tmp5); 
     
    21622162            tcg_gen_shl_tl(t1, t1, cpu_tmp5); 
    21632163            tcg_gen_or_tl(t0, t0, t1); 
    2164              
     2164 
    21652165        } else { 
    21662166            if (ot == OT_LONG) 
     
    21682168 
    21692169            tcg_gen_shl_tl(cpu_tmp4, t0, cpu_tmp5); 
    2170              
     2170 
    21712171            tcg_gen_shl_tl(t0, t0, t2); 
    21722172            tcg_gen_sub_tl(cpu_tmp5, tcg_const_tl(data_bits), t2);