Annotation of qemu/tci.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Tiny Code Interpreter for QEMU
        !             3:  *
        !             4:  * Copyright (c) 2009, 2011 Stefan Weil
        !             5:  *
        !             6:  * This program is free software: you can redistribute it and/or modify
        !             7:  * it under the terms of the GNU General Public License as published by
        !             8:  * the Free Software Foundation, either version 2 of the License, or
        !             9:  * (at your option) any later version.
        !            10:  *
        !            11:  * This program is distributed in the hope that it will be useful,
        !            12:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14:  * GNU General Public License for more details.
        !            15:  *
        !            16:  * You should have received a copy of the GNU General Public License
        !            17:  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
        !            18:  */
        !            19: 
        !            20: #include "config.h"
        !            21: 
        !            22: /* Defining NDEBUG disables assertions (which makes the code faster). */
        !            23: #if !defined(CONFIG_TCG_DEBUG) && !defined(NDEBUG)
        !            24: # define NDEBUG
        !            25: #endif
        !            26: 
        !            27: #include "qemu-common.h"
        !            28: #include "dyngen-exec.h"        /* env */
        !            29: #include "exec-all.h"           /* MAX_OPC_PARAM_IARGS */
        !            30: #include "tcg-op.h"
        !            31: 
        !            32: /* Marker for missing code. */
        !            33: #define TODO() \
        !            34:     do { \
        !            35:         fprintf(stderr, "TODO %s:%u: %s()\n", \
        !            36:                 __FILE__, __LINE__, __func__); \
        !            37:         tcg_abort(); \
        !            38:     } while (0)
        !            39: 
        !            40: #if MAX_OPC_PARAM_IARGS != 4
        !            41: # error Fix needed, number of supported input arguments changed!
        !            42: #endif
        !            43: #if TCG_TARGET_REG_BITS == 32
        !            44: typedef uint64_t (*helper_function)(tcg_target_ulong, tcg_target_ulong,
        !            45:                                     tcg_target_ulong, tcg_target_ulong,
        !            46:                                     tcg_target_ulong, tcg_target_ulong,
        !            47:                                     tcg_target_ulong, tcg_target_ulong);
        !            48: #else
        !            49: typedef uint64_t (*helper_function)(tcg_target_ulong, tcg_target_ulong,
        !            50:                                     tcg_target_ulong, tcg_target_ulong);
        !            51: #endif
        !            52: 
        !            53: /* TCI can optionally use a global register variable for env. */
        !            54: #if !defined(AREG0)
        !            55: CPUState *env;
        !            56: #endif
        !            57: 
        !            58: /* Targets which don't use GETPC also don't need tci_tb_ptr
        !            59:    which makes them a little faster. */
        !            60: #if defined(GETPC)
        !            61: void *tci_tb_ptr;
        !            62: #endif
        !            63: 
        !            64: static tcg_target_ulong tci_reg[TCG_TARGET_NB_REGS];
        !            65: 
        !            66: static tcg_target_ulong tci_read_reg(TCGReg index)
        !            67: {
        !            68:     assert(index < ARRAY_SIZE(tci_reg));
        !            69:     return tci_reg[index];
        !            70: }
        !            71: 
        !            72: #if TCG_TARGET_HAS_ext8s_i32 || TCG_TARGET_HAS_ext8s_i64
        !            73: static int8_t tci_read_reg8s(TCGReg index)
        !            74: {
        !            75:     return (int8_t)tci_read_reg(index);
        !            76: }
        !            77: #endif
        !            78: 
        !            79: #if TCG_TARGET_HAS_ext16s_i32 || TCG_TARGET_HAS_ext16s_i64
        !            80: static int16_t tci_read_reg16s(TCGReg index)
        !            81: {
        !            82:     return (int16_t)tci_read_reg(index);
        !            83: }
        !            84: #endif
        !            85: 
        !            86: #if TCG_TARGET_REG_BITS == 64
        !            87: static int32_t tci_read_reg32s(TCGReg index)
        !            88: {
        !            89:     return (int32_t)tci_read_reg(index);
        !            90: }
        !            91: #endif
        !            92: 
        !            93: static uint8_t tci_read_reg8(TCGReg index)
        !            94: {
        !            95:     return (uint8_t)tci_read_reg(index);
        !            96: }
        !            97: 
        !            98: static uint16_t tci_read_reg16(TCGReg index)
        !            99: {
        !           100:     return (uint16_t)tci_read_reg(index);
        !           101: }
        !           102: 
        !           103: static uint32_t tci_read_reg32(TCGReg index)
        !           104: {
        !           105:     return (uint32_t)tci_read_reg(index);
        !           106: }
        !           107: 
        !           108: #if TCG_TARGET_REG_BITS == 64
        !           109: static uint64_t tci_read_reg64(TCGReg index)
        !           110: {
        !           111:     return tci_read_reg(index);
        !           112: }
        !           113: #endif
        !           114: 
        !           115: static void tci_write_reg(TCGReg index, tcg_target_ulong value)
        !           116: {
        !           117:     assert(index < ARRAY_SIZE(tci_reg));
        !           118:     assert(index != TCG_AREG0);
        !           119:     tci_reg[index] = value;
        !           120: }
        !           121: 
        !           122: static void tci_write_reg8s(TCGReg index, int8_t value)
        !           123: {
        !           124:     tci_write_reg(index, value);
        !           125: }
        !           126: 
        !           127: static void tci_write_reg16s(TCGReg index, int16_t value)
        !           128: {
        !           129:     tci_write_reg(index, value);
        !           130: }
        !           131: 
        !           132: #if TCG_TARGET_REG_BITS == 64
        !           133: static void tci_write_reg32s(TCGReg index, int32_t value)
        !           134: {
        !           135:     tci_write_reg(index, value);
        !           136: }
        !           137: #endif
        !           138: 
        !           139: static void tci_write_reg8(TCGReg index, uint8_t value)
        !           140: {
        !           141:     tci_write_reg(index, value);
        !           142: }
        !           143: 
        !           144: static void tci_write_reg16(TCGReg index, uint16_t value)
        !           145: {
        !           146:     tci_write_reg(index, value);
        !           147: }
        !           148: 
        !           149: static void tci_write_reg32(TCGReg index, uint32_t value)
        !           150: {
        !           151:     tci_write_reg(index, value);
        !           152: }
        !           153: 
        !           154: #if TCG_TARGET_REG_BITS == 32
        !           155: static void tci_write_reg64(uint32_t high_index, uint32_t low_index,
        !           156:                             uint64_t value)
        !           157: {
        !           158:     tci_write_reg(low_index, value);
        !           159:     tci_write_reg(high_index, value >> 32);
        !           160: }
        !           161: #elif TCG_TARGET_REG_BITS == 64
        !           162: static void tci_write_reg64(TCGReg index, uint64_t value)
        !           163: {
        !           164:     tci_write_reg(index, value);
        !           165: }
        !           166: #endif
        !           167: 
        !           168: #if TCG_TARGET_REG_BITS == 32
        !           169: /* Create a 64 bit value from two 32 bit values. */
        !           170: static uint64_t tci_uint64(uint32_t high, uint32_t low)
        !           171: {
        !           172:     return ((uint64_t)high << 32) + low;
        !           173: }
        !           174: #endif
        !           175: 
        !           176: /* Read constant (native size) from bytecode. */
        !           177: static tcg_target_ulong tci_read_i(uint8_t **tb_ptr)
        !           178: {
        !           179:     tcg_target_ulong value = *(tcg_target_ulong *)(*tb_ptr);
        !           180:     *tb_ptr += sizeof(value);
        !           181:     return value;
        !           182: }
        !           183: 
        !           184: /* Read constant (32 bit) from bytecode. */
        !           185: static uint32_t tci_read_i32(uint8_t **tb_ptr)
        !           186: {
        !           187:     uint32_t value = *(uint32_t *)(*tb_ptr);
        !           188:     *tb_ptr += sizeof(value);
        !           189:     return value;
        !           190: }
        !           191: 
        !           192: #if TCG_TARGET_REG_BITS == 64
        !           193: /* Read constant (64 bit) from bytecode. */
        !           194: static uint64_t tci_read_i64(uint8_t **tb_ptr)
        !           195: {
        !           196:     uint64_t value = *(uint64_t *)(*tb_ptr);
        !           197:     *tb_ptr += sizeof(value);
        !           198:     return value;
        !           199: }
        !           200: #endif
        !           201: 
        !           202: /* Read indexed register (native size) from bytecode. */
        !           203: static tcg_target_ulong tci_read_r(uint8_t **tb_ptr)
        !           204: {
        !           205:     tcg_target_ulong value = tci_read_reg(**tb_ptr);
        !           206:     *tb_ptr += 1;
        !           207:     return value;
        !           208: }
        !           209: 
        !           210: /* Read indexed register (8 bit) from bytecode. */
        !           211: static uint8_t tci_read_r8(uint8_t **tb_ptr)
        !           212: {
        !           213:     uint8_t value = tci_read_reg8(**tb_ptr);
        !           214:     *tb_ptr += 1;
        !           215:     return value;
        !           216: }
        !           217: 
        !           218: #if TCG_TARGET_HAS_ext8s_i32 || TCG_TARGET_HAS_ext8s_i64
        !           219: /* Read indexed register (8 bit signed) from bytecode. */
        !           220: static int8_t tci_read_r8s(uint8_t **tb_ptr)
        !           221: {
        !           222:     int8_t value = tci_read_reg8s(**tb_ptr);
        !           223:     *tb_ptr += 1;
        !           224:     return value;
        !           225: }
        !           226: #endif
        !           227: 
        !           228: /* Read indexed register (16 bit) from bytecode. */
        !           229: static uint16_t tci_read_r16(uint8_t **tb_ptr)
        !           230: {
        !           231:     uint16_t value = tci_read_reg16(**tb_ptr);
        !           232:     *tb_ptr += 1;
        !           233:     return value;
        !           234: }
        !           235: 
        !           236: #if TCG_TARGET_HAS_ext16s_i32 || TCG_TARGET_HAS_ext16s_i64
        !           237: /* Read indexed register (16 bit signed) from bytecode. */
        !           238: static int16_t tci_read_r16s(uint8_t **tb_ptr)
        !           239: {
        !           240:     int16_t value = tci_read_reg16s(**tb_ptr);
        !           241:     *tb_ptr += 1;
        !           242:     return value;
        !           243: }
        !           244: #endif
        !           245: 
        !           246: /* Read indexed register (32 bit) from bytecode. */
        !           247: static uint32_t tci_read_r32(uint8_t **tb_ptr)
        !           248: {
        !           249:     uint32_t value = tci_read_reg32(**tb_ptr);
        !           250:     *tb_ptr += 1;
        !           251:     return value;
        !           252: }
        !           253: 
        !           254: #if TCG_TARGET_REG_BITS == 32
        !           255: /* Read two indexed registers (2 * 32 bit) from bytecode. */
        !           256: static uint64_t tci_read_r64(uint8_t **tb_ptr)
        !           257: {
        !           258:     uint32_t low = tci_read_r32(tb_ptr);
        !           259:     return tci_uint64(tci_read_r32(tb_ptr), low);
        !           260: }
        !           261: #elif TCG_TARGET_REG_BITS == 64
        !           262: /* Read indexed register (32 bit signed) from bytecode. */
        !           263: static int32_t tci_read_r32s(uint8_t **tb_ptr)
        !           264: {
        !           265:     int32_t value = tci_read_reg32s(**tb_ptr);
        !           266:     *tb_ptr += 1;
        !           267:     return value;
        !           268: }
        !           269: 
        !           270: /* Read indexed register (64 bit) from bytecode. */
        !           271: static uint64_t tci_read_r64(uint8_t **tb_ptr)
        !           272: {
        !           273:     uint64_t value = tci_read_reg64(**tb_ptr);
        !           274:     *tb_ptr += 1;
        !           275:     return value;
        !           276: }
        !           277: #endif
        !           278: 
        !           279: /* Read indexed register(s) with target address from bytecode. */
        !           280: static target_ulong tci_read_ulong(uint8_t **tb_ptr)
        !           281: {
        !           282:     target_ulong taddr = tci_read_r(tb_ptr);
        !           283: #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
        !           284:     taddr += (uint64_t)tci_read_r(tb_ptr) << 32;
        !           285: #endif
        !           286:     return taddr;
        !           287: }
        !           288: 
        !           289: /* Read indexed register or constant (native size) from bytecode. */
        !           290: static tcg_target_ulong tci_read_ri(uint8_t **tb_ptr)
        !           291: {
        !           292:     tcg_target_ulong value;
        !           293:     TCGReg r = **tb_ptr;
        !           294:     *tb_ptr += 1;
        !           295:     if (r == TCG_CONST) {
        !           296:         value = tci_read_i(tb_ptr);
        !           297:     } else {
        !           298:         value = tci_read_reg(r);
        !           299:     }
        !           300:     return value;
        !           301: }
        !           302: 
        !           303: /* Read indexed register or constant (32 bit) from bytecode. */
        !           304: static uint32_t tci_read_ri32(uint8_t **tb_ptr)
        !           305: {
        !           306:     uint32_t value;
        !           307:     TCGReg r = **tb_ptr;
        !           308:     *tb_ptr += 1;
        !           309:     if (r == TCG_CONST) {
        !           310:         value = tci_read_i32(tb_ptr);
        !           311:     } else {
        !           312:         value = tci_read_reg32(r);
        !           313:     }
        !           314:     return value;
        !           315: }
        !           316: 
        !           317: #if TCG_TARGET_REG_BITS == 32
        !           318: /* Read two indexed registers or constants (2 * 32 bit) from bytecode. */
        !           319: static uint64_t tci_read_ri64(uint8_t **tb_ptr)
        !           320: {
        !           321:     uint32_t low = tci_read_ri32(tb_ptr);
        !           322:     return tci_uint64(tci_read_ri32(tb_ptr), low);
        !           323: }
        !           324: #elif TCG_TARGET_REG_BITS == 64
        !           325: /* Read indexed register or constant (64 bit) from bytecode. */
        !           326: static uint64_t tci_read_ri64(uint8_t **tb_ptr)
        !           327: {
        !           328:     uint64_t value;
        !           329:     TCGReg r = **tb_ptr;
        !           330:     *tb_ptr += 1;
        !           331:     if (r == TCG_CONST) {
        !           332:         value = tci_read_i64(tb_ptr);
        !           333:     } else {
        !           334:         value = tci_read_reg64(r);
        !           335:     }
        !           336:     return value;
        !           337: }
        !           338: #endif
        !           339: 
        !           340: static target_ulong tci_read_label(uint8_t **tb_ptr)
        !           341: {
        !           342:     target_ulong label = tci_read_i(tb_ptr);
        !           343:     assert(label != 0);
        !           344:     return label;
        !           345: }
        !           346: 
        !           347: static bool tci_compare32(uint32_t u0, uint32_t u1, TCGCond condition)
        !           348: {
        !           349:     bool result = false;
        !           350:     int32_t i0 = u0;
        !           351:     int32_t i1 = u1;
        !           352:     switch (condition) {
        !           353:     case TCG_COND_EQ:
        !           354:         result = (u0 == u1);
        !           355:         break;
        !           356:     case TCG_COND_NE:
        !           357:         result = (u0 != u1);
        !           358:         break;
        !           359:     case TCG_COND_LT:
        !           360:         result = (i0 < i1);
        !           361:         break;
        !           362:     case TCG_COND_GE:
        !           363:         result = (i0 >= i1);
        !           364:         break;
        !           365:     case TCG_COND_LE:
        !           366:         result = (i0 <= i1);
        !           367:         break;
        !           368:     case TCG_COND_GT:
        !           369:         result = (i0 > i1);
        !           370:         break;
        !           371:     case TCG_COND_LTU:
        !           372:         result = (u0 < u1);
        !           373:         break;
        !           374:     case TCG_COND_GEU:
        !           375:         result = (u0 >= u1);
        !           376:         break;
        !           377:     case TCG_COND_LEU:
        !           378:         result = (u0 <= u1);
        !           379:         break;
        !           380:     case TCG_COND_GTU:
        !           381:         result = (u0 > u1);
        !           382:         break;
        !           383:     default:
        !           384:         TODO();
        !           385:     }
        !           386:     return result;
        !           387: }
        !           388: 
        !           389: static bool tci_compare64(uint64_t u0, uint64_t u1, TCGCond condition)
        !           390: {
        !           391:     bool result = false;
        !           392:     int64_t i0 = u0;
        !           393:     int64_t i1 = u1;
        !           394:     switch (condition) {
        !           395:     case TCG_COND_EQ:
        !           396:         result = (u0 == u1);
        !           397:         break;
        !           398:     case TCG_COND_NE:
        !           399:         result = (u0 != u1);
        !           400:         break;
        !           401:     case TCG_COND_LT:
        !           402:         result = (i0 < i1);
        !           403:         break;
        !           404:     case TCG_COND_GE:
        !           405:         result = (i0 >= i1);
        !           406:         break;
        !           407:     case TCG_COND_LE:
        !           408:         result = (i0 <= i1);
        !           409:         break;
        !           410:     case TCG_COND_GT:
        !           411:         result = (i0 > i1);
        !           412:         break;
        !           413:     case TCG_COND_LTU:
        !           414:         result = (u0 < u1);
        !           415:         break;
        !           416:     case TCG_COND_GEU:
        !           417:         result = (u0 >= u1);
        !           418:         break;
        !           419:     case TCG_COND_LEU:
        !           420:         result = (u0 <= u1);
        !           421:         break;
        !           422:     case TCG_COND_GTU:
        !           423:         result = (u0 > u1);
        !           424:         break;
        !           425:     default:
        !           426:         TODO();
        !           427:     }
        !           428:     return result;
        !           429: }
        !           430: 
        !           431: /* Interpret pseudo code in tb. */
        !           432: unsigned long tcg_qemu_tb_exec(CPUState *cpustate, uint8_t *tb_ptr)
        !           433: {
        !           434:     unsigned long next_tb = 0;
        !           435: 
        !           436:     env = cpustate;
        !           437:     tci_reg[TCG_AREG0] = (tcg_target_ulong)env;
        !           438:     assert(tb_ptr);
        !           439: 
        !           440:     for (;;) {
        !           441: #if defined(GETPC)
        !           442:         tci_tb_ptr = tb_ptr;
        !           443: #endif
        !           444:         TCGOpcode opc = tb_ptr[0];
        !           445: #if !defined(NDEBUG)
        !           446:         uint8_t op_size = tb_ptr[1];
        !           447:         uint8_t *old_code_ptr = tb_ptr;
        !           448: #endif
        !           449:         tcg_target_ulong t0;
        !           450:         tcg_target_ulong t1;
        !           451:         tcg_target_ulong t2;
        !           452:         tcg_target_ulong label;
        !           453:         TCGCond condition;
        !           454:         target_ulong taddr;
        !           455: #ifndef CONFIG_SOFTMMU
        !           456:         tcg_target_ulong host_addr;
        !           457: #endif
        !           458:         uint8_t tmp8;
        !           459:         uint16_t tmp16;
        !           460:         uint32_t tmp32;
        !           461:         uint64_t tmp64;
        !           462: #if TCG_TARGET_REG_BITS == 32
        !           463:         uint64_t v64;
        !           464: #endif
        !           465: 
        !           466:         /* Skip opcode and size entry. */
        !           467:         tb_ptr += 2;
        !           468: 
        !           469:         switch (opc) {
        !           470:         case INDEX_op_end:
        !           471:         case INDEX_op_nop:
        !           472:             break;
        !           473:         case INDEX_op_nop1:
        !           474:         case INDEX_op_nop2:
        !           475:         case INDEX_op_nop3:
        !           476:         case INDEX_op_nopn:
        !           477:         case INDEX_op_discard:
        !           478:             TODO();
        !           479:             break;
        !           480:         case INDEX_op_set_label:
        !           481:             TODO();
        !           482:             break;
        !           483:         case INDEX_op_call:
        !           484:             t0 = tci_read_ri(&tb_ptr);
        !           485: #if TCG_TARGET_REG_BITS == 32
        !           486:             tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
        !           487:                                           tci_read_reg(TCG_REG_R1),
        !           488:                                           tci_read_reg(TCG_REG_R2),
        !           489:                                           tci_read_reg(TCG_REG_R3),
        !           490:                                           tci_read_reg(TCG_REG_R5),
        !           491:                                           tci_read_reg(TCG_REG_R6),
        !           492:                                           tci_read_reg(TCG_REG_R7),
        !           493:                                           tci_read_reg(TCG_REG_R8));
        !           494:             tci_write_reg(TCG_REG_R0, tmp64);
        !           495:             tci_write_reg(TCG_REG_R1, tmp64 >> 32);
        !           496: #else
        !           497:             tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
        !           498:                                           tci_read_reg(TCG_REG_R1),
        !           499:                                           tci_read_reg(TCG_REG_R2),
        !           500:                                           tci_read_reg(TCG_REG_R3));
        !           501:             tci_write_reg(TCG_REG_R0, tmp64);
        !           502: #endif
        !           503:             break;
        !           504:         case INDEX_op_jmp:
        !           505:         case INDEX_op_br:
        !           506:             label = tci_read_label(&tb_ptr);
        !           507:             assert(tb_ptr == old_code_ptr + op_size);
        !           508:             tb_ptr = (uint8_t *)label;
        !           509:             continue;
        !           510:         case INDEX_op_setcond_i32:
        !           511:             t0 = *tb_ptr++;
        !           512:             t1 = tci_read_r32(&tb_ptr);
        !           513:             t2 = tci_read_ri32(&tb_ptr);
        !           514:             condition = *tb_ptr++;
        !           515:             tci_write_reg32(t0, tci_compare32(t1, t2, condition));
        !           516:             break;
        !           517: #if TCG_TARGET_REG_BITS == 32
        !           518:         case INDEX_op_setcond2_i32:
        !           519:             t0 = *tb_ptr++;
        !           520:             tmp64 = tci_read_r64(&tb_ptr);
        !           521:             v64 = tci_read_ri64(&tb_ptr);
        !           522:             condition = *tb_ptr++;
        !           523:             tci_write_reg32(t0, tci_compare64(tmp64, v64, condition));
        !           524:             break;
        !           525: #elif TCG_TARGET_REG_BITS == 64
        !           526:         case INDEX_op_setcond_i64:
        !           527:             t0 = *tb_ptr++;
        !           528:             t1 = tci_read_r64(&tb_ptr);
        !           529:             t2 = tci_read_ri64(&tb_ptr);
        !           530:             condition = *tb_ptr++;
        !           531:             tci_write_reg64(t0, tci_compare64(t1, t2, condition));
        !           532:             break;
        !           533: #endif
        !           534:         case INDEX_op_mov_i32:
        !           535:             t0 = *tb_ptr++;
        !           536:             t1 = tci_read_r32(&tb_ptr);
        !           537:             tci_write_reg32(t0, t1);
        !           538:             break;
        !           539:         case INDEX_op_movi_i32:
        !           540:             t0 = *tb_ptr++;
        !           541:             t1 = tci_read_i32(&tb_ptr);
        !           542:             tci_write_reg32(t0, t1);
        !           543:             break;
        !           544: 
        !           545:             /* Load/store operations (32 bit). */
        !           546: 
        !           547:         case INDEX_op_ld8u_i32:
        !           548:             t0 = *tb_ptr++;
        !           549:             t1 = tci_read_r(&tb_ptr);
        !           550:             t2 = tci_read_i32(&tb_ptr);
        !           551:             tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
        !           552:             break;
        !           553:         case INDEX_op_ld8s_i32:
        !           554:         case INDEX_op_ld16u_i32:
        !           555:             TODO();
        !           556:             break;
        !           557:         case INDEX_op_ld16s_i32:
        !           558:             TODO();
        !           559:             break;
        !           560:         case INDEX_op_ld_i32:
        !           561:             t0 = *tb_ptr++;
        !           562:             t1 = tci_read_r(&tb_ptr);
        !           563:             t2 = tci_read_i32(&tb_ptr);
        !           564:             tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
        !           565:             break;
        !           566:         case INDEX_op_st8_i32:
        !           567:             t0 = tci_read_r8(&tb_ptr);
        !           568:             t1 = tci_read_r(&tb_ptr);
        !           569:             t2 = tci_read_i32(&tb_ptr);
        !           570:             *(uint8_t *)(t1 + t2) = t0;
        !           571:             break;
        !           572:         case INDEX_op_st16_i32:
        !           573:             t0 = tci_read_r16(&tb_ptr);
        !           574:             t1 = tci_read_r(&tb_ptr);
        !           575:             t2 = tci_read_i32(&tb_ptr);
        !           576:             *(uint16_t *)(t1 + t2) = t0;
        !           577:             break;
        !           578:         case INDEX_op_st_i32:
        !           579:             t0 = tci_read_r32(&tb_ptr);
        !           580:             t1 = tci_read_r(&tb_ptr);
        !           581:             t2 = tci_read_i32(&tb_ptr);
        !           582:             *(uint32_t *)(t1 + t2) = t0;
        !           583:             break;
        !           584: 
        !           585:             /* Arithmetic operations (32 bit). */
        !           586: 
        !           587:         case INDEX_op_add_i32:
        !           588:             t0 = *tb_ptr++;
        !           589:             t1 = tci_read_ri32(&tb_ptr);
        !           590:             t2 = tci_read_ri32(&tb_ptr);
        !           591:             tci_write_reg32(t0, t1 + t2);
        !           592:             break;
        !           593:         case INDEX_op_sub_i32:
        !           594:             t0 = *tb_ptr++;
        !           595:             t1 = tci_read_ri32(&tb_ptr);
        !           596:             t2 = tci_read_ri32(&tb_ptr);
        !           597:             tci_write_reg32(t0, t1 - t2);
        !           598:             break;
        !           599:         case INDEX_op_mul_i32:
        !           600:             t0 = *tb_ptr++;
        !           601:             t1 = tci_read_ri32(&tb_ptr);
        !           602:             t2 = tci_read_ri32(&tb_ptr);
        !           603:             tci_write_reg32(t0, t1 * t2);
        !           604:             break;
        !           605: #if TCG_TARGET_HAS_div_i32
        !           606:         case INDEX_op_div_i32:
        !           607:             t0 = *tb_ptr++;
        !           608:             t1 = tci_read_ri32(&tb_ptr);
        !           609:             t2 = tci_read_ri32(&tb_ptr);
        !           610:             tci_write_reg32(t0, (int32_t)t1 / (int32_t)t2);
        !           611:             break;
        !           612:         case INDEX_op_divu_i32:
        !           613:             t0 = *tb_ptr++;
        !           614:             t1 = tci_read_ri32(&tb_ptr);
        !           615:             t2 = tci_read_ri32(&tb_ptr);
        !           616:             tci_write_reg32(t0, t1 / t2);
        !           617:             break;
        !           618:         case INDEX_op_rem_i32:
        !           619:             t0 = *tb_ptr++;
        !           620:             t1 = tci_read_ri32(&tb_ptr);
        !           621:             t2 = tci_read_ri32(&tb_ptr);
        !           622:             tci_write_reg32(t0, (int32_t)t1 % (int32_t)t2);
        !           623:             break;
        !           624:         case INDEX_op_remu_i32:
        !           625:             t0 = *tb_ptr++;
        !           626:             t1 = tci_read_ri32(&tb_ptr);
        !           627:             t2 = tci_read_ri32(&tb_ptr);
        !           628:             tci_write_reg32(t0, t1 % t2);
        !           629:             break;
        !           630: #elif TCG_TARGET_HAS_div2_i32
        !           631:         case INDEX_op_div2_i32:
        !           632:         case INDEX_op_divu2_i32:
        !           633:             TODO();
        !           634:             break;
        !           635: #endif
        !           636:         case INDEX_op_and_i32:
        !           637:             t0 = *tb_ptr++;
        !           638:             t1 = tci_read_ri32(&tb_ptr);
        !           639:             t2 = tci_read_ri32(&tb_ptr);
        !           640:             tci_write_reg32(t0, t1 & t2);
        !           641:             break;
        !           642:         case INDEX_op_or_i32:
        !           643:             t0 = *tb_ptr++;
        !           644:             t1 = tci_read_ri32(&tb_ptr);
        !           645:             t2 = tci_read_ri32(&tb_ptr);
        !           646:             tci_write_reg32(t0, t1 | t2);
        !           647:             break;
        !           648:         case INDEX_op_xor_i32:
        !           649:             t0 = *tb_ptr++;
        !           650:             t1 = tci_read_ri32(&tb_ptr);
        !           651:             t2 = tci_read_ri32(&tb_ptr);
        !           652:             tci_write_reg32(t0, t1 ^ t2);
        !           653:             break;
        !           654: 
        !           655:             /* Shift/rotate operations (32 bit). */
        !           656: 
        !           657:         case INDEX_op_shl_i32:
        !           658:             t0 = *tb_ptr++;
        !           659:             t1 = tci_read_ri32(&tb_ptr);
        !           660:             t2 = tci_read_ri32(&tb_ptr);
        !           661:             tci_write_reg32(t0, t1 << t2);
        !           662:             break;
        !           663:         case INDEX_op_shr_i32:
        !           664:             t0 = *tb_ptr++;
        !           665:             t1 = tci_read_ri32(&tb_ptr);
        !           666:             t2 = tci_read_ri32(&tb_ptr);
        !           667:             tci_write_reg32(t0, t1 >> t2);
        !           668:             break;
        !           669:         case INDEX_op_sar_i32:
        !           670:             t0 = *tb_ptr++;
        !           671:             t1 = tci_read_ri32(&tb_ptr);
        !           672:             t2 = tci_read_ri32(&tb_ptr);
        !           673:             tci_write_reg32(t0, ((int32_t)t1 >> t2));
        !           674:             break;
        !           675: #if TCG_TARGET_HAS_rot_i32
        !           676:         case INDEX_op_rotl_i32:
        !           677:             t0 = *tb_ptr++;
        !           678:             t1 = tci_read_ri32(&tb_ptr);
        !           679:             t2 = tci_read_ri32(&tb_ptr);
        !           680:             tci_write_reg32(t0, (t1 << t2) | (t1 >> (32 - t2)));
        !           681:             break;
        !           682:         case INDEX_op_rotr_i32:
        !           683:             t0 = *tb_ptr++;
        !           684:             t1 = tci_read_ri32(&tb_ptr);
        !           685:             t2 = tci_read_ri32(&tb_ptr);
        !           686:             tci_write_reg32(t0, (t1 >> t2) | (t1 << (32 - t2)));
        !           687:             break;
        !           688: #endif
        !           689:         case INDEX_op_brcond_i32:
        !           690:             t0 = tci_read_r32(&tb_ptr);
        !           691:             t1 = tci_read_ri32(&tb_ptr);
        !           692:             condition = *tb_ptr++;
        !           693:             label = tci_read_label(&tb_ptr);
        !           694:             if (tci_compare32(t0, t1, condition)) {
        !           695:                 assert(tb_ptr == old_code_ptr + op_size);
        !           696:                 tb_ptr = (uint8_t *)label;
        !           697:                 continue;
        !           698:             }
        !           699:             break;
        !           700: #if TCG_TARGET_REG_BITS == 32
        !           701:         case INDEX_op_add2_i32:
        !           702:             t0 = *tb_ptr++;
        !           703:             t1 = *tb_ptr++;
        !           704:             tmp64 = tci_read_r64(&tb_ptr);
        !           705:             tmp64 += tci_read_r64(&tb_ptr);
        !           706:             tci_write_reg64(t1, t0, tmp64);
        !           707:             break;
        !           708:         case INDEX_op_sub2_i32:
        !           709:             t0 = *tb_ptr++;
        !           710:             t1 = *tb_ptr++;
        !           711:             tmp64 = tci_read_r64(&tb_ptr);
        !           712:             tmp64 -= tci_read_r64(&tb_ptr);
        !           713:             tci_write_reg64(t1, t0, tmp64);
        !           714:             break;
        !           715:         case INDEX_op_brcond2_i32:
        !           716:             tmp64 = tci_read_r64(&tb_ptr);
        !           717:             v64 = tci_read_ri64(&tb_ptr);
        !           718:             condition = *tb_ptr++;
        !           719:             label = tci_read_label(&tb_ptr);
        !           720:             if (tci_compare64(tmp64, v64, condition)) {
        !           721:                 assert(tb_ptr == old_code_ptr + op_size);
        !           722:                 tb_ptr = (uint8_t *)label;
        !           723:                 continue;
        !           724:             }
        !           725:             break;
        !           726:         case INDEX_op_mulu2_i32:
        !           727:             t0 = *tb_ptr++;
        !           728:             t1 = *tb_ptr++;
        !           729:             t2 = tci_read_r32(&tb_ptr);
        !           730:             tmp64 = tci_read_r32(&tb_ptr);
        !           731:             tci_write_reg64(t1, t0, t2 * tmp64);
        !           732:             break;
        !           733: #endif /* TCG_TARGET_REG_BITS == 32 */
        !           734: #if TCG_TARGET_HAS_ext8s_i32
        !           735:         case INDEX_op_ext8s_i32:
        !           736:             t0 = *tb_ptr++;
        !           737:             t1 = tci_read_r8s(&tb_ptr);
        !           738:             tci_write_reg32(t0, t1);
        !           739:             break;
        !           740: #endif
        !           741: #if TCG_TARGET_HAS_ext16s_i32
        !           742:         case INDEX_op_ext16s_i32:
        !           743:             t0 = *tb_ptr++;
        !           744:             t1 = tci_read_r16s(&tb_ptr);
        !           745:             tci_write_reg32(t0, t1);
        !           746:             break;
        !           747: #endif
        !           748: #if TCG_TARGET_HAS_ext8u_i32
        !           749:         case INDEX_op_ext8u_i32:
        !           750:             t0 = *tb_ptr++;
        !           751:             t1 = tci_read_r8(&tb_ptr);
        !           752:             tci_write_reg32(t0, t1);
        !           753:             break;
        !           754: #endif
        !           755: #if TCG_TARGET_HAS_ext16u_i32
        !           756:         case INDEX_op_ext16u_i32:
        !           757:             t0 = *tb_ptr++;
        !           758:             t1 = tci_read_r16(&tb_ptr);
        !           759:             tci_write_reg32(t0, t1);
        !           760:             break;
        !           761: #endif
        !           762: #if TCG_TARGET_HAS_bswap16_i32
        !           763:         case INDEX_op_bswap16_i32:
        !           764:             t0 = *tb_ptr++;
        !           765:             t1 = tci_read_r16(&tb_ptr);
        !           766:             tci_write_reg32(t0, bswap16(t1));
        !           767:             break;
        !           768: #endif
        !           769: #if TCG_TARGET_HAS_bswap32_i32
        !           770:         case INDEX_op_bswap32_i32:
        !           771:             t0 = *tb_ptr++;
        !           772:             t1 = tci_read_r32(&tb_ptr);
        !           773:             tci_write_reg32(t0, bswap32(t1));
        !           774:             break;
        !           775: #endif
        !           776: #if TCG_TARGET_HAS_not_i32
        !           777:         case INDEX_op_not_i32:
        !           778:             t0 = *tb_ptr++;
        !           779:             t1 = tci_read_r32(&tb_ptr);
        !           780:             tci_write_reg32(t0, ~t1);
        !           781:             break;
        !           782: #endif
        !           783: #if TCG_TARGET_HAS_neg_i32
        !           784:         case INDEX_op_neg_i32:
        !           785:             t0 = *tb_ptr++;
        !           786:             t1 = tci_read_r32(&tb_ptr);
        !           787:             tci_write_reg32(t0, -t1);
        !           788:             break;
        !           789: #endif
        !           790: #if TCG_TARGET_REG_BITS == 64
        !           791:         case INDEX_op_mov_i64:
        !           792:             t0 = *tb_ptr++;
        !           793:             t1 = tci_read_r64(&tb_ptr);
        !           794:             tci_write_reg64(t0, t1);
        !           795:             break;
        !           796:         case INDEX_op_movi_i64:
        !           797:             t0 = *tb_ptr++;
        !           798:             t1 = tci_read_i64(&tb_ptr);
        !           799:             tci_write_reg64(t0, t1);
        !           800:             break;
        !           801: 
        !           802:             /* Load/store operations (64 bit). */
        !           803: 
        !           804:         case INDEX_op_ld8u_i64:
        !           805:             t0 = *tb_ptr++;
        !           806:             t1 = tci_read_r(&tb_ptr);
        !           807:             t2 = tci_read_i32(&tb_ptr);
        !           808:             tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
        !           809:             break;
        !           810:         case INDEX_op_ld8s_i64:
        !           811:         case INDEX_op_ld16u_i64:
        !           812:         case INDEX_op_ld16s_i64:
        !           813:             TODO();
        !           814:             break;
        !           815:         case INDEX_op_ld32u_i64:
        !           816:             t0 = *tb_ptr++;
        !           817:             t1 = tci_read_r(&tb_ptr);
        !           818:             t2 = tci_read_i32(&tb_ptr);
        !           819:             tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
        !           820:             break;
        !           821:         case INDEX_op_ld32s_i64:
        !           822:             t0 = *tb_ptr++;
        !           823:             t1 = tci_read_r(&tb_ptr);
        !           824:             t2 = tci_read_i32(&tb_ptr);
        !           825:             tci_write_reg32s(t0, *(int32_t *)(t1 + t2));
        !           826:             break;
        !           827:         case INDEX_op_ld_i64:
        !           828:             t0 = *tb_ptr++;
        !           829:             t1 = tci_read_r(&tb_ptr);
        !           830:             t2 = tci_read_i32(&tb_ptr);
        !           831:             tci_write_reg64(t0, *(uint64_t *)(t1 + t2));
        !           832:             break;
        !           833:         case INDEX_op_st8_i64:
        !           834:             t0 = tci_read_r8(&tb_ptr);
        !           835:             t1 = tci_read_r(&tb_ptr);
        !           836:             t2 = tci_read_i32(&tb_ptr);
        !           837:             *(uint8_t *)(t1 + t2) = t0;
        !           838:             break;
        !           839:         case INDEX_op_st16_i64:
        !           840:             t0 = tci_read_r16(&tb_ptr);
        !           841:             t1 = tci_read_r(&tb_ptr);
        !           842:             t2 = tci_read_i32(&tb_ptr);
        !           843:             *(uint16_t *)(t1 + t2) = t0;
        !           844:             break;
        !           845:         case INDEX_op_st32_i64:
        !           846:             t0 = tci_read_r32(&tb_ptr);
        !           847:             t1 = tci_read_r(&tb_ptr);
        !           848:             t2 = tci_read_i32(&tb_ptr);
        !           849:             *(uint32_t *)(t1 + t2) = t0;
        !           850:             break;
        !           851:         case INDEX_op_st_i64:
        !           852:             t0 = tci_read_r64(&tb_ptr);
        !           853:             t1 = tci_read_r(&tb_ptr);
        !           854:             t2 = tci_read_i32(&tb_ptr);
        !           855:             *(uint64_t *)(t1 + t2) = t0;
        !           856:             break;
        !           857: 
        !           858:             /* Arithmetic operations (64 bit). */
        !           859: 
        !           860:         case INDEX_op_add_i64:
        !           861:             t0 = *tb_ptr++;
        !           862:             t1 = tci_read_ri64(&tb_ptr);
        !           863:             t2 = tci_read_ri64(&tb_ptr);
        !           864:             tci_write_reg64(t0, t1 + t2);
        !           865:             break;
        !           866:         case INDEX_op_sub_i64:
        !           867:             t0 = *tb_ptr++;
        !           868:             t1 = tci_read_ri64(&tb_ptr);
        !           869:             t2 = tci_read_ri64(&tb_ptr);
        !           870:             tci_write_reg64(t0, t1 - t2);
        !           871:             break;
        !           872:         case INDEX_op_mul_i64:
        !           873:             t0 = *tb_ptr++;
        !           874:             t1 = tci_read_ri64(&tb_ptr);
        !           875:             t2 = tci_read_ri64(&tb_ptr);
        !           876:             tci_write_reg64(t0, t1 * t2);
        !           877:             break;
        !           878: #if TCG_TARGET_HAS_div_i64
        !           879:         case INDEX_op_div_i64:
        !           880:         case INDEX_op_divu_i64:
        !           881:         case INDEX_op_rem_i64:
        !           882:         case INDEX_op_remu_i64:
        !           883:             TODO();
        !           884:             break;
        !           885: #elif TCG_TARGET_HAS_div2_i64
        !           886:         case INDEX_op_div2_i64:
        !           887:         case INDEX_op_divu2_i64:
        !           888:             TODO();
        !           889:             break;
        !           890: #endif
        !           891:         case INDEX_op_and_i64:
        !           892:             t0 = *tb_ptr++;
        !           893:             t1 = tci_read_ri64(&tb_ptr);
        !           894:             t2 = tci_read_ri64(&tb_ptr);
        !           895:             tci_write_reg64(t0, t1 & t2);
        !           896:             break;
        !           897:         case INDEX_op_or_i64:
        !           898:             t0 = *tb_ptr++;
        !           899:             t1 = tci_read_ri64(&tb_ptr);
        !           900:             t2 = tci_read_ri64(&tb_ptr);
        !           901:             tci_write_reg64(t0, t1 | t2);
        !           902:             break;
        !           903:         case INDEX_op_xor_i64:
        !           904:             t0 = *tb_ptr++;
        !           905:             t1 = tci_read_ri64(&tb_ptr);
        !           906:             t2 = tci_read_ri64(&tb_ptr);
        !           907:             tci_write_reg64(t0, t1 ^ t2);
        !           908:             break;
        !           909: 
        !           910:             /* Shift/rotate operations (64 bit). */
        !           911: 
        !           912:         case INDEX_op_shl_i64:
        !           913:             t0 = *tb_ptr++;
        !           914:             t1 = tci_read_ri64(&tb_ptr);
        !           915:             t2 = tci_read_ri64(&tb_ptr);
        !           916:             tci_write_reg64(t0, t1 << t2);
        !           917:             break;
        !           918:         case INDEX_op_shr_i64:
        !           919:             t0 = *tb_ptr++;
        !           920:             t1 = tci_read_ri64(&tb_ptr);
        !           921:             t2 = tci_read_ri64(&tb_ptr);
        !           922:             tci_write_reg64(t0, t1 >> t2);
        !           923:             break;
        !           924:         case INDEX_op_sar_i64:
        !           925:             t0 = *tb_ptr++;
        !           926:             t1 = tci_read_ri64(&tb_ptr);
        !           927:             t2 = tci_read_ri64(&tb_ptr);
        !           928:             tci_write_reg64(t0, ((int64_t)t1 >> t2));
        !           929:             break;
        !           930: #if TCG_TARGET_HAS_rot_i64
        !           931:         case INDEX_op_rotl_i64:
        !           932:         case INDEX_op_rotr_i64:
        !           933:             TODO();
        !           934:             break;
        !           935: #endif
        !           936:         case INDEX_op_brcond_i64:
        !           937:             t0 = tci_read_r64(&tb_ptr);
        !           938:             t1 = tci_read_ri64(&tb_ptr);
        !           939:             condition = *tb_ptr++;
        !           940:             label = tci_read_label(&tb_ptr);
        !           941:             if (tci_compare64(t0, t1, condition)) {
        !           942:                 assert(tb_ptr == old_code_ptr + op_size);
        !           943:                 tb_ptr = (uint8_t *)label;
        !           944:                 continue;
        !           945:             }
        !           946:             break;
        !           947: #if TCG_TARGET_HAS_ext8u_i64
        !           948:         case INDEX_op_ext8u_i64:
        !           949:             t0 = *tb_ptr++;
        !           950:             t1 = tci_read_r8(&tb_ptr);
        !           951:             tci_write_reg64(t0, t1);
        !           952:             break;
        !           953: #endif
        !           954: #if TCG_TARGET_HAS_ext8s_i64
        !           955:         case INDEX_op_ext8s_i64:
        !           956:             t0 = *tb_ptr++;
        !           957:             t1 = tci_read_r8s(&tb_ptr);
        !           958:             tci_write_reg64(t0, t1);
        !           959:             break;
        !           960: #endif
        !           961: #if TCG_TARGET_HAS_ext16s_i64
        !           962:         case INDEX_op_ext16s_i64:
        !           963:             t0 = *tb_ptr++;
        !           964:             t1 = tci_read_r16s(&tb_ptr);
        !           965:             tci_write_reg64(t0, t1);
        !           966:             break;
        !           967: #endif
        !           968: #if TCG_TARGET_HAS_ext16u_i64
        !           969:         case INDEX_op_ext16u_i64:
        !           970:             t0 = *tb_ptr++;
        !           971:             t1 = tci_read_r16(&tb_ptr);
        !           972:             tci_write_reg64(t0, t1);
        !           973:             break;
        !           974: #endif
        !           975: #if TCG_TARGET_HAS_ext32s_i64
        !           976:         case INDEX_op_ext32s_i64:
        !           977:             t0 = *tb_ptr++;
        !           978:             t1 = tci_read_r32s(&tb_ptr);
        !           979:             tci_write_reg64(t0, t1);
        !           980:             break;
        !           981: #endif
        !           982: #if TCG_TARGET_HAS_ext32u_i64
        !           983:         case INDEX_op_ext32u_i64:
        !           984:             t0 = *tb_ptr++;
        !           985:             t1 = tci_read_r32(&tb_ptr);
        !           986:             tci_write_reg64(t0, t1);
        !           987:             break;
        !           988: #endif
        !           989: #if TCG_TARGET_HAS_bswap16_i64
        !           990:         case INDEX_op_bswap16_i64:
        !           991:             TODO();
        !           992:             t0 = *tb_ptr++;
        !           993:             t1 = tci_read_r16(&tb_ptr);
        !           994:             tci_write_reg64(t0, bswap16(t1));
        !           995:             break;
        !           996: #endif
        !           997: #if TCG_TARGET_HAS_bswap32_i64
        !           998:         case INDEX_op_bswap32_i64:
        !           999:             t0 = *tb_ptr++;
        !          1000:             t1 = tci_read_r32(&tb_ptr);
        !          1001:             tci_write_reg64(t0, bswap32(t1));
        !          1002:             break;
        !          1003: #endif
        !          1004: #if TCG_TARGET_HAS_bswap64_i64
        !          1005:         case INDEX_op_bswap64_i64:
        !          1006:             TODO();
        !          1007:             t0 = *tb_ptr++;
        !          1008:             t1 = tci_read_r64(&tb_ptr);
        !          1009:             tci_write_reg64(t0, bswap64(t1));
        !          1010:             break;
        !          1011: #endif
        !          1012: #if TCG_TARGET_HAS_not_i64
        !          1013:         case INDEX_op_not_i64:
        !          1014:             t0 = *tb_ptr++;
        !          1015:             t1 = tci_read_r64(&tb_ptr);
        !          1016:             tci_write_reg64(t0, ~t1);
        !          1017:             break;
        !          1018: #endif
        !          1019: #if TCG_TARGET_HAS_neg_i64
        !          1020:         case INDEX_op_neg_i64:
        !          1021:             t0 = *tb_ptr++;
        !          1022:             t1 = tci_read_r64(&tb_ptr);
        !          1023:             tci_write_reg64(t0, -t1);
        !          1024:             break;
        !          1025: #endif
        !          1026: #endif /* TCG_TARGET_REG_BITS == 64 */
        !          1027: 
        !          1028:             /* QEMU specific operations. */
        !          1029: 
        !          1030: #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
        !          1031:         case INDEX_op_debug_insn_start:
        !          1032:             TODO();
        !          1033:             break;
        !          1034: #else
        !          1035:         case INDEX_op_debug_insn_start:
        !          1036:             TODO();
        !          1037:             break;
        !          1038: #endif
        !          1039:         case INDEX_op_exit_tb:
        !          1040:             next_tb = *(uint64_t *)tb_ptr;
        !          1041:             goto exit;
        !          1042:             break;
        !          1043:         case INDEX_op_goto_tb:
        !          1044:             t0 = tci_read_i32(&tb_ptr);
        !          1045:             assert(tb_ptr == old_code_ptr + op_size);
        !          1046:             tb_ptr += (int32_t)t0;
        !          1047:             continue;
        !          1048:         case INDEX_op_qemu_ld8u:
        !          1049:             t0 = *tb_ptr++;
        !          1050:             taddr = tci_read_ulong(&tb_ptr);
        !          1051: #ifdef CONFIG_SOFTMMU
        !          1052:             tmp8 = __ldb_mmu(taddr, tci_read_i(&tb_ptr));
        !          1053: #else
        !          1054:             host_addr = (tcg_target_ulong)taddr;
        !          1055:             assert(taddr == host_addr);
        !          1056:             tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
        !          1057: #endif
        !          1058:             tci_write_reg8(t0, tmp8);
        !          1059:             break;
        !          1060:         case INDEX_op_qemu_ld8s:
        !          1061:             t0 = *tb_ptr++;
        !          1062:             taddr = tci_read_ulong(&tb_ptr);
        !          1063: #ifdef CONFIG_SOFTMMU
        !          1064:             tmp8 = __ldb_mmu(taddr, tci_read_i(&tb_ptr));
        !          1065: #else
        !          1066:             host_addr = (tcg_target_ulong)taddr;
        !          1067:             assert(taddr == host_addr);
        !          1068:             tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
        !          1069: #endif
        !          1070:             tci_write_reg8s(t0, tmp8);
        !          1071:             break;
        !          1072:         case INDEX_op_qemu_ld16u:
        !          1073:             t0 = *tb_ptr++;
        !          1074:             taddr = tci_read_ulong(&tb_ptr);
        !          1075: #ifdef CONFIG_SOFTMMU
        !          1076:             tmp16 = __ldw_mmu(taddr, tci_read_i(&tb_ptr));
        !          1077: #else
        !          1078:             host_addr = (tcg_target_ulong)taddr;
        !          1079:             assert(taddr == host_addr);
        !          1080:             tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
        !          1081: #endif
        !          1082:             tci_write_reg16(t0, tmp16);
        !          1083:             break;
        !          1084:         case INDEX_op_qemu_ld16s:
        !          1085:             t0 = *tb_ptr++;
        !          1086:             taddr = tci_read_ulong(&tb_ptr);
        !          1087: #ifdef CONFIG_SOFTMMU
        !          1088:             tmp16 = __ldw_mmu(taddr, tci_read_i(&tb_ptr));
        !          1089: #else
        !          1090:             host_addr = (tcg_target_ulong)taddr;
        !          1091:             assert(taddr == host_addr);
        !          1092:             tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
        !          1093: #endif
        !          1094:             tci_write_reg16s(t0, tmp16);
        !          1095:             break;
        !          1096: #if TCG_TARGET_REG_BITS == 64
        !          1097:         case INDEX_op_qemu_ld32u:
        !          1098:             t0 = *tb_ptr++;
        !          1099:             taddr = tci_read_ulong(&tb_ptr);
        !          1100: #ifdef CONFIG_SOFTMMU
        !          1101:             tmp32 = __ldl_mmu(taddr, tci_read_i(&tb_ptr));
        !          1102: #else
        !          1103:             host_addr = (tcg_target_ulong)taddr;
        !          1104:             assert(taddr == host_addr);
        !          1105:             tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
        !          1106: #endif
        !          1107:             tci_write_reg32(t0, tmp32);
        !          1108:             break;
        !          1109:         case INDEX_op_qemu_ld32s:
        !          1110:             t0 = *tb_ptr++;
        !          1111:             taddr = tci_read_ulong(&tb_ptr);
        !          1112: #ifdef CONFIG_SOFTMMU
        !          1113:             tmp32 = __ldl_mmu(taddr, tci_read_i(&tb_ptr));
        !          1114: #else
        !          1115:             host_addr = (tcg_target_ulong)taddr;
        !          1116:             assert(taddr == host_addr);
        !          1117:             tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
        !          1118: #endif
        !          1119:             tci_write_reg32s(t0, tmp32);
        !          1120:             break;
        !          1121: #endif /* TCG_TARGET_REG_BITS == 64 */
        !          1122:         case INDEX_op_qemu_ld32:
        !          1123:             t0 = *tb_ptr++;
        !          1124:             taddr = tci_read_ulong(&tb_ptr);
        !          1125: #ifdef CONFIG_SOFTMMU
        !          1126:             tmp32 = __ldl_mmu(taddr, tci_read_i(&tb_ptr));
        !          1127: #else
        !          1128:             host_addr = (tcg_target_ulong)taddr;
        !          1129:             assert(taddr == host_addr);
        !          1130:             tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
        !          1131: #endif
        !          1132:             tci_write_reg32(t0, tmp32);
        !          1133:             break;
        !          1134:         case INDEX_op_qemu_ld64:
        !          1135:             t0 = *tb_ptr++;
        !          1136: #if TCG_TARGET_REG_BITS == 32
        !          1137:             t1 = *tb_ptr++;
        !          1138: #endif
        !          1139:             taddr = tci_read_ulong(&tb_ptr);
        !          1140: #ifdef CONFIG_SOFTMMU
        !          1141:             tmp64 = __ldq_mmu(taddr, tci_read_i(&tb_ptr));
        !          1142: #else
        !          1143:             host_addr = (tcg_target_ulong)taddr;
        !          1144:             assert(taddr == host_addr);
        !          1145:             tmp64 = tswap64(*(uint64_t *)(host_addr + GUEST_BASE));
        !          1146: #endif
        !          1147:             tci_write_reg(t0, tmp64);
        !          1148: #if TCG_TARGET_REG_BITS == 32
        !          1149:             tci_write_reg(t1, tmp64 >> 32);
        !          1150: #endif
        !          1151:             break;
        !          1152:         case INDEX_op_qemu_st8:
        !          1153:             t0 = tci_read_r8(&tb_ptr);
        !          1154:             taddr = tci_read_ulong(&tb_ptr);
        !          1155: #ifdef CONFIG_SOFTMMU
        !          1156:             t2 = tci_read_i(&tb_ptr);
        !          1157:             __stb_mmu(taddr, t0, t2);
        !          1158: #else
        !          1159:             host_addr = (tcg_target_ulong)taddr;
        !          1160:             assert(taddr == host_addr);
        !          1161:             *(uint8_t *)(host_addr + GUEST_BASE) = t0;
        !          1162: #endif
        !          1163:             break;
        !          1164:         case INDEX_op_qemu_st16:
        !          1165:             t0 = tci_read_r16(&tb_ptr);
        !          1166:             taddr = tci_read_ulong(&tb_ptr);
        !          1167: #ifdef CONFIG_SOFTMMU
        !          1168:             t2 = tci_read_i(&tb_ptr);
        !          1169:             __stw_mmu(taddr, t0, t2);
        !          1170: #else
        !          1171:             host_addr = (tcg_target_ulong)taddr;
        !          1172:             assert(taddr == host_addr);
        !          1173:             *(uint16_t *)(host_addr + GUEST_BASE) = tswap16(t0);
        !          1174: #endif
        !          1175:             break;
        !          1176:         case INDEX_op_qemu_st32:
        !          1177:             t0 = tci_read_r32(&tb_ptr);
        !          1178:             taddr = tci_read_ulong(&tb_ptr);
        !          1179: #ifdef CONFIG_SOFTMMU
        !          1180:             t2 = tci_read_i(&tb_ptr);
        !          1181:             __stl_mmu(taddr, t0, t2);
        !          1182: #else
        !          1183:             host_addr = (tcg_target_ulong)taddr;
        !          1184:             assert(taddr == host_addr);
        !          1185:             *(uint32_t *)(host_addr + GUEST_BASE) = tswap32(t0);
        !          1186: #endif
        !          1187:             break;
        !          1188:         case INDEX_op_qemu_st64:
        !          1189:             tmp64 = tci_read_r64(&tb_ptr);
        !          1190:             taddr = tci_read_ulong(&tb_ptr);
        !          1191: #ifdef CONFIG_SOFTMMU
        !          1192:             t2 = tci_read_i(&tb_ptr);
        !          1193:             __stq_mmu(taddr, tmp64, t2);
        !          1194: #else
        !          1195:             host_addr = (tcg_target_ulong)taddr;
        !          1196:             assert(taddr == host_addr);
        !          1197:             *(uint64_t *)(host_addr + GUEST_BASE) = tswap64(tmp64);
        !          1198: #endif
        !          1199:             break;
        !          1200:         default:
        !          1201:             TODO();
        !          1202:             break;
        !          1203:         }
        !          1204:         assert(tb_ptr == old_code_ptr + op_size);
        !          1205:     }
        !          1206: exit:
        !          1207:     return next_tb;
        !          1208: }

unix.superglobalmegacorp.com