VirtualBox

Changeset 13731 in vbox


Ignore:
Timestamp:
Nov 1, 2008 7:39:12 PM (16 years ago)
Author:
vboxsync
Message:

more cleanup, 32-bit mode still doesn't work.
Very hard to tell why.

Location:
trunk/src/recompiler_new
Files:
2 deleted
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/recompiler_new/Sun/config-host.h

    r8168 r13731  
    2121
    2222
    23 #if defined(RT_ARCH_AMD64) || defined(HOST_X86_64) /* The latter, for dyngen when cross compiling (windows, l4, etc). */
     23#if defined(RT_ARCH_AMD64)
    2424# define HOST_X86_64 1
    2525# define HOST_LONG_BITS 64

  • trunk/src/recompiler_new/VBoxRecompiler.c

    r13716 r13731  
    30803080    VBOX_CHECK_ADDR(SrcGCPhys);
    30813081    PGMPhysRead(cpu_single_env->pVM, SrcGCPhys, pvDst, cb);
     3082#ifdef DEBUG_PHYS
     3083    LogRel(("read(%d): %p\n", cb, SrcGCPhys));
     3084#endif
    30823085    STAM_PROFILE_ADV_STOP(&gStatMemRead, a);
    30833086}
    … …  
    30943097    STAM_PROFILE_ADV_START(&gStatMemRead, a);
    30953098    VBOX_CHECK_ADDR(SrcGCPhys);
    3096     val = PGMR3PhysReadU8(cpu_single_env->pVM, SrcGCPhys);
     3099    val = PGMR3PhysReadU8(cpu_single_env->pVM, SrcGCPhys);   
    30973100    STAM_PROFILE_ADV_STOP(&gStatMemRead, a);
     3101#ifdef DEBUG_PHYS
     3102    LogRel(("readu8: %x <- %p\n", val, SrcGCPhys));
     3103#endif
    30983104    return val;
    30993105}
    … …  
    31123118    val = PGMR3PhysReadU8(cpu_single_env->pVM, SrcGCPhys);
    31133119    STAM_PROFILE_ADV_STOP(&gStatMemRead, a);
     3120#ifdef DEBUG_PHYS
     3121    LogRel(("reads8: %x <- %p\n", val, SrcGCPhys));
     3122#endif
    31143123    return val;
    31153124}
    … …  
    31283137    val = PGMR3PhysReadU16(cpu_single_env->pVM, SrcGCPhys);
    31293138    STAM_PROFILE_ADV_STOP(&gStatMemRead, a);
     3139#ifdef DEBUG_PHYS
     3140    LogRel(("readu16: %x <- %p\n", val, SrcGCPhys));
     3141#endif
    31303142    return val;
    31313143}
    … …  
    31443156    val = PGMR3PhysReadU16(cpu_single_env->pVM, SrcGCPhys);
    31453157    STAM_PROFILE_ADV_STOP(&gStatMemRead, a);
     3158#ifdef DEBUG_PHYS
     3159    LogRel(("reads16: %x <- %p\n", val, SrcGCPhys));
     3160#endif
    31463161    return val;
    31473162}
    … …  
    31603175    val = PGMR3PhysReadU32(cpu_single_env->pVM, SrcGCPhys);
    31613176    STAM_PROFILE_ADV_STOP(&gStatMemRead, a);
     3177#ifdef DEBUG_PHYS
     3178    LogRel(("readu32: %x <- %p\n", val, SrcGCPhys));
     3179#endif
    31623180    return val;
    31633181}
    … …  
    31763194    val = PGMR3PhysReadU32(cpu_single_env->pVM, SrcGCPhys);
    31773195    STAM_PROFILE_ADV_STOP(&gStatMemRead, a);
     3196#ifdef DEBUG_PHYS
     3197    LogRel(("reads32: %x <- %p\n", val, SrcGCPhys));
     3198#endif
    31783199    return val;
    31793200}
    … …  
    32243245    PGMPhysWrite(cpu_single_env->pVM, DstGCPhys, pvSrc, cb);
    32253246    STAM_PROFILE_ADV_STOP(&gStatMemWrite, a);
     3247    LogRel(("write(%d): %p\n", cb, DstGCPhys));
    32263248}
    32273249
    … …  
    32393261    PGMR3PhysWriteU8(cpu_single_env->pVM, DstGCPhys, val);
    32403262    STAM_PROFILE_ADV_STOP(&gStatMemWrite, a);
     3263    LogRel(("writeu8: %x -> %p\n", val, DstGCPhys));
    32413264}
    32423265
    … …  
    32543277    PGMR3PhysWriteU16(cpu_single_env->pVM, DstGCPhys, val);
    32553278    STAM_PROFILE_ADV_STOP(&gStatMemWrite, a);
     3279    LogRel(("writeu16: %x -> %p\n", val, DstGCPhys));
    32563280}
    32573281
    … …  
    32693293    PGMR3PhysWriteU32(cpu_single_env->pVM, DstGCPhys, val);
    32703294    STAM_PROFILE_ADV_STOP(&gStatMemWrite, a);
     3295    LogRel(("writeu32: %x -> %p\n", val, DstGCPhys));
    32713296}
    32723297

  • trunk/src/recompiler_new/dyngen-exec.h

    r13726 r13731  
    277277#endif
    278278
    279 #ifdef __i386__
    280 #define EXIT_TB() asm volatile ("ret")
    281 #define GOTO_LABEL_PARAM(n) asm volatile ("jmp " ASM_NAME(__op_gen_label) #n)
    282 #endif
    283 #ifdef __x86_64__
    284 #define EXIT_TB() asm volatile ("ret")
    285 #define GOTO_LABEL_PARAM(n) asm volatile ("jmp " ASM_NAME(__op_gen_label) #n)
    286 #endif
    287 #ifdef __powerpc__
    288 #define EXIT_TB() asm volatile ("blr")
    289 #define GOTO_LABEL_PARAM(n) asm volatile ("b " ASM_NAME(__op_gen_label) #n)
    290 #endif
    291 #ifdef __s390__
    292 #define EXIT_TB() asm volatile ("br %r14")
    293 #define GOTO_LABEL_PARAM(n) asm volatile ("b " ASM_NAME(__op_gen_label) #n)
    294 #endif
    295 #ifdef __alpha__
    296 #define EXIT_TB() asm volatile ("ret")
    297 #endif
    298 #ifdef __ia64__
    299 #define EXIT_TB() asm volatile ("br.ret.sptk.many b0;;")
    300 #define GOTO_LABEL_PARAM(n) asm volatile ("br.sptk.many " \
    301                                           ASM_NAME(__op_gen_label) #n)
    302 #endif
    303 #ifdef __sparc__
    304 #define EXIT_TB() asm volatile ("jmpl %i0 + 8, %g0; nop")
    305 #define GOTO_LABEL_PARAM(n) asm volatile ("ba " ASM_NAME(__op_gen_label) #n ";nop")
    306 #endif
    307 #ifdef __arm__
    308 #define EXIT_TB() asm volatile ("b exec_loop")
    309 #define GOTO_LABEL_PARAM(n) asm volatile ("b " ASM_NAME(__op_gen_label) #n)
    310 #endif
    311 #ifdef __mc68000
    312 #define EXIT_TB() asm volatile ("rts")
    313 #endif
    314 
    315 
    316279#ifdef VBOX
    317280#define GETPC() ASMReturnAddress()

  • trunk/src/recompiler_new/exec-all.h

    r13382 r13731  
    348348#if !defined(CONFIG_USER_ONLY)
    349349
    350 void tlb_fill(target_ulong addr, int is_write, int is_user,
     350void tlb_fill(target_ulong addr, int is_write, int mmu_idx,
    351351              void *retaddr);
    352352
    … …  
    391391   is the offset relative to phys_ram_base */
    392392#ifndef VBOX
    393 static inline target_ulong get_phys_addr_code(CPUState *env, target_ulong addr)
    394 #else
    395 DECLINLINE(target_ulong) get_phys_addr_code(CPUState *env, target_ulong addr)
    396 #endif
    397 {
    398     int is_user, index, pd;
    399 
    400     index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
    401 #if defined(TARGET_I386)
    402     is_user = ((env->hflags & HF_CPL_MASK) == 3);
    403 #elif defined (TARGET_PPC)
    404     is_user = msr_pr;
    405 #elif defined (TARGET_MIPS)
    406     is_user = ((env->hflags & MIPS_HFLAG_MODE) == MIPS_HFLAG_UM);
    407 #elif defined (TARGET_SPARC)
    408     is_user = (env->psrs == 0);
    409 #elif defined (TARGET_ARM)
    410     is_user = ((env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_USR);
    411 #elif defined (TARGET_SH4)
    412     is_user = ((env->sr & SR_MD) == 0);
    413 #else
    414 #error unimplemented CPU
    415 #endif
    416 #ifndef VBOX
    417     if (__builtin_expect(env->tlb_table[is_user][index].addr_code !=
    418                          (addr & TARGET_PAGE_MASK), 0)) {
    419 #else
    420     if (RT_UNLIKELY(env->tlb_table[is_user][index].addr_code !=
    421                          (addr & TARGET_PAGE_MASK))) {
    422 #endif
     393static inline target_ulong get_phys_addr_code(CPUState *env1, target_ulong addr)
     394#else
     395DECLINLINE(target_ulong) get_phys_addr_code(CPUState *env1, target_ulong addr)
     396#endif
     397{
     398    int mmu_idx, page_index, pd;
     399
     400    page_index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
     401    mmu_idx = cpu_mmu_index(env1);
     402    if (unlikely(env1->tlb_table[mmu_idx][page_index].addr_code !=
     403                 (addr & TARGET_PAGE_MASK))) {
    423404        ldub_code(addr);
    424405    }
    425     pd = env->tlb_table[is_user][index].addr_code & ~TARGET_PAGE_MASK;
     406    pd = env1->tlb_table[mmu_idx][page_index].addr_code & ~TARGET_PAGE_MASK;
    426407    if (pd > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) {
    427408# ifdef VBOX
    428409        /* deal with non-MMIO access handlers. */
    429         return remR3PhysGetPhysicalAddressCode(env, addr, &env->tlb_table[is_user][index]);
     410        return remR3PhysGetPhysicalAddressCode(env1, addr, &env1->tlb_table[mmu_idx][page_index]);
     411# elif defined(TARGET_SPARC) || defined(TARGET_MIPS)
     412        do_unassigned_access(addr, 0, 1, 0, 4);
     413#else
     414        cpu_abort(env1, "Trying to execute code outside RAM or ROM at 0x" TARGET_FMT_lx "\n", addr);
     415#endif
     416    }
     417
     418# if defined(VBOX) && defined(REM_PHYS_ADDR_IN_TLB)
     419    return addr + env1->tlb_table[mmu_idx][page_index].addend;
     420# elif defined(VBOX)
     421    return remR3HCVirt2GCPhys(env, (void *)(addr + env1->tlb_table[mmu_idx][page_index].addend));
    430422# else
    431         cpu_abort(env, "Trying to execute code outside RAM or ROM at 0x%08lx\n", addr);
    432 # endif
    433     }
    434 # if defined(VBOX) && defined(REM_PHYS_ADDR_IN_TLB)
    435     return addr + env->tlb_table[is_user][index].addend;
    436 # elif defined(VBOX)
    437     return remR3HCVirt2GCPhys(env, (void *)(addr + env->tlb_table[is_user][index].addend));
    438 # else
    439     return addr + env->tlb_table[is_user][index].addend - (unsigned long)phys_ram_base;
     423    return addr + env1->tlb_table[mmu_idx][page_index].addend - (unsigned long)phys_ram_base;
    440424# endif
    441425}

  • trunk/src/recompiler_new/exec.c

    r13652 r13731  
    22992299int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
    23002300                      target_phys_addr_t paddr, int prot,
    2301                       int is_user, int is_softmmu)
     2301                      int mmu_idx, int is_softmmu)
    23022302{
    23032303    return 0;

  • trunk/src/recompiler_new/osdep.h

    r13384 r13731  
    3030# define NULL 0
    3131#endif
     32
     33#define fflush(file)            RTLogFlush(NULL)
     34#define printf(...)             LogIt(LOG_INSTANCE, 0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
     35#define fprintf(logfile, ...)   LogIt(LOG_INSTANCE, 0, LOG_GROUP_REM_PRINTF, (__VA_ARGS__))
     36
    3237
    3338#else /* !VBOX */

  • trunk/src/recompiler_new/softmmu_header.h

    r13382 r13731  
    8181
    8282#if (DATA_SIZE <= 4) && (TARGET_LONG_BITS == 32) && defined(__i386__) && \
    83     (ACCESS_TYPE < NB_MMU_MODES) && defined(ASM_SOFTMMU)
    84 
    85 #ifdef VBOX
    86 /* generic store macro */
    87 
    88 DELCINLINE(void) glue(glue(st, SUFFIX), MEMSUFFIX)(target_ulong ptr, RES_TYPE v)
    89 {
    90     int index;
    91     target_ulong addr;
    92     unsigned long physaddr;
    93     int is_user;
    94 
    95     addr = ptr;
    96     index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
    97     is_user = CPU_MMU_INDEX;
    98     if (__builtin_expect(env->tlb_table[is_user][index].addr_write !=
    99                          (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))), 0)) {
    100         glue(glue(__st, SUFFIX), MMUSUFFIX)(addr, v, is_user);
    101     } else {
    102         physaddr = addr + env->tlb_table[is_user][index].addend;
    103         glue(glue(st, SUFFIX), _raw)((uint8_t *)physaddr, v);
    104     }
    105 }
    106 
    107 #else /* !VBOX */
     83    (ACCESS_TYPE < NB_MMU_MODES) && defined(ASM_SOFTMMU) && !defined(VBOX)
     84
     85static inline RES_TYPE glue(glue(ld, USUFFIX), MEMSUFFIX)(target_ulong ptr)
     86{
     87    int res;
     88
     89    asm volatile ("movl %1, %%edx\n"
     90                  "movl %1, %%eax\n"
     91                  "shrl %3, %%edx\n"
     92                  "andl %4, %%eax\n"
     93                  "andl %2, %%edx\n"
     94                  "leal %5(%%edx, %%ebp), %%edx\n"
     95                  "cmpl (%%edx), %%eax\n"
     96                  "movl %1, %%eax\n"
     97                  "je 1f\n"
     98                  "movl %6, %%edx\n"
     99                  "call %7\n"
     100                  "movl %%eax, %0\n"
     101                  "jmp 2f\n"
     102                  "1:\n"
     103                  "addl 12(%%edx), %%eax\n"
     104#if DATA_SIZE == 1
     105                  "movzbl (%%eax), %0\n"
     106#elif DATA_SIZE == 2
     107                  "movzwl (%%eax), %0\n"
     108#elif DATA_SIZE == 4
     109                  "movl (%%eax), %0\n"
     110#else
     111#error unsupported size
     112#endif
     113                  "2:\n"
     114                  : "=r" (res)
     115                  : "r" (ptr),
     116                  "i" ((CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS),
     117                  "i" (TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS),
     118                  "i" (TARGET_PAGE_MASK | (DATA_SIZE - 1)),
     119                  "m" (*(uint32_t *)offsetof(CPUState, tlb_table[CPU_MMU_INDEX][0].addr_read)),
     120                  "i" (CPU_MMU_INDEX),
     121                  "m" (*(uint8_t *)&glue(glue(__ld, SUFFIX), MMUSUFFIX))
     122                  : "%eax", "%ecx", "%edx", "memory", "cc");
     123    return res;
     124}
     125
     126#if DATA_SIZE <= 2
     127static inline int glue(glue(lds, SUFFIX), MEMSUFFIX)(target_ulong ptr)
     128{
     129    int res;
     130
     131    asm volatile ("movl %1, %%edx\n"
     132                  "movl %1, %%eax\n"
     133                  "shrl %3, %%edx\n"
     134                  "andl %4, %%eax\n"
     135                  "andl %2, %%edx\n"
     136                  "leal %5(%%edx, %%ebp), %%edx\n"
     137                  "cmpl (%%edx), %%eax\n"
     138                  "movl %1, %%eax\n"
     139                  "je 1f\n"
     140                  "movl %6, %%edx\n"
     141                  "call %7\n"
     142#if DATA_SIZE == 1
     143                  "movsbl %%al, %0\n"
     144#elif DATA_SIZE == 2
     145                  "movswl %%ax, %0\n"
     146#else
     147#error unsupported size
     148#endif
     149                  "jmp 2f\n"
     150                  "1:\n"
     151                  "addl 12(%%edx), %%eax\n"
     152#if DATA_SIZE == 1
     153                  "movsbl (%%eax), %0\n"
     154#elif DATA_SIZE == 2
     155                  "movswl (%%eax), %0\n"
     156#else
     157#error unsupported size
     158#endif
     159                  "2:\n"
     160                  : "=r" (res)
     161                  : "r" (ptr),
     162                  "i" ((CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS),
     163                  "i" (TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS),
     164                  "i" (TARGET_PAGE_MASK | (DATA_SIZE - 1)),
     165                  "m" (*(uint32_t *)offsetof(CPUState, tlb_table[CPU_MMU_INDEX][0].addr_read)),
     166                  "i" (CPU_MMU_INDEX),
     167                  "m" (*(uint8_t *)&glue(glue(__ld, SUFFIX), MMUSUFFIX))
     168                  : "%eax", "%ecx", "%edx", "memory", "cc");
     169    return res;
     170}
     171#endif
    108172
    109173static inline void glue(glue(st, SUFFIX), MEMSUFFIX)(target_ulong ptr, RES_TYPE v)
    … …  
    127191#error unsupported size
    128192#endif
    129                   "pushl %6\n"
     193                  "movl %6, %%ecx\n"
    130194                  "call %7\n"
    131                   "popl %%eax\n"
    132195                  "jmp 2f\n"
    133196                  "1:\n"
    … …  
    143206#endif
    144207                  "2:\n"
    145                   :
    146                   : "r" (ptr),
    147 /* NOTE: 'q' would be needed as constraint, but we could not use it
    148    with T1 ! */
    149                   "r" (v),
    150                   "i" ((CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS),
    151                   "i" (TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS),
     208                  :
     209                  : "r" (ptr),
     210#if DATA_SIZE == 1
     211                  "q" (v),
     212#else
     213                  "r" (v),
     214#endif
     215                  "i" ((CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS),
     216                  "i" (TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS),
    152217                  "i" (TARGET_PAGE_MASK | (DATA_SIZE - 1)),
    153218                  "m" (*(uint32_t *)offsetof(CPUState, tlb_table[CPU_MMU_INDEX][0].addr_write)),
    … …  
    156221                  : "%eax", "%ecx", "%edx", "memory", "cc");
    157222}
    158 #endif /* !VBOX */
    159 
    160223#else
    161224
    … …  
    168231#endif
    169232{
    170     int index;
     233
     234    int page_index;
    171235    RES_TYPE res;
    172236    target_ulong addr;
    173237    unsigned long physaddr;
    174     int is_user;
     238    int mmu_idx;
    175239
    176240    addr = ptr;
    177     index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
    178     is_user = CPU_MMU_INDEX;
    179 #ifndef VBOX
    180     if (__builtin_expect(env->tlb_table[is_user][index].ADDR_READ !=
    181                          (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))), 0)) {
    182 #else
    183     if  (RT_UNLIKELY(env->tlb_table[is_user][index].ADDR_READ !=
    184                          (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
    185 #endif
    186         res = glue(glue(__ld, SUFFIX), MMUSUFFIX)(addr, is_user);
     241    page_index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
     242    mmu_idx = CPU_MMU_INDEX;
     243    if (unlikely(env->tlb_table[mmu_idx][page_index].ADDR_READ !=
     244                 (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
     245        res = glue(glue(__ld, SUFFIX), MMUSUFFIX)(addr, mmu_idx);
    187246    } else {
    188         physaddr = addr + env->tlb_table[is_user][index].addend;
     247        physaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
    189248        res = glue(glue(ld, USUFFIX), _raw)((uint8_t *)physaddr);
    190249    }
    … …  
    199258#endif
    200259{
    201     int res, index;
     260    int res, page_index;
    202261    target_ulong addr;
    203262    unsigned long physaddr;
    204     int is_user;
     263    int mmu_idx;
    205264
    206265    addr = ptr;
    207     index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
    208     is_user = CPU_MMU_INDEX;
    209 #ifndef VBOX
    210     if (__builtin_expect(env->tlb_table[is_user][index].ADDR_READ !=
    211                          (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))), 0)) {
    212 #else
    213     if (RT_UNLIKELY(env->tlb_table[is_user][index].ADDR_READ !=
    214                          (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
    215 #endif
    216         res = (DATA_STYPE)glue(glue(__ld, SUFFIX), MMUSUFFIX)(addr, is_user);
     266    page_index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
     267    mmu_idx = CPU_MMU_INDEX;
     268    if (unlikely(env->tlb_table[mmu_idx][page_index].ADDR_READ !=
     269                 (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
     270        res = (DATA_STYPE)glue(glue(__ld, SUFFIX), MMUSUFFIX)(addr, mmu_idx);
    217271    } else {
    218         physaddr = addr + env->tlb_table[is_user][index].addend;
     272        physaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
    219273        res = glue(glue(lds, SUFFIX), _raw)((uint8_t *)physaddr);
    220274    }
    … …  
    232286#endif
    233287{
    234     int index;
     288    int page_index;
    235289    target_ulong addr;
    236290    unsigned long physaddr;
    237     int is_user;
     291    int mmu_idx;
    238292
    239293    addr = ptr;
    240     index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
    241     is_user = CPU_MMU_INDEX;
    242 #ifndef VBOX
    243     if (__builtin_expect(env->tlb_table[is_user][index].addr_write !=
    244                          (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))), 0)) {
    245 #else
    246     if (RT_UNLIKELY(env->tlb_table[is_user][index].addr_write !=
    247                          (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
    248 #endif
    249         glue(glue(__st, SUFFIX), MMUSUFFIX)(addr, v, is_user);
     294    page_index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
     295    mmu_idx = CPU_MMU_INDEX;
     296    if (unlikely(env->tlb_table[mmu_idx][page_index].addr_write !=
     297                 (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
     298        glue(glue(__st, SUFFIX), MMUSUFFIX)(addr, v, mmu_idx);
    250299    } else {
    251         physaddr = addr + env->tlb_table[is_user][index].addend;
     300        physaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
    252301        glue(glue(st, SUFFIX), _raw)((uint8_t *)physaddr, v);
    253302    }

  • trunk/src/recompiler_new/softmmu_template.h

    r13382 r13731  
    5757#endif
    5858
    59 static DATA_TYPE glue(glue(slow_ld, SUFFIX), MMUSUFFIX)(target_ulong addr, 
    60                                                         int is_user,
     59static DATA_TYPE glue(glue(slow_ld, SUFFIX), MMUSUFFIX)(target_ulong addr,
     60                                                        int mmu_idx,
    6161                                                        void *retaddr);
    6262#ifndef VBOX
    … …  
    207207static void glue(glue(slow_st, SUFFIX), MMUSUFFIX)(target_ulong addr,
    208208                                                   DATA_TYPE val,
    209                                                    int is_user,
     209                                                   int mmu_idx,
    210210                                                   void *retaddr);
    211211
    … …  
    299299}
    300300
    301 /* handles all unaligned cases */
    302301/* handles all unaligned cases */
    303302static void glue(glue(slow_st, SUFFIX), MMUSUFFIX)(target_ulong addr,

  • trunk/src/recompiler_new/target-i386/cpu.h

    r13382 r13731  
    635635    uint32_t smbase;
    636636    int old_exception;  /* exception in flight */
    637  
    638637
    639638    CPU_COMMON
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette