Archipelago » qemu

/*

 * Tiny Code Generator for QEMU

 *

 * Copyright (c) 2008 Andrzej Zaborowski

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#if defined(__ARM_ARCH_7__) ||  \

    defined(__ARM_ARCH_7A__) || \

    defined(__ARM_ARCH_7EM__) || \

    defined(__ARM_ARCH_7M__) || \

    defined(__ARM_ARCH_7R__)

#define USE_ARMV7_INSTRUCTIONS

#endif

#if defined(USE_ARMV7_INSTRUCTIONS) || \

    defined(__ARM_ARCH_6J__) || \

    defined(__ARM_ARCH_6K__) || \

    defined(__ARM_ARCH_6T2__) || \

    defined(__ARM_ARCH_6Z__) || \

    defined(__ARM_ARCH_6ZK__)

#define USE_ARMV6_INSTRUCTIONS

#endif

#if defined(USE_ARMV6_INSTRUCTIONS) || \

    defined(__ARM_ARCH_5T__) || \

    defined(__ARM_ARCH_5TE__) || \

    defined(__ARM_ARCH_5TEJ__)

#define USE_ARMV5_INSTRUCTIONS

#endif

#ifdef USE_ARMV5_INSTRUCTIONS

static const int use_armv5_instructions = 1;

#else

static const int use_armv5_instructions = 0;

#endif

#undef USE_ARMV5_INSTRUCTIONS

#ifdef USE_ARMV6_INSTRUCTIONS

static const int use_armv6_instructions = 1;

#else

static const int use_armv6_instructions = 0;

#endif

#undef USE_ARMV6_INSTRUCTIONS

#ifdef USE_ARMV7_INSTRUCTIONS

static const int use_armv7_instructions = 1;

#else

static const int use_armv7_instructions = 0;

#endif

#undef USE_ARMV7_INSTRUCTIONS

#ifndef NDEBUG

static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {

    "%r0",

    "%r1",

    "%r2",

    "%r3",

    "%r4",

    "%r5",

    "%r6",

    "%r7",

    "%r8",

    "%r9",

    "%r10",

    "%r11",

    "%r12",

    "%r13",

    "%r14",

    "%pc",

};

#endif

static const int tcg_target_reg_alloc_order[] = {

    TCG_REG_R4,

    TCG_REG_R5,

    TCG_REG_R6,

    TCG_REG_R7,

    TCG_REG_R8,

    TCG_REG_R9,

    TCG_REG_R10,

    TCG_REG_R11,

    TCG_REG_R13,

    TCG_REG_R0,

    TCG_REG_R1,

    TCG_REG_R2,

    TCG_REG_R3,

    TCG_REG_R12,

    TCG_REG_R14,

};

static const int tcg_target_call_iarg_regs[4] = {

    TCG_REG_R0, TCG_REG_R1, TCG_REG_R2, TCG_REG_R3

};

static const int tcg_target_call_oarg_regs[2] = {

    TCG_REG_R0, TCG_REG_R1

};

static inline void reloc_abs32(void *code_ptr, tcg_target_long target)

{

    *(uint32_t *) code_ptr = target;

}

static inline void reloc_pc24(void *code_ptr, tcg_target_long target)

{

    uint32_t offset = ((target - ((tcg_target_long) code_ptr + 8)) >> 2);

    *(uint32_t *) code_ptr = ((*(uint32_t *) code_ptr) & ~0xffffff)

                             | (offset & 0xffffff);

}

static void patch_reloc(uint8_t *code_ptr, int type,

                tcg_target_long value, tcg_target_long addend)

{

    switch (type) {

    case R_ARM_ABS32:

        reloc_abs32(code_ptr, value);

        break;

    case R_ARM_CALL:

    case R_ARM_JUMP24:

    default:

        tcg_abort();

    case R_ARM_PC24:

        reloc_pc24(code_ptr, value);

        break;

    }

}

/* maximum number of register used for input function arguments */

static inline int tcg_target_get_call_iarg_regs_count(int flags)

{

    return 4;

}

/* parse target specific constraints */

static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)

{

    const char *ct_str;

    ct_str = *pct_str;

    switch (ct_str[0]) {

    case 'I':

         ct->ct |= TCG_CT_CONST_ARM;

         break;

    case 'r':

        ct->ct |= TCG_CT_REG;

        tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);

        break;

    /* qemu_ld address */

    case 'l':

        ct->ct |= TCG_CT_REG;

        tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);

#ifdef CONFIG_SOFTMMU

        /* r0 and r1 will be overwritten when reading the tlb entry,

           so don't use these. */

        tcg_regset_reset_reg(ct->u.regs, TCG_REG_R0);

        tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1);

#endif

        break;

    case 'L':

        ct->ct |= TCG_CT_REG;

        tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);

#ifdef CONFIG_SOFTMMU

        /* r1 is still needed to load data_reg or data_reg2,

           so don't use it. */

        tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1);

#endif

        break;

    /* qemu_st address & data_reg */

    case 's':

        ct->ct |= TCG_CT_REG;

        tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);

        /* r0 and r1 will be overwritten when reading the tlb entry

           (softmmu only) and doing the byte swapping, so don't

           use these. */

        tcg_regset_reset_reg(ct->u.regs, TCG_REG_R0);

        tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1);

        break;

    /* qemu_st64 data_reg2 */

    case 'S':

        ct->ct |= TCG_CT_REG;

        tcg_regset_set32(ct->u.regs, 0, (1 << TCG_TARGET_NB_REGS) - 1);

        /* r0 and r1 will be overwritten when reading the tlb entry

            (softmmu only) and doing the byte swapping, so don't

            use these. */

        tcg_regset_reset_reg(ct->u.regs, TCG_REG_R0);

        tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1);

#ifdef CONFIG_SOFTMMU

        /* r2 is still needed to load data_reg, so don't use it. */

        tcg_regset_reset_reg(ct->u.regs, TCG_REG_R2);

#endif

        break;

    default:

        return -1;

    }

    ct_str++;

    *pct_str = ct_str;

    return 0;

}

static inline uint32_t rotl(uint32_t val, int n)

{

  return (val << n) | (val >> (32 - n));

}

/* ARM immediates for ALU instructions are made of an unsigned 8-bit

   right-rotated by an even amount between 0 and 30. */

static inline int encode_imm(uint32_t imm)

{

    int shift;

    /* simple case, only lower bits */

    if ((imm & ~0xff) == 0)

        return 0;

    /* then try a simple even shift */

    shift = ctz32(imm) & ~1;

    if (((imm >> shift) & ~0xff) == 0)

        return 32 - shift;

    /* now try harder with rotations */

    if ((rotl(imm, 2) & ~0xff) == 0)

        return 2;

    if ((rotl(imm, 4) & ~0xff) == 0)

        return 4;

    if ((rotl(imm, 6) & ~0xff) == 0)

        return 6;

    /* imm can't be encoded */

    return -1;

}

static inline int check_fit_imm(uint32_t imm)

{

    return encode_imm(imm) >= 0;

}

/* Test if a constant matches the constraint.

 * TODO: define constraints for:

 *

 * ldr/str offset:   between -0xfff and 0xfff

 * ldrh/strh offset: between -0xff and 0xff

 * mov operand2:     values represented with x << (2 * y), x < 0x100

 * add, sub, eor...: ditto

 */

static inline int tcg_target_const_match(tcg_target_long val,

                const TCGArgConstraint *arg_ct)

{

    int ct;

    ct = arg_ct->ct;

    if (ct & TCG_CT_CONST)

        return 1;

    else if ((ct & TCG_CT_CONST_ARM) && check_fit_imm(val))

        return 1;

    else

        return 0;

}

enum arm_data_opc_e {

    ARITH_AND = 0x0,

    ARITH_EOR = 0x1,

    ARITH_SUB = 0x2,

    ARITH_RSB = 0x3,

    ARITH_ADD = 0x4,

    ARITH_ADC = 0x5,

    ARITH_SBC = 0x6,

    ARITH_RSC = 0x7,

    ARITH_TST = 0x8,

    ARITH_CMP = 0xa,

    ARITH_CMN = 0xb,

    ARITH_ORR = 0xc,

    ARITH_MOV = 0xd,

    ARITH_BIC = 0xe,

    ARITH_MVN = 0xf,

};

#define TO_CPSR(opc) \

  ((opc == ARITH_CMP || opc == ARITH_CMN || opc == ARITH_TST) << 20)

#define SHIFT_IMM_LSL(im)        (((im) << 7) | 0x00)

#define SHIFT_IMM_LSR(im)        (((im) << 7) | 0x20)

#define SHIFT_IMM_ASR(im)        (((im) << 7) | 0x40)

#define SHIFT_IMM_ROR(im)        (((im) << 7) | 0x60)

#define SHIFT_REG_LSL(rs)        (((rs) << 8) | 0x10)

#define SHIFT_REG_LSR(rs)        (((rs) << 8) | 0x30)

#define SHIFT_REG_ASR(rs)        (((rs) << 8) | 0x50)

#define SHIFT_REG_ROR(rs)        (((rs) << 8) | 0x70)

enum arm_cond_code_e {

    COND_EQ = 0x0,

    COND_NE = 0x1,

    COND_CS = 0x2,        /* Unsigned greater or equal */

    COND_CC = 0x3,        /* Unsigned less than */

    COND_MI = 0x4,        /* Negative */

    COND_PL = 0x5,        /* Zero or greater */

    COND_VS = 0x6,        /* Overflow */

    COND_VC = 0x7,        /* No overflow */

    COND_HI = 0x8,        /* Unsigned greater than */

    COND_LS = 0x9,        /* Unsigned less or equal */

    COND_GE = 0xa,

    COND_LT = 0xb,

    COND_GT = 0xc,

    COND_LE = 0xd,

    COND_AL = 0xe,

};

static const uint8_t tcg_cond_to_arm_cond[10] = {

    [TCG_COND_EQ] = COND_EQ,

    [TCG_COND_NE] = COND_NE,

    [TCG_COND_LT] = COND_LT,

    [TCG_COND_GE] = COND_GE,

    [TCG_COND_LE] = COND_LE,

    [TCG_COND_GT] = COND_GT,

    /* unsigned */

    [TCG_COND_LTU] = COND_CC,

    [TCG_COND_GEU] = COND_CS,

    [TCG_COND_LEU] = COND_LS,

    [TCG_COND_GTU] = COND_HI,

};

static inline void tcg_out_bx(TCGContext *s, int cond, int rn)

{

    tcg_out32(s, (cond << 28) | 0x012fff10 | rn);

}

static inline void tcg_out_b(TCGContext *s, int cond, int32_t offset)

{

    tcg_out32(s, (cond << 28) | 0x0a000000 |

                    (((offset - 8) >> 2) & 0x00ffffff));

}

static inline void tcg_out_b_noaddr(TCGContext *s, int cond)

{

#ifdef HOST_WORDS_BIGENDIAN

    tcg_out8(s, (cond << 4) | 0x0a);

    s->code_ptr += 3;

#else

    s->code_ptr += 3;

    tcg_out8(s, (cond << 4) | 0x0a);

#endif

}

static inline void tcg_out_bl(TCGContext *s, int cond, int32_t offset)

{

    tcg_out32(s, (cond << 28) | 0x0b000000 |

                    (((offset - 8) >> 2) & 0x00ffffff));

}

static inline void tcg_out_blx(TCGContext *s, int cond, int rn)

{

    tcg_out32(s, (cond << 28) | 0x012fff30 | rn);

}

static inline void tcg_out_dat_reg(TCGContext *s,

                int cond, int opc, int rd, int rn, int rm, int shift)

{

    tcg_out32(s, (cond << 28) | (0 << 25) | (opc << 21) | TO_CPSR(opc) |

                    (rn << 16) | (rd << 12) | shift | rm);

}

static inline void tcg_out_dat_reg2(TCGContext *s,

                int cond, int opc0, int opc1, int rd0, int rd1,

                int rn0, int rn1, int rm0, int rm1, int shift)

{

    if (rd0 == rn1 || rd0 == rm1) {

        tcg_out32(s, (cond << 28) | (0 << 25) | (opc0 << 21) | (1 << 20) |

                        (rn0 << 16) | (8 << 12) | shift | rm0);

        tcg_out32(s, (cond << 28) | (0 << 25) | (opc1 << 21) |

                        (rn1 << 16) | (rd1 << 12) | shift | rm1);

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        rd0, 0, TCG_REG_R8, SHIFT_IMM_LSL(0));

    } else {

        tcg_out32(s, (cond << 28) | (0 << 25) | (opc0 << 21) | (1 << 20) |

                        (rn0 << 16) | (rd0 << 12) | shift | rm0);

        tcg_out32(s, (cond << 28) | (0 << 25) | (opc1 << 21) |

                        (rn1 << 16) | (rd1 << 12) | shift | rm1);

    }

}

static inline void tcg_out_dat_imm(TCGContext *s,

                int cond, int opc, int rd, int rn, int im)

{

    tcg_out32(s, (cond << 28) | (1 << 25) | (opc << 21) | TO_CPSR(opc) |

                    (rn << 16) | (rd << 12) | im);

}

static inline void tcg_out_movi32(TCGContext *s,

                int cond, int rd, uint32_t arg)

{

    /* TODO: This is very suboptimal, we can easily have a constant

     * pool somewhere after all the instructions.  */

    if ((int)arg < 0 && (int)arg >= -0x100) {

        tcg_out_dat_imm(s, cond, ARITH_MVN, rd, 0, (~arg) & 0xff);

    } else if (use_armv7_instructions) {

        /* use movw/movt */

        /* movw */

        tcg_out32(s, (cond << 28) | 0x03000000 | (rd << 12)

                  | ((arg << 4) & 0x000f0000) | (arg & 0xfff));

        if (arg & 0xffff0000) {

            /* movt */

            tcg_out32(s, (cond << 28) | 0x03400000 | (rd << 12)

                      | ((arg >> 12) & 0x000f0000) | ((arg >> 16) & 0xfff));

        }

    } else {

        int opc = ARITH_MOV;

        int rn = 0;

        do {

            int i, rot;

            i = ctz32(arg) & ~1;

            rot = ((32 - i) << 7) & 0xf00;

            tcg_out_dat_imm(s, cond, opc, rd, rn, ((arg >> i) & 0xff) | rot);

            arg &= ~(0xff << i);

            opc = ARITH_ORR;

            rn = rd;

        } while (arg);

    }

}

static inline void tcg_out_mul32(TCGContext *s,

                int cond, int rd, int rs, int rm)

{

    if (rd != rm)

        tcg_out32(s, (cond << 28) | (rd << 16) | (0 << 12) |

                        (rs << 8) | 0x90 | rm);

    else if (rd != rs)

        tcg_out32(s, (cond << 28) | (rd << 16) | (0 << 12) |

                        (rm << 8) | 0x90 | rs);

    else {

        tcg_out32(s, (cond << 28) | ( 8 << 16) | (0 << 12) |

                        (rs << 8) | 0x90 | rm);

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        rd, 0, TCG_REG_R8, SHIFT_IMM_LSL(0));

    }

}

static inline void tcg_out_umull32(TCGContext *s,

                int cond, int rd0, int rd1, int rs, int rm)

{

    if (rd0 != rm && rd1 != rm)

        tcg_out32(s, (cond << 28) | 0x800090 |

                        (rd1 << 16) | (rd0 << 12) | (rs << 8) | rm);

    else if (rd0 != rs && rd1 != rs)

        tcg_out32(s, (cond << 28) | 0x800090 |

                        (rd1 << 16) | (rd0 << 12) | (rm << 8) | rs);

    else {

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        TCG_REG_R8, 0, rm, SHIFT_IMM_LSL(0));

        tcg_out32(s, (cond << 28) | 0x800098 |

                        (rd1 << 16) | (rd0 << 12) | (rs << 8));

    }

}

static inline void tcg_out_smull32(TCGContext *s,

                int cond, int rd0, int rd1, int rs, int rm)

{

    if (rd0 != rm && rd1 != rm)

        tcg_out32(s, (cond << 28) | 0xc00090 |

                        (rd1 << 16) | (rd0 << 12) | (rs << 8) | rm);

    else if (rd0 != rs && rd1 != rs)

        tcg_out32(s, (cond << 28) | 0xc00090 |

                        (rd1 << 16) | (rd0 << 12) | (rm << 8) | rs);

    else {

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        TCG_REG_R8, 0, rm, SHIFT_IMM_LSL(0));

        tcg_out32(s, (cond << 28) | 0xc00098 |

                        (rd1 << 16) | (rd0 << 12) | (rs << 8));

    }

}

static inline void tcg_out_ext8s(TCGContext *s, int cond,

                                 int rd, int rn)

{

    if (use_armv6_instructions) {

        /* sxtb */

        tcg_out32(s, 0x06af0070 | (cond << 28) | (rd << 12) | rn);

    } else {

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        rd, 0, rn, SHIFT_IMM_LSL(24));

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        rd, 0, rd, SHIFT_IMM_ASR(24));

    }

}

static inline void tcg_out_ext8u(TCGContext *s, int cond,

                                 int rd, int rn)

{

    tcg_out_dat_imm(s, cond, ARITH_AND, rd, rn, 0xff);

}

static inline void tcg_out_ext16s(TCGContext *s, int cond,

                                  int rd, int rn)

{

    if (use_armv6_instructions) {

        /* sxth */

        tcg_out32(s, 0x06bf0070 | (cond << 28) | (rd << 12) | rn);

    } else {

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        rd, 0, rn, SHIFT_IMM_LSL(16));

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        rd, 0, rd, SHIFT_IMM_ASR(16));

    }

}

static inline void tcg_out_ext16u(TCGContext *s, int cond,

                                  int rd, int rn)

{

    if (use_armv6_instructions) {

        /* uxth */

        tcg_out32(s, 0x06ff0070 | (cond << 28) | (rd << 12) | rn);

    } else {

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        rd, 0, rn, SHIFT_IMM_LSL(16));

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        rd, 0, rd, SHIFT_IMM_LSR(16));

    }

}

static inline void tcg_out_bswap16s(TCGContext *s, int cond, int rd, int rn)

{

    if (use_armv6_instructions) {

        /* revsh */

        tcg_out32(s, 0x06ff0fb0 | (cond << 28) | (rd << 12) | rn);

    } else {

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        TCG_REG_R8, 0, rn, SHIFT_IMM_LSL(24));

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        TCG_REG_R8, 0, TCG_REG_R8, SHIFT_IMM_ASR(16));

        tcg_out_dat_reg(s, cond, ARITH_ORR,

                        rd, TCG_REG_R8, rn, SHIFT_IMM_LSR(8));

    }

}

static inline void tcg_out_bswap16(TCGContext *s, int cond, int rd, int rn)

{

    if (use_armv6_instructions) {

        /* rev16 */

        tcg_out32(s, 0x06bf0fb0 | (cond << 28) | (rd << 12) | rn);

    } else {

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        TCG_REG_R8, 0, rn, SHIFT_IMM_LSL(24));

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        TCG_REG_R8, 0, TCG_REG_R8, SHIFT_IMM_LSR(16));

        tcg_out_dat_reg(s, cond, ARITH_ORR,

                        rd, TCG_REG_R8, rn, SHIFT_IMM_LSR(8));

    }

}

static inline void tcg_out_bswap32(TCGContext *s, int cond, int rd, int rn)

{

    if (use_armv6_instructions) {

        /* rev */

        tcg_out32(s, 0x06bf0f30 | (cond << 28) | (rd << 12) | rn);

    } else {

        tcg_out_dat_reg(s, cond, ARITH_EOR,

                        TCG_REG_R8, rn, rn, SHIFT_IMM_ROR(16));

        tcg_out_dat_imm(s, cond, ARITH_BIC,

                        TCG_REG_R8, TCG_REG_R8, 0xff | 0x800);

        tcg_out_dat_reg(s, cond, ARITH_MOV,

                        rd, 0, rn, SHIFT_IMM_ROR(8));

        tcg_out_dat_reg(s, cond, ARITH_EOR,

                        rd, rd, TCG_REG_R8, SHIFT_IMM_LSR(8));

    }

}

static inline void tcg_out_ld32_12(TCGContext *s, int cond,

                int rd, int rn, tcg_target_long im)

{

    if (im >= 0)

        tcg_out32(s, (cond << 28) | 0x05900000 |

                        (rn << 16) | (rd << 12) | (im & 0xfff));

    else

        tcg_out32(s, (cond << 28) | 0x05100000 |

                        (rn << 16) | (rd << 12) | ((-im) & 0xfff));

}

static inline void tcg_out_st32_12(TCGContext *s, int cond,

                int rd, int rn, tcg_target_long im)

{

    if (im >= 0)

        tcg_out32(s, (cond << 28) | 0x05800000 |

                        (rn << 16) | (rd << 12) | (im & 0xfff));

    else

        tcg_out32(s, (cond << 28) | 0x05000000 |

                        (rn << 16) | (rd << 12) | ((-im) & 0xfff));

}

static inline void tcg_out_ld32_r(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x07900000 |

                    (rn << 16) | (rd << 12) | rm);

}

static inline void tcg_out_st32_r(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x07800000 |

                    (rn << 16) | (rd << 12) | rm);

}

/* Register pre-increment with base writeback.  */

static inline void tcg_out_ld32_rwb(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x07b00000 |

                    (rn << 16) | (rd << 12) | rm);

}

static inline void tcg_out_st32_rwb(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x07a00000 |

                    (rn << 16) | (rd << 12) | rm);

}

static inline void tcg_out_ld16u_8(TCGContext *s, int cond,

                int rd, int rn, tcg_target_long im)

{

    if (im >= 0)

        tcg_out32(s, (cond << 28) | 0x01d000b0 |

                        (rn << 16) | (rd << 12) |

                        ((im & 0xf0) << 4) | (im & 0xf));

    else

        tcg_out32(s, (cond << 28) | 0x015000b0 |

                        (rn << 16) | (rd << 12) |

                        (((-im) & 0xf0) << 4) | ((-im) & 0xf));

}

static inline void tcg_out_st16_8(TCGContext *s, int cond,

                int rd, int rn, tcg_target_long im)

{

    if (im >= 0)

        tcg_out32(s, (cond << 28) | 0x01c000b0 |

                        (rn << 16) | (rd << 12) |

                        ((im & 0xf0) << 4) | (im & 0xf));

    else

        tcg_out32(s, (cond << 28) | 0x014000b0 |

                        (rn << 16) | (rd << 12) |

                        (((-im) & 0xf0) << 4) | ((-im) & 0xf));

}

static inline void tcg_out_ld16u_r(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x019000b0 |

                    (rn << 16) | (rd << 12) | rm);

}

static inline void tcg_out_st16_r(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x018000b0 |

                    (rn << 16) | (rd << 12) | rm);

}

static inline void tcg_out_ld16s_8(TCGContext *s, int cond,

                int rd, int rn, tcg_target_long im)

{

    if (im >= 0)

        tcg_out32(s, (cond << 28) | 0x01d000f0 |

                        (rn << 16) | (rd << 12) |

                        ((im & 0xf0) << 4) | (im & 0xf));

    else

        tcg_out32(s, (cond << 28) | 0x015000f0 |

                        (rn << 16) | (rd << 12) |

                        (((-im) & 0xf0) << 4) | ((-im) & 0xf));

}

static inline void tcg_out_ld16s_r(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x019000f0 |

                    (rn << 16) | (rd << 12) | rm);

}

static inline void tcg_out_ld8_12(TCGContext *s, int cond,

                int rd, int rn, tcg_target_long im)

{

    if (im >= 0)

        tcg_out32(s, (cond << 28) | 0x05d00000 |

                        (rn << 16) | (rd << 12) | (im & 0xfff));

    else

        tcg_out32(s, (cond << 28) | 0x05500000 |

                        (rn << 16) | (rd << 12) | ((-im) & 0xfff));

}

static inline void tcg_out_st8_12(TCGContext *s, int cond,

                int rd, int rn, tcg_target_long im)

{

    if (im >= 0)

        tcg_out32(s, (cond << 28) | 0x05c00000 |

                        (rn << 16) | (rd << 12) | (im & 0xfff));

    else

        tcg_out32(s, (cond << 28) | 0x05400000 |

                        (rn << 16) | (rd << 12) | ((-im) & 0xfff));

}

static inline void tcg_out_ld8_r(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x07d00000 |

                    (rn << 16) | (rd << 12) | rm);

}

static inline void tcg_out_st8_r(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x07c00000 |

                    (rn << 16) | (rd << 12) | rm);

}

static inline void tcg_out_ld8s_8(TCGContext *s, int cond,

                int rd, int rn, tcg_target_long im)

{

    if (im >= 0)

        tcg_out32(s, (cond << 28) | 0x01d000d0 |

                        (rn << 16) | (rd << 12) |

                        ((im & 0xf0) << 4) | (im & 0xf));

    else

        tcg_out32(s, (cond << 28) | 0x015000d0 |

                        (rn << 16) | (rd << 12) |

                        (((-im) & 0xf0) << 4) | ((-im) & 0xf));

}

static inline void tcg_out_ld8s_r(TCGContext *s, int cond,

                int rd, int rn, int rm)

{

    tcg_out32(s, (cond << 28) | 0x019000d0 |

                    (rn << 16) | (rd << 12) | rm);

}

static inline void tcg_out_ld32u(TCGContext *s, int cond,

                int rd, int rn, int32_t offset)

{

    if (offset > 0xfff || offset < -0xfff) {

        tcg_out_movi32(s, cond, TCG_REG_R8, offset);

        tcg_out_ld32_r(s, cond, rd, rn, TCG_REG_R8);

    } else

        tcg_out_ld32_12(s, cond, rd, rn, offset);

}

static inline void tcg_out_st32(TCGContext *s, int cond,

                int rd, int rn, int32_t offset)

{

    if (offset > 0xfff || offset < -0xfff) {

        tcg_out_movi32(s, cond, TCG_REG_R8, offset);

        tcg_out_st32_r(s, cond, rd, rn, TCG_REG_R8);

    } else

        tcg_out_st32_12(s, cond, rd, rn, offset);

}

static inline void tcg_out_ld16u(TCGContext *s, int cond,

                int rd, int rn, int32_t offset)

{

    if (offset > 0xff || offset < -0xff) {

        tcg_out_movi32(s, cond, TCG_REG_R8, offset);

        tcg_out_ld16u_r(s, cond, rd, rn, TCG_REG_R8);

    } else

        tcg_out_ld16u_8(s, cond, rd, rn, offset);

}

static inline void tcg_out_ld16s(TCGContext *s, int cond,

                int rd, int rn, int32_t offset)

{

    if (offset > 0xff || offset < -0xff) {

        tcg_out_movi32(s, cond, TCG_REG_R8, offset);

        tcg_out_ld16s_r(s, cond, rd, rn, TCG_REG_R8);

    } else

        tcg_out_ld16s_8(s, cond, rd, rn, offset);

}

static inline void tcg_out_st16(TCGContext *s, int cond,

                int rd, int rn, int32_t offset)

{

    if (offset > 0xff || offset < -0xff) {

        tcg_out_movi32(s, cond, TCG_REG_R8, offset);

        tcg_out_st16_r(s, cond, rd, rn, TCG_REG_R8);

    } else

        tcg_out_st16_8(s, cond, rd, rn, offset);

}

static inline void tcg_out_ld8u(TCGContext *s, int cond,

                int rd, int rn, int32_t offset)

{

    if (offset > 0xfff || offset < -0xfff) {

        tcg_out_movi32(s, cond, TCG_REG_R8, offset);

        tcg_out_ld8_r(s, cond, rd, rn, TCG_REG_R8);

    } else

        tcg_out_ld8_12(s, cond, rd, rn, offset);

}

static inline void tcg_out_ld8s(TCGContext *s, int cond,

                int rd, int rn, int32_t offset)

{

    if (offset > 0xff || offset < -0xff) {

        tcg_out_movi32(s, cond, TCG_REG_R8, offset);

        tcg_out_ld8s_r(s, cond, rd, rn, TCG_REG_R8);

    } else

        tcg_out_ld8s_8(s, cond, rd, rn, offset);

}

static inline void tcg_out_st8(TCGContext *s, int cond,

                int rd, int rn, int32_t offset)

{

    if (offset > 0xfff || offset < -0xfff) {

        tcg_out_movi32(s, cond, TCG_REG_R8, offset);

        tcg_out_st8_r(s, cond, rd, rn, TCG_REG_R8);

    } else

        tcg_out_st8_12(s, cond, rd, rn, offset);

}

static inline void tcg_out_goto(TCGContext *s, int cond, uint32_t addr)

{

    int32_t val;

    val = addr - (tcg_target_long) s->code_ptr;

    if (val - 8 < 0x01fffffd && val - 8 > -0x01fffffd)

        tcg_out_b(s, cond, val);

    else {

#if 1

        tcg_abort();

#else

        if (cond == COND_AL) {

            tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, TCG_REG_PC, -4);

            tcg_out32(s, addr); /* XXX: This is l->u.value, can we use it? */

        } else {