VirtualBox

Changeset 13382

Show
Ignore:
Timestamp:
10/19/08 22:45:30 (3 months ago)
Author:
vboxsync
Message:

more MSVC-related stuff

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/recompiler_new/VBoxRecompiler.c

    r13358 r13382  
    245245    uint32_t u32Dummy; 
    246246    unsigned i; 
     247    int rc; 
    247248 
    248249    /* 
     
    276277 
    277278    /* ctx. */ 
    278     int rc = CPUMQueryGuestCtxPtr(pVM, &pVM->rem.s.pCtx); 
     279    rc = CPUMQueryGuestCtxPtr(pVM, &pVM->rem.s.pCtx); 
    279280    if (VBOX_FAILURE(rc)) 
    280281    { 
     
    451452static DECLCALLBACK(int) remR3Save(PVM pVM, PSSMHANDLE pSSM) 
    452453{ 
    453     LogFlow(("remR3Save:\n")); 
    454  
    455454    /* 
    456455     * Save the required CPU Env bits. 
     
    458457     */ 
    459458    PREM pRem = &pVM->rem.s; 
     459    LogFlow(("remR3Save:\n")); 
    460460    Assert(!pRem->fInREM); 
    461461    SSMR3PutU32(pSSM,   pRem->Env.hflags); 
     
    482482    uint32_t u32Dummy; 
    483483    uint32_t fRawRing0 = false; 
     484    uint32_t u32Sep; 
     485    int rc; 
     486    PREM pRem; 
    484487    LogFlow(("remR3Load:\n")); 
    485488 
     
    509512     * (Not much because we're never in REM when doing the save.) 
    510513     */ 
    511     PREM pRem = &pVM->rem.s; 
     514    pRem = &pVM->rem.s; 
    512515    Assert(!pRem->fInREM); 
    513516    SSMR3GetU32(pSSM,   &pRem->Env.hflags); 
     
    519522    } 
    520523 
    521     uint32_t u32Sep; 
    522     int rc = SSMR3GetU32(pSSM, &u32Sep);            /* separator */ 
     524    rc = SSMR3GetU32(pSSM, &u32Sep);            /* separator */ 
    523525    if (VBOX_FAILURE(rc)) 
    524526        return rc; 
     
    536538    if (u32Version == REM_SAVED_STATE_VERSION_VER1_6) 
    537539    { 
     540        unsigned i; 
     541     
    538542        /* 
    539543         * Load the REM stuff. 
     
    547551            return VERR_SSM_DATA_UNIT_FORMAT_CHANGED; 
    548552        } 
    549         unsigned i; 
    550553        for (i = 0; i < pRem->cInvalidatedPages; i++) 
    551554            SSMR3GetGCPtr(pSSM, &pRem->aGCPtrInvalidatedPages[i]); 
     
    608611REMR3DECL(int) REMR3Step(PVM pVM) 
    609612{ 
     613    int         rc, interrupt_request; 
     614    RTGCPTR     GCPtrPC; 
     615    bool        fBp; 
     616  
    610617    /* 
    611618     * Lock the REM - we don't wanna have anyone interrupting us 
     
    613620     * pending interrupts and suchlike. 
    614621     */ 
    615     int interrupt_request = pVM->rem.s.Env.interrupt_request; 
     622    interrupt_request = pVM->rem.s.Env.interrupt_request; 
    616623    Assert(!(interrupt_request & ~(CPU_INTERRUPT_HARD | CPU_INTERRUPT_EXIT | CPU_INTERRUPT_EXITTB | CPU_INTERRUPT_TIMER  | CPU_INTERRUPT_EXTERNAL_HARD | CPU_INTERRUPT_EXTERNAL_EXIT | CPU_INTERRUPT_EXTERNAL_TIMER))); 
    617624    pVM->rem.s.Env.interrupt_request = 0; 
     
    621628     * If we're standing at a breakpoint, that have to be disabled before we start stepping. 
    622629     */ 
    623     RTGCPTR     GCPtrPC = pVM->rem.s.Env.eip + pVM->rem.s.Env.segs[R_CS].base; 
    624     bool        fBp = !cpu_breakpoint_remove(&pVM->rem.s.Env, GCPtrPC); 
     630    GCPtrPC = pVM->rem.s.Env.eip + pVM->rem.s.Env.segs[R_CS].base; 
     631    fBp = !cpu_breakpoint_remove(&pVM->rem.s.Env, GCPtrPC); 
    625632 
    626633    /* 
     
    629636     * just flip it on and off to make sure it moves 
    630637     */ 
    631     int rc = cpu_exec(&pVM->rem.s.Env); 
     638    rc = cpu_exec(&pVM->rem.s.Env); 
    632639    if (rc == EXCP_DEBUG) 
    633640    { 
     
    728735REMR3DECL(int) REMR3EmulateInstruction(PVM pVM) 
    729736{ 
     737    int rc, rc2; 
    730738    Log2(("REMR3EmulateInstruction: (cs:eip=%04x:%08x)\n", CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM))); 
    731739 
     
    739747     * Sync the state and enable single instruction / single stepping. 
    740748     */ 
    741     int rc = REMR3State(pVM, false /* no need to flush the TBs; we always compile. */); 
     749    rc = REMR3State(pVM, false /* no need to flush the TBs; we always compile. */); 
    742750    if (VBOX_SUCCESS(rc)) 
    743751    { 
     
    951959#endif 
    952960        pVM->rem.s.Env.interrupt_request = interrupt_request; 
    953         int rc2 = REMR3StateBack(pVM); 
     961        rc2 = REMR3StateBack(pVM); 
    954962        AssertRC(rc2); 
    955963    } 
     
    975983REMR3DECL(int) REMR3Run(PVM pVM) 
    976984{ 
     985    int rc; 
    977986    Log2(("REMR3Run: (cs:eip=%04x:%VGv)\n", pVM->rem.s.Env.segs[R_CS].selector, pVM->rem.s.Env.eip)); 
    978987    Assert(pVM->rem.s.fInREM); 
    979988 
    980989    TMNotifyStartOfExecution(pVM); 
    981     int rc = cpu_exec(&pVM->rem.s.Env); 
     990    rc = cpu_exec(&pVM->rem.s.Env); 
    982991    TMNotifyEndOfExecution(pVM); 
    983992    switch (rc) 
     
    11041113    /* !!! THIS MUST BE IN SYNC WITH emR3Reschedule !!! */ 
    11051114    /* !!! THIS MUST BE IN SYNC WITH emR3Reschedule !!! */ 
     1115    uint32_t u32CR0; 
    11061116 
    11071117    /* Update counter. */ 
     
    11101120    if (HWACCMIsEnabled(env->pVM)) 
    11111121    { 
     1122        CPUMCTX Ctx; 
     1123 
    11121124        env->state |= CPU_RAW_HWACC; 
    11131125 
     
    11151127         * Create partial context for HWACCMR3CanExecuteGuest 
    11161128         */ 
    1117         CPUMCTX Ctx; 
    11181129        Ctx.cr0            = env->cr[0]; 
    11191130        Ctx.cr3            = env->cr[3]; 
     
    12151226    } 
    12161227 
    1217     uint32_t u32CR0 = env->cr[0]; 
     1228    u32CR0 = env->cr[0]; 
    12181229    if ((u32CR0 & (X86_CR0_PG | X86_CR0_PE)) != (X86_CR0_PG | X86_CR0_PE)) 
    12191230    { 
     
    13441355{ 
    13451356    PVM pVM = env->pVM; 
     1357    PCPUMCTX pCtx; 
     1358    int rc; 
    13461359 
    13471360    /* 
     
    13591372     * Update the control registers before calling PGMFlushPage. 
    13601373     */ 
    1361     PCPUMCTX pCtx = (PCPUMCTX)pVM->rem.s.pCtx; 
     1374    pCtx = (PCPUMCTX)pVM->rem.s.pCtx; 
    13621375    pCtx->cr0 = env->cr[0]; 
    13631376    pCtx->cr3 = env->cr[3]; 
     
    13671380     * Let PGM do the rest. 
    13681381     */ 
    1369     int rc = PGMInvalidatePage(pVM, GCPtr); 
     1382    rc = PGMInvalidatePage(pVM, GCPtr); 
    13701383    if (VBOX_FAILURE(rc)) 
    13711384    { 
     
    14261439{ 
    14271440    PVM pVM = env->pVM; 
     1441    PCPUMCTX pCtx; 
    14281442 
    14291443    /* 
     
    14451459     * Update the control registers before calling PGMR3FlushTLB. 
    14461460     */ 
    1447     PCPUMCTX pCtx = (PCPUMCTX)pVM->rem.s.pCtx; 
     1461    pCtx = (PCPUMCTX)pVM->rem.s.pCtx; 
    14481462    pCtx->cr0 = env->cr[0]; 
    14491463    pCtx->cr3 = env->cr[3]; 
     
    14661480    int rc; 
    14671481    PVM pVM = env->pVM; 
     1482    PCPUMCTX pCtx; 
    14681483 
    14691484    /* 
     
    14791494     * as it may need to map whatever cr3 is pointing to. 
    14801495     */ 
    1481     PCPUMCTX pCtx = (PCPUMCTX)pVM->rem.s.pCtx; 
     1496    pCtx = (PCPUMCTX)pVM->rem.s.pCtx; 
    14821497    pCtx->cr0 = env->cr[0]; 
    14831498    pCtx->cr3 = env->cr[3]; 
     
    16281643REMR3DECL(int)  REMR3State(PVM pVM, bool fFlushTBs) 
    16291644{ 
     1645    register const CPUMCTX *pCtx; 
     1646    register unsigned       fFlags; 
     1647    bool                    fHiddenSelRegsValid; 
     1648    unsigned                i; 
     1649    TRPMEVENT               enmType; 
     1650    uint8_t                 u8TrapNo; 
     1651    int                     rc;  
     1652 
    16301653    Log2(("REMR3State:\n")); 
    16311654    STAM_PROFILE_START(&pVM->rem.s.StatsState, a); 
    1632     register const CPUMCTX *pCtx = pVM->rem.s.pCtx; 
    1633     register unsigned       fFlags; 
    1634     bool                    fHiddenSelRegsValid = CPUMAreHiddenSelRegsValid(pVM); 
    1635     unsigned                i; 
     1655          
     1656    pCtx = pVM->rem.s.pCtx; 
     1657    fHiddenSelRegsValid = CPUMAreHiddenSelRegsValid(pVM); 
    16361658 
    16371659    Assert(!pVM->rem.s.fInREM); 
     
    17161738    if (pVM->rem.s.cInvalidatedPages) 
    17171739    { 
     1740        RTUINT i; 
     1741         
    17181742        pVM->rem.s.fIgnoreInvlPg = true; 
    1719         RTUINT i; 
    17201743        for (i = 0; i < pVM->rem.s.cInvalidatedPages; i++) 
    17211744        { 
     
    19761999     */ 
    19772000    pVM->rem.s.Env.exception_index = -1; /** @todo this won't work :/ */ 
    1978     TRPMEVENT   enmType; 
    1979     uint8_t     u8TrapNo; 
    1980     int rc = TRPMQueryTrap(pVM, &u8TrapNo, &enmType); 
     2001    rc = TRPMQueryTrap(pVM, &u8TrapNo, &enmType); 
    19812002    if (VBOX_SUCCESS(rc)) 
    19822003    { 
     
    20762097REMR3DECL(int) REMR3StateBack(PVM pVM) 
    20772098{ 
     2099    register PCPUMCTX pCtx = pVM->rem.s.pCtx; 
     2100    unsigned          i; 
     2101 
    20782102    Log2(("REMR3StateBack:\n")); 
    20792103    Assert(pVM->rem.s.fInREM); 
    20802104    STAM_PROFILE_START(&pVM->rem.s.StatsStateBack, a); 
    2081     register PCPUMCTX pCtx = pVM->rem.s.pCtx; 
    2082     unsigned          i; 
    2083  
    2084     /* 
     2105        /* 
    20852106     * Copy back the registers. 
    20862107     * This is done in the order they are declared in the CPUMCTX structure. 
     
    22692290        &&  pVM->rem.s.Env.exception_index < 256) 
    22702291    { 
     2292        int rc; 
     2293 
    22712294        Log(("REMR3StateBack: Pending trap %x %d\n", pVM->rem.s.Env.exception_index, pVM->rem.s.Env.exception_is_int)); 
    2272         int rc = TRPMAssertTrap(pVM, pVM->rem.s.Env.exception_index, (pVM->rem.s.Env.exception_is_int) ? TRPM_SOFTWARE_INT : TRPM_HARDWARE_INT); 
     2295        rc = TRPMAssertTrap(pVM, pVM->rem.s.Env.exception_index, (pVM->rem.s.Env.exception_is_int) ? TRPM_SOFTWARE_INT : TRPM_HARDWARE_INT); 
    22732296        AssertRC(rc); 
    22742297        switch (pVM->rem.s.Env.exception_index) 
     
    23012324static void remR3StateUpdate(PVM pVM) 
    23022325{ 
    2303     Assert(pVM->rem.s.fInREM); 
    23042326    register PCPUMCTX pCtx = pVM->rem.s.pCtx; 
    23052327    unsigned          i; 
    23062328 
     2329    Assert(pVM->rem.s.fInREM); 
     2330     
    23072331    /* 
    23082332     * Copy back the registers. 
     
    24922516REMR3DECL(void) REMR3A20Set(PVM pVM, bool fEnable) 
    24932517{ 
     2518    bool fSaved; 
     2519 
    24942520    LogFlow(("REMR3A20Set: fEnable=%d\n", fEnable)); 
    24952521    VM_ASSERT_EMT(pVM); 
    24962522 
    2497     bool fSaved = pVM->rem.s.fIgnoreAll; /* just in case. */ 
     2523    fSaved = pVM->rem.s.fIgnoreAll; /* just in case. */ 
    24982524    pVM->rem.s.fIgnoreAll = fSaved || !pVM->rem.s.fInREM; 
    24992525 
     
    25122538REMR3DECL(void) REMR3ReplayInvalidatedPages(PVM pVM) 
    25132539{ 
     2540    RTUINT i; 
     2541     
    25142542    VM_ASSERT_EMT(pVM); 
    25152543 
     
    25262554     */ 
    25272555    pVM->rem.s.fIgnoreInvlPg = true; 
    2528     RTUINT i; 
    25292556    for (i = 0; i < pVM->rem.s.cInvalidatedPages; i++) 
    25302557    { 
     
    25452572REMR3DECL(void) REMR3ReplayHandlerNotifications(PVM pVM) 
    25462573{ 
     2574    /* 
     2575     * Replay the flushes. 
     2576     */ 
     2577    RTUINT i; 
     2578    const RTUINT c = pVM->rem.s.cHandlerNotifications; 
     2579     
    25472580    LogFlow(("REMR3ReplayInvalidatedPages:\n")); 
    25482581    VM_ASSERT_EMT(pVM); 
    25492582 
    2550     /* 
    2551      * Replay the flushes. 
    2552      */ 
    2553     RTUINT i; 
    2554     const RTUINT c = pVM->rem.s.cHandlerNotifications; 
    25552583    pVM->rem.s.cHandlerNotifications = 0; 
    25562584    for (i = 0; i < c; i++) 
     
    27452773    int rc; 
    27462774    PVM pVM = cpu_single_env->pVM; 
     2775    const RTGCPHYS GCPhys = physaddr; 
    27472776 
    27482777    LogFlow(("remR3GrowDynRange %VGp\n", physaddr)); 
    2749     const RTGCPHYS GCPhys = physaddr; 
    27502778    rc = PGM3PhysGrowRange(pVM, &GCPhys); 
    27512779    if (VBOX_SUCCESS(rc)) 
     
    32743302static void     remR3MMIOWriteU8(void *pvVM, target_phys_addr_t GCPhys, uint32_t u32) 
    32753303{ 
     3304    int rc; 
    32763305    Log2(("remR3MMIOWriteU8: GCPhys=%VGp u32=%#x\n", GCPhys, u32)); 
    3277     int rc = IOMMMIOWrite((PVM)pvVM, GCPhys, u32, 1); 
     3306    rc = IOMMMIOWrite((PVM)pvVM, GCPhys, u32, 1); 
    32783307    AssertMsg(rc == VINF_SUCCESS, ("rc=%Vrc\n", rc)); NOREF(rc); 
    32793308} 
     
    32823311static void     remR3MMIOWriteU16(void *pvVM, target_phys_addr_t GCPhys, uint32_t u32) 
    32833312{ 
     3313    int rc; 
    32843314    Log2(("remR3MMIOWriteU16: GCPhys=%VGp u32=%#x\n", GCPhys, u32)); 
    3285     int rc = IOMMMIOWrite((PVM)pvVM, GCPhys, u32, 2); 
     3315    rc = IOMMMIOWrite((PVM)pvVM, GCPhys, u32, 2); 
    32863316    AssertMsg(rc == VINF_SUCCESS, ("rc=%Vrc\n", rc)); NOREF(rc); 
    32873317} 
     
    32903320static void     remR3MMIOWriteU32(void *pvVM, target_phys_addr_t GCPhys, uint32_t u32) 
    32913321{ 
     3322    int rc; 
    32923323    Log2(("remR3MMIOWriteU32: GCPhys=%VGp u32=%#x\n", GCPhys, u32)); 
    3293     int rc = IOMMMIOWrite((PVM)pvVM, GCPhys, u32, 4); 
     3324    rc = IOMMMIOWrite((PVM)pvVM, GCPhys, u32, 4); 
    32943325    AssertMsg(rc == VINF_SUCCESS, ("rc=%Vrc\n", rc)); NOREF(rc); 
    32953326} 
     
    33033334static uint32_t remR3HandlerReadU8(void *pvVM, target_phys_addr_t GCPhys) 
    33043335{ 
     3336    uint8_t u8; 
    33053337    Log2(("remR3HandlerReadU8: GCPhys=%VGp\n", GCPhys)); 
    3306     uint8_t u8; 
    33073338    PGMPhysRead((PVM)pvVM, GCPhys, &u8, sizeof(u8)); 
    33083339    return u8; 
     
    33113342static uint32_t remR3HandlerReadU16(void *pvVM, target_phys_addr_t GCPhys) 
    33123343{ 
     3344    uint16_t u16; 
    33133345    Log2(("remR3HandlerReadU16: GCPhys=%VGp\n", GCPhys)); 
    3314     uint16_t u16; 
    33153346    PGMPhysRead((PVM)pvVM, GCPhys, &u16, sizeof(u16)); 
    33163347    return u16; 
     
    33193350static uint32_t remR3HandlerReadU32(void *pvVM, target_phys_addr_t GCPhys) 
    33203351{ 
     3352    uint32_t u32; 
    33213353    Log2(("remR3HandlerReadU32: GCPhys=%VGp\n", GCPhys)); 
    3322     uint32_t u32; 
    33233354    PGMPhysRead((PVM)pvVM, GCPhys, &u32, sizeof(u32)); 
    33243355    return u32; 
     
    34343465bool remR3DisasBlock(CPUState *env, int f32BitCode, int nrInstructions, char *pszPrefix) 
    34353466{ 
    3436     int i; 
     3467    int           i, rc; 
     3468    RTGCPTR       GCPtrPC; 
     3469    uint8_t       *pvPC; 
     3470    RTINTPTR      off; 
     3471    DISCPUSTATE   Cpu; 
    34373472 
    34383473    /* 
     
    34463481     * We don't care to much about cross page correctness presently. 
    34473482     */ 
    3448     RTGCPTR    GCPtrPC = env->segs[R_CS].base + env->eip; 
    3449     void      *pvPC; 
     3483    GCPtrPC = env->segs[R_CS].base + env->eip; 
    34503484    if (f32BitCode && (env->cr[0] & (X86_CR0_PE | X86_CR0_PG)) == (X86_CR0_PE | X86_CR0_PG)) 
    34513485    { 
     
    34533487 
    34543488        /* convert eip to physical address. */ 
    3455         int rc = PGMPhysGCPtr2HCPtrByGstCR3(env->pVM, 
    3456                                             GCPtrPC, 
    3457                                             env->cr[3], 
    3458                                             env->cr[4] & (X86_CR4_PSE | X86_CR4_PAE), /** @todo add longmode flag */ 
    3459                                             &pvPC); 
     3489        rc = PGMPhysGCPtr2HCPtrByGstCR3(env->pVM, 
     3490                                        GCPtrPC, 
     3491                                        env->cr[3], 
     3492                                        env->cr[4] & (X86_CR4_PSE | X86_CR4_PAE), /** @todo add longmode flag */ 
     3493                                        &pvPC); 
    34603494        if (VBOX_FAILURE(rc)) 
    34613495        { 
     
    34693503    { 
    34703504        /* physical address */ 
    3471         int rc = PGMPhysGCPhys2HCPtr(env->pVM, (RTGCPHYS)GCPtrPC, nrInstructions * 16, &pvPC); 
     3505        rc = PGMPhysGCPhys2HCPtr(env->pVM, (RTGCPHYS)GCPtrPC, nrInstructions * 16, &pvPC); 
    34723506        if (VBOX_FAILURE(rc)) 
    34733507            return false; 
     
    34773511     * Disassemble. 
    34783512     */ 
    3479     RTINTPTR        off = env->eip - (RTGCUINTPTR)pvPC; 
    3480     DISCPUSTATE     Cpu; 
     3513    off = env->eip - (RTGCUINTPTR)pvPC; 
    34813514    Cpu.mode = f32BitCode ? CPUMODE_32BIT : CPUMODE_16BIT; 
    34823515    Cpu.pfnReadBytes = NULL;            /** @todo make cs:eip reader for the disassembler. */ 
     
    35183551{ 
    35193552#ifdef USE_OLD_DUMP_AND_DISASSEMBLY 
    3520     PVM pVM = env->pVM; 
     3553    PVM         pVM =   env->pVM; 
     3554    RTGCPTR     GCPtrPC; 
     3555    uint8_t     *pvPC; 
     3556    char        szOutput[256]; 
     3557    uint32_t    cbOp; 
     3558    RTINTPTR    off; 
     3559    DISCPUSTATE Cpu; 
     3560                          
    35213561 
    35223562    /* Doesn't work in long mode. */ 
     
    35433583     * We don't care to much about cross page correctness presently. 
    35443584     */ 
    3545     RTGCPTR    GCPtrPC = env->segs[R_CS].base + env->eip; 
    3546     void      *pvPC; 
     3585    GCPtrPC = env->segs[R_CS].base + env->eip; 
    35473586    if ((env->cr[0] & (X86_CR0_PE | X86_CR0_PG)) == (X86_CR0_PE | X86_CR0_PG)) 
    35483587    { 
     
    35733612     * Disassemble. 
    35743613     */ 
    3575     RTINTPTR        off = env->eip - (RTGCUINTPTR)pvPC; 
    3576     DISCPUSTATE     Cpu; 
     3614    off = env->eip - (RTGCUINTPTR)pvPC; 
    35773615    Cpu.mode = f32BitCode ? CPUMODE_32BIT : CPUMODE_16BIT; 
    35783616    Cpu.pfnReadBytes = NULL;            /** @todo make cs:eip reader for the disassembler. */ 
     
    35803618    //Cpu.dwUserData[1] = (uintptr_t)pvPC; 
    35813619    //Cpu.dwUserData[2] = GCPtrPC; 
    3582     char szOutput[256]; 
    3583     uint32_t    cbOp; 
    35843620    if (RT_FAILURE(DISInstr(&Cpu, (uintptr_t)pvPC, off, &cbOp, &szOutput[0]))) 
    35853621        return false; 
     
    36913727    { 
    36923728        PVM pVM = cpu_single_env->pVM; 
     3729        RTSEL cs; 
     3730        RTGCUINTPTR eip; 
    36933731 
    36943732        /* 
     
    37013739         */ 
    37023740        RTLogPrintf("Guest Code: PC=%VGp #VGp (%VGp) bytes fFlags=%d\n", uCode, cb, cb, fFlags); 
    3703         RTSEL cs = cpu_single_env->segs[R_CS].selector; 
    3704         RTGCUINTPTR eip = uCode - cpu_single_env->segs[R_CS].base; 
     3741        cs = cpu_single_env->segs[R_CS].selector; 
     3742        eip = uCode - cpu_single_env->segs[R_CS].base; 
    37053743        for (;;) 
    37063744        { 
     
    41204158void cpu_outb(CPUState *env, int addr, int val) 
    41214159{ 
     4160    int rc; 
     4161 
    41224162    if (addr != 0x80 && addr != 0x70 && addr != 0x61) 
    41234163        Log2(("cpu_outb: addr=%#06x val=%#x\n", addr, val)); 
    41244164 
    4125     int rc = IOMIOPortWrite(env->pVM, (RTIOPORT)addr, val, 1); 
     4165    rc = IOMIOPortWrite(env->pVM, (RTIOPORT)addr, val, 1); 
    41264166    if (RT_LIKELY(rc == VINF_SUCCESS)) 
    41274167        return; 
     
    41524192void cpu_outl(CPUState *env, int addr, int val) 
    41534193{ 
     4194    int rc; 
    41544195    Log2(("cpu_outl: addr=%#06x val=%#x\n", addr, val)); 
    4155     int rc = IOMIOPortWrite(env->pVM, (RTIOPORT)addr, val, 4); 
     4196    rc = IOMIOPortWrite(env->pVM, (RTIOPORT)addr, val, 4); 
    41564197    if (RT_LIKELY(rc == VINF_SUCCESS)) 
    41574198        return; 
     
    42864327void cpu_abort(CPUState *env, const char *pszFormat, ...) 
    42874328{ 
     4329    va_list args; 
     4330    PVM pVM; 
     4331     
    42884332    /* 
    42894333     * Bitch about it. 
    42904334     */ 
     4335#ifndef _MSC_VER 
     4336    /** @todo: MSVC is right - it's not valid C */ 
    42914337    RTLogFlags(NULL, "nodisabled nobuffered"); 
    4292     va_list args; 
     4338#endif 
    42934339    va_start(args, pszFormat); 
    42944340    RTLogPrintf("fatal error in recompiler cpu: %N\n", pszFormat, &args); 
     
    43024348     * the EMs failure handling. 
    43034349     */ 
    4304     PVM pVM = cpu_single_env->pVM; 
     4350    pVM = cpu_single_env->pVM; 
    43054351    if (pVM->rem.s.fInREM) 
    43064352        REMR3StateBack(pVM); 
     
    43184364static void remAbort(int rc, const char *pszTip) 
    43194365{ 
     4366    PVM pVM; 
     4367 
    43204368    /* 
    43214369     * Bitch about it. 
     
    43274375     * Jump back to where we entered the recompiler. 
    43284376     */ 
    4329     PVM pVM = cpu_single_env->pVM; 
     4377    pVM = cpu_single_env->pVM; 
    43304378    if (pVM->rem.s.fInREM) 
    43314379        REMR3StateBack(pVM); 
  • trunk/src/recompiler_new/bswap.h

    r2422 r13382  
    7979 
    8080#ifndef bswap16 /* BSD endian.h clash */ 
     81#ifndef VBOX 
    8182static inline uint16_t bswap16(uint16_t x) 
     83#else 
     84DECLINLINE(uint16_t) bswap16(uint16_t x) 
     85#endif 
    8286{ 
    8387    return bswap_16(x); 
     
    8690 
    8791#ifndef bswap32 /* BSD endian.h clash */ 
     92#ifndef VBOX 
    8893static inline uint32_t bswap32(uint32_t x) 
     94#else 
     95DECLINLINE(uint32_t) bswap32(uint32_t x) 
     96#endif 
    8997{ 
    9098    return bswap_32(x); 
     
    93101 
    94102#ifndef bswap64 /* BSD endian.h clash. */ 
     103#ifndef VBOX 
    95104static inline uint64_t bswap64(uint64_t x) 
     105#else 
     106DECLINLINE(uint64_t) bswap64(uint64_t x) 
     107#endif 
    96108{ 
    97109    return bswap_64(x); 
     
    99111#endif 
    100112 
     113#ifndef VBOX 
    101114static inline void bswap16s(uint16_t *s) 
     115#else 
     116DECLINLINE(void) bswap16s(uint16_t *s) 
     117#endif 
    102118{ 
    103119    *s = bswap16(*s); 
    104120} 
    105121 
     122#ifndef VBOX 
    106123static inline void bswap32s(uint32_t *s) 
     124#else 
     125DECLINLINE(void) bswap32s(uint32_t *s) 
     126#endif 
    107127{ 
    108128    *s = bswap32(*s); 
    109129} 
    110130 
     131#ifndef VBOX 
    111132static inline void bswap64s(uint64_t *s) 
     133#else 
     134DECLINLINE(void) bswap64s(uint64_t *s) 
     135#endif 
    112136{ 
    113137    *s = bswap64(*s); 
     
    126150#endif 
    127151 
     152#ifndef VBOX 
    128153#define CPU_CONVERT(endian, size, type)\ 
    129154static inline type endian ## size ## _to_cpu(type v)\ 
     
    156181     *p = cpu_to_ ## endian ## size(v);\ 
    157182} 
     183#else  /* VBOX */ 
     184#define CPU_CONVERT(endian, size, type)\ 
     185DECLINLINE(type) endian ## size ## _to_cpu(type v)\ 
     186{\ 
     187    return endian ## _bswap(v, size);\ 
     188}\ 
     189\ 
     190DECLINLINE(type) cpu_to_ ## endian ## size(type v)\ 
     191{\ 
     192    return endian ## _bswap(v, size);\ 
     193}\ 
     194\ 
     195DECLINLINE(void) endian ## size ## _to_cpus(type *p)\ 
     196{\ 
     197    endian ## _bswaps(p, size)\ 
     198}\ 
     199\ 
     200DECLINLINE(void) cpu_to_ ## endian ## size ## s(type *p)\ 
     201{\ 
     202    endian ## _bswaps(p, size)\ 
     203}\ 
     204\ 
     205DECLINLINE(type) endian ## size ## _to_cpup(const type *p)\ 
     206{\ 
     207    return endian ## size ## _to_cpu(*p);\ 
     208}\ 
     209\ 
     210DECLINLINE(void) cpu_to_ ## endian ## size ## w(type *p, type v)\ 
     211{\ 
     212     *p = cpu_to_ ## endian ## size(v);\ 
     213} 
     214#endif /* VBOX */ 
    158215 
    159216CPU_CONVERT(be, 16, uint16_t) 
  • trunk/src/recompiler_new/cpu-all.h

    r13230 r13382  
    3232#ifdef VBOX 
    3333# ifndef LOG_GROUP 
    34 #  include <VBox/log.h> 
    3534#  define LOG_GROUP LOG_GROUP_REM 
    3635# endif 
     36# include <VBox/log.h> 
    3737# include <VBox/pgm.h> /* PGM_DYNAMIC_RAM_ALLOC */ 
    3838#endif 
     
    9595#else 
    9696 
     97#ifndef VBOX 
    9798static inline uint16_t tswap16(uint16_t s) 
     99#else 
     100DECLINLINE(uint16_t) tswap16(uint16_t s) 
     101#endif 
    98102{ 
    99103    return s; 
    100104} 
    101105 
     106#ifndef VBOX 
    102107static inline uint32_t tswap32(uint32_t s) 
     108#else 
     109DECLINLINE(uint32_t) tswap32(uint32_t s) 
     110#endif 
    103111{ 
    104112    return s; 
    105113} 
    106114 
     115#ifndef VBOX 
    107116static inline uint64_t tswap64(uint64_t s) 
     117#else 
     118DECLINLINE(uint64_t) tswap64(uint64_t s) 
     119#endif 
    108120{ 
    109121    return s; 
    110122} 
    111123 
     124#ifndef VBOX 
    112125static inline void tswap16s(uint16_t *s) 
    113 
    114 
    115  
     126#else 
     127DECLINLINE(void) tswap16s(uint16_t *s) 
     128#endif 
     129
     130
     131 
     132#ifndef VBOX 
    116133static inline void tswap32s(uint32_t *s) 
    117 
    118 
    119  
     134#else 
     135DECLINLINE(void) tswap32s(uint32_t *s) 
     136#endif 
     137
     138
     139 
     140#ifndef VBOX 
    120141static inline void tswap64s(uint64_t *s) 
     142#else 
     143DECLINLINE(void) tswap64s(uint64_t *s) 
     144#endif 
    121145{ 
    122146} 
     
    249273#endif 
    250274 
    251 static inline int ldub_p(void *ptr) 
     275DECLINLINE(int) ldub_p(void *ptr) 
    252276{ 
    253277    VBOX_CHECK_ADDR(ptr); 
     
    255279} 
    256280 
    257 static inline int ldsb_p(void *ptr) 
     281DECLINLINE(int) ldsb_p(void *ptr) 
    258282{ 
    259283    VBOX_CHECK_ADDR(ptr); 
     
    261285} 
    262286 
    263 static inline void stb_p(void *ptr, int v) 
     287DECLINLINE(void) stb_p(void *ptr, int v) 
    264288{ 
    265289    VBOX_CHECK_ADDR(ptr); 
     
    267291} 
    268292 
    269 static inline int lduw_le_p(void *ptr) 
     293DECLINLINE(int) lduw_le_p(void *ptr) 
    270294{ 
    271295    VBOX_CHECK_ADDR(ptr); 
     
    273297} 
    274298 
    275 static inline int ldsw_le_p(void *ptr) 
     299DECLINLINE(int) ldsw_le_p(void *ptr) 
    276300{ 
    277301    VBOX_CHECK_ADDR(ptr); 
     
    279303} 
    280304 
    281 static inline void stw_le_p(void *ptr, int v) 
     305DECLINLINE(void) stw_le_p(void *ptr, int v) 
    282306{ 
    283307    VBOX_CHECK_ADDR(ptr); 
     
    285309} 
    286310 
    287 static inline int ldl_le_p(void *ptr) 
     311DECLINLINE(int) ldl_le_p(void *ptr) 
    288312{ 
    289313    VBOX_CHECK_ADDR(ptr); 
     
    291315} 
    292316 
    293 static inline void stl_le_p(void *ptr, int v) 
     317DECLINLINE(void) stl_le_p(void *ptr, int v) 
    294318{ 
    295319    VBOX_CHECK_ADDR(ptr); 
     
    297321} 
    298322 
    299 static inline void stq_le_p(void *ptr, uint64_t v) 
     323DECLINLINE(void) stq_le_p(void *ptr, uint64_t v) 
    300324{ 
    301325    VBOX_CHECK_ADDR(ptr); 
     
    303327} 
    304328 
    305 static inline uint64_t ldq_le_p(void *ptr) 
     329DECLINLINE(uint64_t) ldq_le_p(void *ptr) 
    306330{ 
    307331    VBOX_CHECK_ADDR(ptr); 
     
    313337/* float access */ 
    314338 
    315 static inline float32 ldfl_le_p(void *ptr) 
     339DECLINLINE(float32) ldfl_le_p(void *ptr) 
    316340{ 
    317341    union { 
     
    323347} 
    324348 
    325 static inline void stfl_le_p(void *ptr, float32 v) 
     349DECLINLINE(void) stfl_le_p(void *ptr, float32 v) 
    326350{ 
    327351    union { 
     
    333357} 
    334358 
    335 static inline float64 ldfq_le_p(void *ptr) 
     359DECLINLINE(float64) ldfq_le_p(void *ptr) 
    336360{ 
    337361    CPU_DoubleU u; 
    338362    u.l.lower = ldl_le_p(ptr); 
    339     u.l.upper = ldl_le_p(ptr + 4); 
     363    u.l.upper = ldl_le_p((uint8_t*)ptr + 4); 
    340364    return u.d; 
    341365} 
    342366 
    343 static inline void stfq_le_p(void *ptr, float64 v) 
     367DECLINLINE(void) stfq_le_p(void *ptr, float64 v) 
    344368{ 
    345369    CPU_DoubleU u; 
    346370    u.d = v; 
    347371    stl_le_p(ptr, u.l.lower); 
    348     stl_le_p(ptr + 4, u.l.upper); 
     372    stl_le_p((uint8_t*)ptr + 4, u.l.upper); 
    349373} 
    350374 
     
    549573#if !defined(WORDS_BIGENDIAN) || defined(WORDS_ALIGNED) 
    550574 
     575#ifndef VBOX 
    551576static inline int lduw_be_p(void *ptr) 
    552577{ 
     
    563588#endif 
    564589} 
    565  
     590#else /* VBOX */ 
     591DECLINLINE(int) lduw_be_p(void *ptr) 
     592
     593#if defined(__i386__) && !defined(_MSC_VER) 
     594    int val; 
     595    asm volatile ("movzwl %1, %0\n" 
     596                  "xchgb %b0, %h0\n" 
     597                  : "=q" (val) 
     598                  : "m" (*(uint16_t *)ptr)); 
     599    return val; 
     600#else 
     601    uint8_t *b = (uint8_t *) ptr; 
     602    return ((b[0] << 8) | b[1]); 
     603#endif 
     604
     605#endif 
     606 
     607#ifndef VBOX 
    566608static inline int ldsw_be_p(void *ptr) 
    567609{ 
     
    578620#endif 
    579621} 
    580  
     622#else 
     623DECLINLINE(int) ldsw_be_p(void *ptr) 
     624
     625#if defined(__i386__) && !defined(_MSC_VER) 
     626    int val; 
     627    asm volatile ("movzwl %1, %0\n" 
     628                  "xchgb %b0, %h0\n" 
     629                  : "=q" (val) 
     630                  : "m" (*(uint16_t *)ptr)); 
     631    return (int16_t)val; 
     632#else 
     633    uint8_t *b = (uint8_t *) ptr; 
     634    return (int16_t)((b[0] << 8) | b[1]); 
     635#endif 
     636
     637#endif 
     638 
     639#ifndef VBOX 
    581640static inline int ldl_be_p(void *ptr) 
    582641{ 
     
    593652#endif 
    594653} 
    595  
     654#else 
     655DECLINLINE(int) ldl_be_p(void *ptr) 
     656
     657#if (defined(__i386__) || defined(__x86_64__)) && !defined(_MSC_VER) 
     658    int val; 
     659    asm volatile ("movl %1, %0\n" 
     660                  "bswap %0\n" 
     661                  : "=r" (val) 
     662                  : "m" (*(uint32_t *)ptr)); 
     663    return val; 
     664#else 
     665    uint8_t *b = (uint8_t *) ptr; 
     666    return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]; 
     667#endif 
     668
     669#endif 
     670 
     671#ifndef VBOX 
    596672static inline uint64_t ldq_be_p(void *ptr) 
     673#else 
     674DECLINLINE(uint64_t) ldq_be_p(void *ptr) 
     675#endif 
    597676{ 
    598677    uint32_t a,b; 
    599678    a = ldl_be_p(ptr); 
    600     b = ldl_be_p(ptr+4); 
     679    b = ldl_be_p((uint8_t*)ptr+4); 
    601680    return (((uint64_t)a<<32)|b); 
    602681} 
    603682 
     683#ifndef VBOX 
    604684static inline void stw_be_p(void *ptr, int v) 
    605685{ 
     
    615695#endif 
    616696} 
    617  
     697#else 
     698DECLINLINE(void) stw_be_p(void *ptr, int v) 
     699
     700#if defined(__i386__) && !defined(_MSC_VER) 
     701    asm volatile ("xchgb %b0, %h0\n" 
     702                  "movw %w0, %1\n" 
     703                  : "=q" (v) 
     704                  : "m" (*(uint16_t *)ptr), "0" (v)); 
     705#else 
     706    uint8_t *d = (uint8_t *) ptr; 
     707    d[0] = v >> 8; 
     708    d[1] = v; 
     709#endif 
     710
     711 
     712#endif /* VBOX */ 
     713 
     714#ifndef VBOX 
    618715static inline void stl_be_p(void *ptr, int v) 
    619716{ 
     
    631728#endif 
    632729} 
    633  
     730#else 
     731DECLINLINE(void) stl_be_p(void *ptr, int v) 
     732
     733#if !defined(_MSC_VER) && (defined(__i386__) || defined(__x86_64__)) 
     734    asm volatile ("bswap %0\n" 
     735                  "movl %0, %1\n" 
     736                  : "=r" (v) 
     737                  : "m" (*(uint32_t *)ptr), "0" (v)); 
     738#else 
     739    uint8_t *d = (uint8_t *) ptr; 
     740    d[0] = v >> 24; 
     741    d[1] = v >> 16; 
     742    d[2] = v >> 8; 
     743    d[3] = v; 
     744#endif 
     745
     746#endif /* VBOX */ 
     747 
     748#ifndef VBOX 
    634749static inline void stq_be_p(void *ptr, uint64_t v) 
     750#else 
     751DECLINLINE(void) stq_be_p(void *ptr, uint64_t v) 
     752#endif 
    635753{ 
    636754    stl_be_p(ptr, v >> 32); 
    637     stl_be_p(ptr + 4, v); 
     755    stl_be_p((uint8_t*)ptr + 4, v); 
    638756} 
    639757 
    640758/* float access */ 
    641  
     759#ifndef VBOX 
    642760static inline float32 ldfl_be_p(void *ptr) 
     761#else 
     762DECLINLINE(float32) ldfl_be_p(void *ptr) 
     763#endif 
    643764{ 
    644765    union { 
     
    650771} 
    651772 
     773#ifndef VBOX 
    652774static inline void stfl_be_p(void *ptr, float32 v) 
     775#else 
     776DECLINLINE(void) stfl_be_p(void *ptr, float32 v) 
     777#endif 
    653778{ 
    654779    union { 
     
    660785} 
    661786 
     787#ifndef VBOX 
    662788static inline float64 ldfq_be_p(void *ptr) 
     789#else 
     790DECLINLINE(float64) ldfq_be_p(void *ptr) 
     791#endif 
    663792{ 
    664793    CPU_DoubleU u; 
    665794    u.l.upper = ldl_be_p(ptr); 
    666     u.l.lower = ldl_be_p(ptr + 4); 
     795    u.l.lower = ldl_be_p((uint8_t*)ptr + 4); 
    667796    return u.d; 
    668797} 
    669798 
     799#ifndef VBOX 
    670800static inline void stfq_be_p(void *ptr, float64 v) 
     801#else 
     802DECLINLINE(void) stfq_be_p(void *ptr, float64 v) 
     803#endif 
    671804{ 
    672805    CPU_DoubleU u; 
    673806    u.d = v; 
    674807    stl_be_p(ptr, u.l.upper); 
    675     stl_be_p(ptr + 4, u.l.lower); 
     808    stl_be_p((uint8_t*)ptr + 4, u.l.lower); 
    676809} 
    677810 
     
    11031236void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf, 
    11041237                            int len, int is_write); 
     1238#ifndef VBOX 
    11051239static inline void cpu_physical_memory_read(target_phys_addr_t addr, 
    11061240                                            uint8_t *buf, int len) 
     1241#else 
     1242DECLINLINE(void) cpu_physical_memory_read(target_phys_addr_t addr, 
     1243                                          uint8_t *buf, int len) 
     1244#endif 
    11071245{ 
    11081246    cpu_physical_memory_rw(addr, bu