bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Tiny Code Generator for QEMU |
| 3 | * |
| 4 | * Copyright (c) 2008 Fabrice Bellard |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 7 | * of this software and associated documentation files (the "Software"), to deal |
| 8 | * in the Software without restriction, including without limitation the rights |
| 9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 10 | * copies of the Software, and to permit persons to whom the Software is |
| 11 | * furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in |
| 14 | * all copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 22 | * THE SOFTWARE. |
| 23 | */ |
aurel32 | f839394 | 2009-04-13 18:45:38 +0000 | [diff] [blame] | 24 | #include "qemu-common.h" |
Stefan Weil | 817b838 | 2011-09-17 22:00:27 +0200 | [diff] [blame] | 25 | |
| 26 | /* Target word size (must be identical to pointer size). */ |
| 27 | #if UINTPTR_MAX == UINT32_MAX |
| 28 | # define TCG_TARGET_REG_BITS 32 |
| 29 | #elif UINTPTR_MAX == UINT64_MAX |
| 30 | # define TCG_TARGET_REG_BITS 64 |
| 31 | #else |
| 32 | # error Unknown pointer size for tcg target |
| 33 | #endif |
| 34 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 35 | #include "tcg-target.h" |
Blue Swirl | 96e132e | 2009-09-20 19:06:34 +0000 | [diff] [blame] | 36 | #include "tcg-runtime.h" |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 37 | |
| 38 | #if TCG_TARGET_REG_BITS == 32 |
| 39 | typedef int32_t tcg_target_long; |
| 40 | typedef uint32_t tcg_target_ulong; |
| 41 | #define TCG_PRIlx PRIx32 |
| 42 | #define TCG_PRIld PRId32 |
| 43 | #elif TCG_TARGET_REG_BITS == 64 |
| 44 | typedef int64_t tcg_target_long; |
| 45 | typedef uint64_t tcg_target_ulong; |
| 46 | #define TCG_PRIlx PRIx64 |
| 47 | #define TCG_PRIld PRId64 |
| 48 | #else |
| 49 | #error unsupported |
| 50 | #endif |
| 51 | |
| 52 | #if TCG_TARGET_NB_REGS <= 32 |
| 53 | typedef uint32_t TCGRegSet; |
| 54 | #elif TCG_TARGET_NB_REGS <= 64 |
| 55 | typedef uint64_t TCGRegSet; |
| 56 | #else |
| 57 | #error unsupported |
| 58 | #endif |
| 59 | |
Richard Henderson | 25c4d9c | 2011-08-17 14:11:46 -0700 | [diff] [blame] | 60 | /* Turn some undef macros into false macros. */ |
| 61 | #if TCG_TARGET_REG_BITS == 32 |
| 62 | #define TCG_TARGET_HAS_div_i64 0 |
| 63 | #define TCG_TARGET_HAS_div2_i64 0 |
| 64 | #define TCG_TARGET_HAS_rot_i64 0 |
| 65 | #define TCG_TARGET_HAS_ext8s_i64 0 |
| 66 | #define TCG_TARGET_HAS_ext16s_i64 0 |
| 67 | #define TCG_TARGET_HAS_ext32s_i64 0 |
| 68 | #define TCG_TARGET_HAS_ext8u_i64 0 |
| 69 | #define TCG_TARGET_HAS_ext16u_i64 0 |
| 70 | #define TCG_TARGET_HAS_ext32u_i64 0 |
| 71 | #define TCG_TARGET_HAS_bswap16_i64 0 |
| 72 | #define TCG_TARGET_HAS_bswap32_i64 0 |
| 73 | #define TCG_TARGET_HAS_bswap64_i64 0 |
| 74 | #define TCG_TARGET_HAS_neg_i64 0 |
| 75 | #define TCG_TARGET_HAS_not_i64 0 |
| 76 | #define TCG_TARGET_HAS_andc_i64 0 |
| 77 | #define TCG_TARGET_HAS_orc_i64 0 |
| 78 | #define TCG_TARGET_HAS_eqv_i64 0 |
| 79 | #define TCG_TARGET_HAS_nand_i64 0 |
| 80 | #define TCG_TARGET_HAS_nor_i64 0 |
| 81 | #define TCG_TARGET_HAS_deposit_i64 0 |
| 82 | #endif |
| 83 | |
Jan Kiszka | a477332 | 2011-09-29 18:52:11 +0200 | [diff] [blame] | 84 | #ifndef TCG_TARGET_deposit_i32_valid |
| 85 | #define TCG_TARGET_deposit_i32_valid(ofs, len) 1 |
| 86 | #endif |
| 87 | #ifndef TCG_TARGET_deposit_i64_valid |
| 88 | #define TCG_TARGET_deposit_i64_valid(ofs, len) 1 |
| 89 | #endif |
| 90 | |
Richard Henderson | 25c4d9c | 2011-08-17 14:11:46 -0700 | [diff] [blame] | 91 | /* Only one of DIV or DIV2 should be defined. */ |
| 92 | #if defined(TCG_TARGET_HAS_div_i32) |
| 93 | #define TCG_TARGET_HAS_div2_i32 0 |
| 94 | #elif defined(TCG_TARGET_HAS_div2_i32) |
| 95 | #define TCG_TARGET_HAS_div_i32 0 |
| 96 | #endif |
| 97 | #if defined(TCG_TARGET_HAS_div_i64) |
| 98 | #define TCG_TARGET_HAS_div2_i64 0 |
| 99 | #elif defined(TCG_TARGET_HAS_div2_i64) |
| 100 | #define TCG_TARGET_HAS_div_i64 0 |
| 101 | #endif |
| 102 | |
Richard Henderson | a975160 | 2010-03-19 11:12:29 -0700 | [diff] [blame] | 103 | typedef enum TCGOpcode { |
Aurelien Jarno | c61aaf7 | 2010-06-03 19:40:04 +0200 | [diff] [blame] | 104 | #define DEF(name, oargs, iargs, cargs, flags) INDEX_op_ ## name, |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 105 | #include "tcg-opc.h" |
| 106 | #undef DEF |
| 107 | NB_OPS, |
Richard Henderson | a975160 | 2010-03-19 11:12:29 -0700 | [diff] [blame] | 108 | } TCGOpcode; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 109 | |
| 110 | #define tcg_regset_clear(d) (d) = 0 |
| 111 | #define tcg_regset_set(d, s) (d) = (s) |
| 112 | #define tcg_regset_set32(d, reg, val32) (d) |= (val32) << (reg) |
Aurelien Jarno | 7d30175 | 2009-10-28 22:44:34 +0100 | [diff] [blame] | 113 | #define tcg_regset_set_reg(d, r) (d) |= 1L << (r) |
| 114 | #define tcg_regset_reset_reg(d, r) (d) &= ~(1L << (r)) |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 115 | #define tcg_regset_test_reg(d, r) (((d) >> (r)) & 1) |
| 116 | #define tcg_regset_or(d, a, b) (d) = (a) | (b) |
| 117 | #define tcg_regset_and(d, a, b) (d) = (a) & (b) |
| 118 | #define tcg_regset_andnot(d, a, b) (d) = (a) & ~(b) |
| 119 | #define tcg_regset_not(d, a) (d) = ~(a) |
| 120 | |
| 121 | typedef struct TCGRelocation { |
| 122 | struct TCGRelocation *next; |
| 123 | int type; |
| 124 | uint8_t *ptr; |
| 125 | tcg_target_long addend; |
| 126 | } TCGRelocation; |
| 127 | |
| 128 | typedef struct TCGLabel { |
blueswir1 | c44f945 | 2008-05-19 16:32:18 +0000 | [diff] [blame] | 129 | int has_value; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 130 | union { |
| 131 | tcg_target_ulong value; |
| 132 | TCGRelocation *first_reloc; |
| 133 | } u; |
| 134 | } TCGLabel; |
| 135 | |
| 136 | typedef struct TCGPool { |
| 137 | struct TCGPool *next; |
blueswir1 | c44f945 | 2008-05-19 16:32:18 +0000 | [diff] [blame] | 138 | int size; |
| 139 | uint8_t data[0] __attribute__ ((aligned)); |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 140 | } TCGPool; |
| 141 | |
| 142 | #define TCG_POOL_CHUNK_SIZE 32768 |
| 143 | |
| 144 | #define TCG_MAX_LABELS 512 |
| 145 | |
blueswir1 | c4071c9 | 2008-03-16 19:21:07 +0000 | [diff] [blame] | 146 | #define TCG_MAX_TEMPS 512 |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 147 | |
bellard | b03cce8 | 2008-05-10 10:52:05 +0000 | [diff] [blame] | 148 | /* when the size of the arguments of a called function is smaller than |
| 149 | this value, they are statically allocated in the TB stack frame */ |
| 150 | #define TCG_STATIC_CALL_ARGS_SIZE 128 |
| 151 | |
Richard Henderson | c02244a | 2010-03-19 11:36:30 -0700 | [diff] [blame] | 152 | typedef enum TCGType { |
| 153 | TCG_TYPE_I32, |
| 154 | TCG_TYPE_I64, |
| 155 | TCG_TYPE_COUNT, /* number of different types */ |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 156 | |
Richard Henderson | 3b6dac3 | 2010-06-02 17:26:55 -0700 | [diff] [blame] | 157 | /* An alias for the size of the host register. */ |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 158 | #if TCG_TARGET_REG_BITS == 32 |
Richard Henderson | 3b6dac3 | 2010-06-02 17:26:55 -0700 | [diff] [blame] | 159 | TCG_TYPE_REG = TCG_TYPE_I32, |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 160 | #else |
Richard Henderson | 3b6dac3 | 2010-06-02 17:26:55 -0700 | [diff] [blame] | 161 | TCG_TYPE_REG = TCG_TYPE_I64, |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 162 | #endif |
Richard Henderson | 3b6dac3 | 2010-06-02 17:26:55 -0700 | [diff] [blame] | 163 | |
| 164 | /* An alias for the size of the native pointer. We don't currently |
| 165 | support any hosts with 64-bit registers and 32-bit pointers. */ |
| 166 | TCG_TYPE_PTR = TCG_TYPE_REG, |
| 167 | |
| 168 | /* An alias for the size of the target "long", aka register. */ |
Richard Henderson | c02244a | 2010-03-19 11:36:30 -0700 | [diff] [blame] | 169 | #if TARGET_LONG_BITS == 64 |
| 170 | TCG_TYPE_TL = TCG_TYPE_I64, |
| 171 | #else |
| 172 | TCG_TYPE_TL = TCG_TYPE_I32, |
| 173 | #endif |
| 174 | } TCGType; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 175 | |
| 176 | typedef tcg_target_ulong TCGArg; |
| 177 | |
Stefan Weil | 8ef935b | 2011-10-11 19:43:15 +0200 | [diff] [blame] | 178 | /* Define a type and accessor macros for variables. Using a struct is |
pbrook | ac56dd4 | 2008-02-03 19:56:33 +0000 | [diff] [blame] | 179 | nice because it gives some level of type safely. Ideally the compiler |
| 180 | be able to see through all this. However in practice this is not true, |
Dong Xu Wang | 9814dd2 | 2011-11-22 18:06:22 +0800 | [diff] [blame] | 181 | especially on targets with braindamaged ABIs (e.g. i386). |
pbrook | ac56dd4 | 2008-02-03 19:56:33 +0000 | [diff] [blame] | 182 | We use plain int by default to avoid this runtime overhead. |
| 183 | Users of tcg_gen_* don't need to know about any of this, and should |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 184 | treat TCGv as an opaque type. |
Stefan Weil | 06ea77b | 2011-05-22 14:02:40 +0200 | [diff] [blame] | 185 | In addition we do typechecking for different types of variables. TCGv_i32 |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 186 | and TCGv_i64 are 32/64-bit variables respectively. TCGv and TCGv_ptr |
| 187 | are aliases for target_ulong and host pointer sized values respectively. |
| 188 | */ |
pbrook | ac56dd4 | 2008-02-03 19:56:33 +0000 | [diff] [blame] | 189 | |
Juan Quintela | 092c73e | 2009-07-27 16:13:04 +0200 | [diff] [blame] | 190 | #ifdef CONFIG_DEBUG_TCG |
aurel32 | f839394 | 2009-04-13 18:45:38 +0000 | [diff] [blame] | 191 | #define DEBUG_TCGV 1 |
| 192 | #endif |
pbrook | ac56dd4 | 2008-02-03 19:56:33 +0000 | [diff] [blame] | 193 | |
| 194 | #ifdef DEBUG_TCGV |
| 195 | |
| 196 | typedef struct |
| 197 | { |
blueswir1 | a810a2d | 2008-12-07 17:16:42 +0000 | [diff] [blame] | 198 | int i32; |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 199 | } TCGv_i32; |
pbrook | ac56dd4 | 2008-02-03 19:56:33 +0000 | [diff] [blame] | 200 | |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 201 | typedef struct |
| 202 | { |
blueswir1 | a810a2d | 2008-12-07 17:16:42 +0000 | [diff] [blame] | 203 | int i64; |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 204 | } TCGv_i64; |
| 205 | |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 206 | typedef struct { |
| 207 | int iptr; |
| 208 | } TCGv_ptr; |
| 209 | |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 210 | #define MAKE_TCGV_I32(i) __extension__ \ |
| 211 | ({ TCGv_i32 make_tcgv_tmp = {i}; make_tcgv_tmp;}) |
| 212 | #define MAKE_TCGV_I64(i) __extension__ \ |
| 213 | ({ TCGv_i64 make_tcgv_tmp = {i}; make_tcgv_tmp;}) |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 214 | #define MAKE_TCGV_PTR(i) __extension__ \ |
| 215 | ({ TCGv_ptr make_tcgv_tmp = {i}; make_tcgv_tmp; }) |
blueswir1 | a810a2d | 2008-12-07 17:16:42 +0000 | [diff] [blame] | 216 | #define GET_TCGV_I32(t) ((t).i32) |
| 217 | #define GET_TCGV_I64(t) ((t).i64) |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 218 | #define GET_TCGV_PTR(t) ((t).iptr) |
pbrook | ac56dd4 | 2008-02-03 19:56:33 +0000 | [diff] [blame] | 219 | #if TCG_TARGET_REG_BITS == 32 |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 220 | #define TCGV_LOW(t) MAKE_TCGV_I32(GET_TCGV_I64(t)) |
| 221 | #define TCGV_HIGH(t) MAKE_TCGV_I32(GET_TCGV_I64(t) + 1) |
pbrook | ac56dd4 | 2008-02-03 19:56:33 +0000 | [diff] [blame] | 222 | #endif |
| 223 | |
| 224 | #else /* !DEBUG_TCGV */ |
| 225 | |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 226 | typedef int TCGv_i32; |
| 227 | typedef int TCGv_i64; |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 228 | #if TCG_TARGET_REG_BITS == 32 |
| 229 | #define TCGv_ptr TCGv_i32 |
| 230 | #else |
| 231 | #define TCGv_ptr TCGv_i64 |
| 232 | #endif |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 233 | #define MAKE_TCGV_I32(x) (x) |
| 234 | #define MAKE_TCGV_I64(x) (x) |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 235 | #define MAKE_TCGV_PTR(x) (x) |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 236 | #define GET_TCGV_I32(t) (t) |
| 237 | #define GET_TCGV_I64(t) (t) |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 238 | #define GET_TCGV_PTR(t) (t) |
aurel32 | 44e6acb | 2009-03-10 08:56:30 +0000 | [diff] [blame] | 239 | |
pbrook | ac56dd4 | 2008-02-03 19:56:33 +0000 | [diff] [blame] | 240 | #if TCG_TARGET_REG_BITS == 32 |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 241 | #define TCGV_LOW(t) (t) |
pbrook | ac56dd4 | 2008-02-03 19:56:33 +0000 | [diff] [blame] | 242 | #define TCGV_HIGH(t) ((t) + 1) |
| 243 | #endif |
| 244 | |
| 245 | #endif /* DEBUG_TCGV */ |
| 246 | |
aurel32 | 43e860e | 2009-03-10 10:29:45 +0000 | [diff] [blame] | 247 | #define TCGV_EQUAL_I32(a, b) (GET_TCGV_I32(a) == GET_TCGV_I32(b)) |
| 248 | #define TCGV_EQUAL_I64(a, b) (GET_TCGV_I64(a) == GET_TCGV_I64(b)) |
| 249 | |
pbrook | a50f5b9 | 2008-06-29 15:25:29 +0000 | [diff] [blame] | 250 | /* Dummy definition to avoid compiler warnings. */ |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 251 | #define TCGV_UNUSED_I32(x) x = MAKE_TCGV_I32(-1) |
| 252 | #define TCGV_UNUSED_I64(x) x = MAKE_TCGV_I64(-1) |
pbrook | a50f5b9 | 2008-06-29 15:25:29 +0000 | [diff] [blame] | 253 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 254 | /* call flags */ |
| 255 | #define TCG_CALL_TYPE_MASK 0x000f |
| 256 | #define TCG_CALL_TYPE_STD 0x0000 /* standard C call */ |
| 257 | #define TCG_CALL_TYPE_REGPARM_1 0x0001 /* i386 style regparm call (1 reg) */ |
| 258 | #define TCG_CALL_TYPE_REGPARM_2 0x0002 /* i386 style regparm call (2 regs) */ |
| 259 | #define TCG_CALL_TYPE_REGPARM 0x0003 /* i386 style regparm call (3 regs) */ |
aurel32 | 3e00b3f | 2009-04-07 19:57:24 +0000 | [diff] [blame] | 260 | /* A pure function only reads its arguments and TCG global variables |
aurel32 | 34d5a9f | 2009-04-06 12:33:51 +0000 | [diff] [blame] | 261 | and cannot raise exceptions. Hence a call to a pure function can be |
bellard | c6e113f | 2008-05-17 12:42:15 +0000 | [diff] [blame] | 262 | safely suppressed if the return value is not used. */ |
| 263 | #define TCG_CALL_PURE 0x0010 |
aurel32 | b9c18f5 | 2009-04-06 12:33:59 +0000 | [diff] [blame] | 264 | /* A const function only reads its arguments and does not use TCG |
aurel32 | 3e00b3f | 2009-04-07 19:57:24 +0000 | [diff] [blame] | 265 | global variables. Hence a call to such a function does not |
| 266 | save TCG global variables back to their canonical location. */ |
aurel32 | b9c18f5 | 2009-04-06 12:33:59 +0000 | [diff] [blame] | 267 | #define TCG_CALL_CONST 0x0020 |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 268 | |
bellard | 39cf05d | 2008-05-22 14:59:57 +0000 | [diff] [blame] | 269 | /* used to align parameters */ |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 270 | #define TCG_CALL_DUMMY_TCGV MAKE_TCGV_I32(-1) |
bellard | 39cf05d | 2008-05-22 14:59:57 +0000 | [diff] [blame] | 271 | #define TCG_CALL_DUMMY_ARG ((TCGArg)(-1)) |
| 272 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 273 | typedef enum { |
| 274 | TCG_COND_EQ, |
| 275 | TCG_COND_NE, |
| 276 | TCG_COND_LT, |
| 277 | TCG_COND_GE, |
| 278 | TCG_COND_LE, |
| 279 | TCG_COND_GT, |
| 280 | /* unsigned */ |
| 281 | TCG_COND_LTU, |
| 282 | TCG_COND_GEU, |
| 283 | TCG_COND_LEU, |
| 284 | TCG_COND_GTU, |
| 285 | } TCGCond; |
| 286 | |
Richard Henderson | 1c08622 | 2010-02-09 12:33:09 -0800 | [diff] [blame] | 287 | /* Invert the sense of the comparison. */ |
Richard Henderson | 401d466 | 2010-01-07 10:15:20 -0800 | [diff] [blame] | 288 | static inline TCGCond tcg_invert_cond(TCGCond c) |
| 289 | { |
| 290 | return (TCGCond)(c ^ 1); |
| 291 | } |
| 292 | |
Richard Henderson | 1c08622 | 2010-02-09 12:33:09 -0800 | [diff] [blame] | 293 | /* Swap the operands in a comparison. */ |
| 294 | static inline TCGCond tcg_swap_cond(TCGCond c) |
| 295 | { |
| 296 | int mask = (c < TCG_COND_LT ? 0 : c < TCG_COND_LTU ? 7 : 15); |
| 297 | return (TCGCond)(c ^ mask); |
| 298 | } |
| 299 | |
Richard Henderson | ff44c2f | 2009-12-27 09:09:41 +0000 | [diff] [blame] | 300 | static inline TCGCond tcg_unsigned_cond(TCGCond c) |
| 301 | { |
| 302 | return (c >= TCG_COND_LT && c <= TCG_COND_GT ? c + 4 : c); |
| 303 | } |
| 304 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 305 | #define TEMP_VAL_DEAD 0 |
| 306 | #define TEMP_VAL_REG 1 |
| 307 | #define TEMP_VAL_MEM 2 |
| 308 | #define TEMP_VAL_CONST 3 |
| 309 | |
| 310 | /* XXX: optimize memory layout */ |
| 311 | typedef struct TCGTemp { |
| 312 | TCGType base_type; |
| 313 | TCGType type; |
| 314 | int val_type; |
| 315 | int reg; |
| 316 | tcg_target_long val; |
| 317 | int mem_reg; |
| 318 | tcg_target_long mem_offset; |
| 319 | unsigned int fixed_reg:1; |
| 320 | unsigned int mem_coherent:1; |
| 321 | unsigned int mem_allocated:1; |
Stefan Weil | 5225d66 | 2011-04-28 17:20:26 +0200 | [diff] [blame] | 322 | unsigned int temp_local:1; /* If true, the temp is saved across |
bellard | 641d5fb | 2008-05-25 17:24:00 +0000 | [diff] [blame] | 323 | basic blocks. Otherwise, it is not |
Stefan Weil | 5225d66 | 2011-04-28 17:20:26 +0200 | [diff] [blame] | 324 | preserved across basic blocks. */ |
bellard | e8996ee | 2008-05-23 17:33:39 +0000 | [diff] [blame] | 325 | unsigned int temp_allocated:1; /* never used for code gen */ |
| 326 | /* index of next free temp of same base type, -1 if end */ |
| 327 | int next_free_temp; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 328 | const char *name; |
| 329 | } TCGTemp; |
| 330 | |
| 331 | typedef struct TCGHelperInfo { |
bellard | 4dc81f2 | 2008-05-22 16:08:32 +0000 | [diff] [blame] | 332 | tcg_target_ulong func; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 333 | const char *name; |
| 334 | } TCGHelperInfo; |
| 335 | |
| 336 | typedef struct TCGContext TCGContext; |
| 337 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 338 | struct TCGContext { |
| 339 | uint8_t *pool_cur, *pool_end; |
| 340 | TCGPool *pool_first, *pool_current; |
| 341 | TCGLabel *labels; |
| 342 | int nb_labels; |
| 343 | TCGTemp *temps; /* globals first, temps after */ |
| 344 | int nb_globals; |
| 345 | int nb_temps; |
bellard | 641d5fb | 2008-05-25 17:24:00 +0000 | [diff] [blame] | 346 | /* index of free temps, -1 if none */ |
| 347 | int first_free_temp[TCG_TYPE_COUNT * 2]; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 348 | |
| 349 | /* goto_tb support */ |
| 350 | uint8_t *code_buf; |
| 351 | unsigned long *tb_next; |
| 352 | uint16_t *tb_next_offset; |
| 353 | uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */ |
| 354 | |
bellard | 641d5fb | 2008-05-25 17:24:00 +0000 | [diff] [blame] | 355 | /* liveness analysis */ |
Aurelien Jarno | 866cb6c | 2011-05-17 18:25:45 +0200 | [diff] [blame] | 356 | uint16_t *op_dead_args; /* for each operation, each bit tells if the |
| 357 | corresponding argument is dead */ |
bellard | 641d5fb | 2008-05-25 17:24:00 +0000 | [diff] [blame] | 358 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 359 | /* tells in which temporary a given register is. It does not take |
| 360 | into account fixed registers */ |
| 361 | int reg_to_temp[TCG_TARGET_NB_REGS]; |
| 362 | TCGRegSet reserved_regs; |
| 363 | tcg_target_long current_frame_offset; |
| 364 | tcg_target_long frame_start; |
| 365 | tcg_target_long frame_end; |
| 366 | int frame_reg; |
| 367 | |
| 368 | uint8_t *code_ptr; |
| 369 | TCGTemp static_temps[TCG_MAX_TEMPS]; |
| 370 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 371 | TCGHelperInfo *helpers; |
| 372 | int nb_helpers; |
| 373 | int allocated_helpers; |
bellard | e8996ee | 2008-05-23 17:33:39 +0000 | [diff] [blame] | 374 | int helpers_sorted; |
bellard | a23a9ec | 2008-05-23 09:52:20 +0000 | [diff] [blame] | 375 | |
| 376 | #ifdef CONFIG_PROFILER |
| 377 | /* profiling info */ |
| 378 | int64_t tb_count1; |
| 379 | int64_t tb_count; |
| 380 | int64_t op_count; /* total insn count */ |
| 381 | int op_count_max; /* max insn per TB */ |
| 382 | int64_t temp_count; |
| 383 | int temp_count_max; |
bellard | a23a9ec | 2008-05-23 09:52:20 +0000 | [diff] [blame] | 384 | int64_t del_op_count; |
| 385 | int64_t code_in_len; |
| 386 | int64_t code_out_len; |
| 387 | int64_t interm_time; |
| 388 | int64_t code_time; |
| 389 | int64_t la_time; |
| 390 | int64_t restore_count; |
| 391 | int64_t restore_time; |
| 392 | #endif |
Peter Maydell | 27bfd83 | 2011-03-06 21:39:53 +0000 | [diff] [blame] | 393 | |
| 394 | #ifdef CONFIG_DEBUG_TCG |
| 395 | int temps_in_use; |
| 396 | #endif |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 397 | }; |
| 398 | |
| 399 | extern TCGContext tcg_ctx; |
| 400 | extern uint16_t *gen_opc_ptr; |
| 401 | extern TCGArg *gen_opparam_ptr; |
| 402 | extern uint16_t gen_opc_buf[]; |
| 403 | extern TCGArg gen_opparam_buf[]; |
| 404 | |
| 405 | /* pool based memory allocation */ |
| 406 | |
| 407 | void *tcg_malloc_internal(TCGContext *s, int size); |
| 408 | void tcg_pool_reset(TCGContext *s); |
| 409 | void tcg_pool_delete(TCGContext *s); |
| 410 | |
| 411 | static inline void *tcg_malloc(int size) |
| 412 | { |
| 413 | TCGContext *s = &tcg_ctx; |
| 414 | uint8_t *ptr, *ptr_end; |
| 415 | size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1); |
| 416 | ptr = s->pool_cur; |
| 417 | ptr_end = ptr + size; |
| 418 | if (unlikely(ptr_end > s->pool_end)) { |
| 419 | return tcg_malloc_internal(&tcg_ctx, size); |
| 420 | } else { |
| 421 | s->pool_cur = ptr_end; |
| 422 | return ptr; |
| 423 | } |
| 424 | } |
| 425 | |
| 426 | void tcg_context_init(TCGContext *s); |
Richard Henderson | 9002ec7 | 2010-05-06 08:50:41 -0700 | [diff] [blame] | 427 | void tcg_prologue_init(TCGContext *s); |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 428 | void tcg_func_start(TCGContext *s); |
| 429 | |
aurel32 | 54604f7 | 2008-12-07 20:35:00 +0000 | [diff] [blame] | 430 | int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf); |
| 431 | int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset); |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 432 | |
| 433 | void tcg_set_frame(TCGContext *s, int reg, |
| 434 | tcg_target_long start, tcg_target_long size); |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 435 | |
| 436 | TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name); |
| 437 | TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset, |
| 438 | const char *name); |
| 439 | TCGv_i32 tcg_temp_new_internal_i32(int temp_local); |
| 440 | static inline TCGv_i32 tcg_temp_new_i32(void) |
bellard | 641d5fb | 2008-05-25 17:24:00 +0000 | [diff] [blame] | 441 | { |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 442 | return tcg_temp_new_internal_i32(0); |
bellard | 641d5fb | 2008-05-25 17:24:00 +0000 | [diff] [blame] | 443 | } |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 444 | static inline TCGv_i32 tcg_temp_local_new_i32(void) |
bellard | 641d5fb | 2008-05-25 17:24:00 +0000 | [diff] [blame] | 445 | { |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 446 | return tcg_temp_new_internal_i32(1); |
bellard | 641d5fb | 2008-05-25 17:24:00 +0000 | [diff] [blame] | 447 | } |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 448 | void tcg_temp_free_i32(TCGv_i32 arg); |
| 449 | char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg); |
| 450 | |
| 451 | TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name); |
| 452 | TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset, |
| 453 | const char *name); |
| 454 | TCGv_i64 tcg_temp_new_internal_i64(int temp_local); |
| 455 | static inline TCGv_i64 tcg_temp_new_i64(void) |
| 456 | { |
| 457 | return tcg_temp_new_internal_i64(0); |
| 458 | } |
| 459 | static inline TCGv_i64 tcg_temp_local_new_i64(void) |
| 460 | { |
| 461 | return tcg_temp_new_internal_i64(1); |
| 462 | } |
| 463 | void tcg_temp_free_i64(TCGv_i64 arg); |
| 464 | char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg); |
| 465 | |
Blue Swirl | e31b0a7 | 2011-08-06 13:58:47 +0000 | [diff] [blame] | 466 | static inline bool tcg_arg_is_local(TCGContext *s, TCGArg arg) |
| 467 | { |
| 468 | return s->temps[arg].temp_local; |
| 469 | } |
| 470 | |
Peter Maydell | 27bfd83 | 2011-03-06 21:39:53 +0000 | [diff] [blame] | 471 | #if defined(CONFIG_DEBUG_TCG) |
| 472 | /* If you call tcg_clear_temp_count() at the start of a section of |
| 473 | * code which is not supposed to leak any TCG temporaries, then |
| 474 | * calling tcg_check_temp_count() at the end of the section will |
| 475 | * return 1 if the section did in fact leak a temporary. |
| 476 | */ |
| 477 | void tcg_clear_temp_count(void); |
| 478 | int tcg_check_temp_count(void); |
| 479 | #else |
| 480 | #define tcg_clear_temp_count() do { } while (0) |
| 481 | #define tcg_check_temp_count() 0 |
| 482 | #endif |
| 483 | |
Stefan Weil | 405cf9f | 2010-10-22 23:03:31 +0200 | [diff] [blame] | 484 | void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf); |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 485 | |
| 486 | #define TCG_CT_ALIAS 0x80 |
| 487 | #define TCG_CT_IALIAS 0x40 |
| 488 | #define TCG_CT_REG 0x01 |
| 489 | #define TCG_CT_CONST 0x02 /* any constant of register size */ |
| 490 | |
| 491 | typedef struct TCGArgConstraint { |
bellard | 5ff9d6a | 2008-02-04 00:37:54 +0000 | [diff] [blame] | 492 | uint16_t ct; |
| 493 | uint8_t alias_index; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 494 | union { |
| 495 | TCGRegSet regs; |
| 496 | } u; |
| 497 | } TCGArgConstraint; |
| 498 | |
| 499 | #define TCG_MAX_OP_ARGS 16 |
| 500 | |
Richard Henderson | 8399ad5 | 2011-08-17 14:11:45 -0700 | [diff] [blame] | 501 | /* Bits for TCGOpDef->flags, 8 bits available. */ |
| 502 | enum { |
| 503 | /* Instruction defines the end of a basic block. */ |
| 504 | TCG_OPF_BB_END = 0x01, |
| 505 | /* Instruction clobbers call registers and potentially update globals. */ |
| 506 | TCG_OPF_CALL_CLOBBER = 0x02, |
| 507 | /* Instruction has side effects: it cannot be removed |
| 508 | if its outputs are not used. */ |
| 509 | TCG_OPF_SIDE_EFFECTS = 0x04, |
| 510 | /* Instruction operands are 64-bits (otherwise 32-bits). */ |
| 511 | TCG_OPF_64BIT = 0x08, |
Richard Henderson | 25c4d9c | 2011-08-17 14:11:46 -0700 | [diff] [blame] | 512 | /* Instruction is optional and not implemented by the host. */ |
| 513 | TCG_OPF_NOT_PRESENT = 0x10, |
Richard Henderson | 8399ad5 | 2011-08-17 14:11:45 -0700 | [diff] [blame] | 514 | }; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 515 | |
| 516 | typedef struct TCGOpDef { |
| 517 | const char *name; |
| 518 | uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args; |
| 519 | uint8_t flags; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 520 | TCGArgConstraint *args_ct; |
| 521 | int *sorted_args; |
Stefan Weil | c68aaa1 | 2010-02-15 17:17:21 +0100 | [diff] [blame] | 522 | #if defined(CONFIG_DEBUG_TCG) |
| 523 | int used; |
| 524 | #endif |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 525 | } TCGOpDef; |
Richard Henderson | 8399ad5 | 2011-08-17 14:11:45 -0700 | [diff] [blame] | 526 | |
| 527 | extern TCGOpDef tcg_op_defs[]; |
Stefan Weil | 2a24374 | 2011-09-29 18:33:21 +0200 | [diff] [blame] | 528 | extern const size_t tcg_op_defs_max; |
| 529 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 530 | typedef struct TCGTargetOpDef { |
Richard Henderson | a975160 | 2010-03-19 11:12:29 -0700 | [diff] [blame] | 531 | TCGOpcode op; |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 532 | const char *args_ct_str[TCG_MAX_OP_ARGS]; |
| 533 | } TCGTargetOpDef; |
| 534 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 535 | #define tcg_abort() \ |
| 536 | do {\ |
| 537 | fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\ |
| 538 | abort();\ |
| 539 | } while (0) |
| 540 | |
| 541 | void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs); |
| 542 | |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 543 | #if TCG_TARGET_REG_BITS == 32 |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 544 | #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I32(n)) |
| 545 | #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I32(GET_TCGV_PTR(n)) |
| 546 | |
Peter Maydell | 73f5e31 | 2011-12-10 16:35:31 +0000 | [diff] [blame] | 547 | #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i32((tcg_target_long)(V))) |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 548 | #define tcg_global_reg_new_ptr(R, N) \ |
| 549 | TCGV_NAT_TO_PTR(tcg_global_reg_new_i32((R), (N))) |
| 550 | #define tcg_global_mem_new_ptr(R, O, N) \ |
| 551 | TCGV_NAT_TO_PTR(tcg_global_mem_new_i32((R), (O), (N))) |
| 552 | #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i32()) |
| 553 | #define tcg_temp_free_ptr(T) tcg_temp_free_i32(TCGV_PTR_TO_NAT(T)) |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 554 | #else |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 555 | #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I64(n)) |
| 556 | #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I64(GET_TCGV_PTR(n)) |
| 557 | |
Peter Maydell | 73f5e31 | 2011-12-10 16:35:31 +0000 | [diff] [blame] | 558 | #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i64((tcg_target_long)(V))) |
Peter Maydell | ebecf36 | 2011-05-27 13:12:13 +0100 | [diff] [blame] | 559 | #define tcg_global_reg_new_ptr(R, N) \ |
| 560 | TCGV_NAT_TO_PTR(tcg_global_reg_new_i64((R), (N))) |
| 561 | #define tcg_global_mem_new_ptr(R, O, N) \ |
| 562 | TCGV_NAT_TO_PTR(tcg_global_mem_new_i64((R), (O), (N))) |
| 563 | #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i64()) |
| 564 | #define tcg_temp_free_ptr(T) tcg_temp_free_i64(TCGV_PTR_TO_NAT(T)) |
bellard | c896fe2 | 2008-02-01 10:05:41 +0000 | [diff] [blame] | 565 | #endif |
| 566 | |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 567 | void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, |
| 568 | int sizemask, TCGArg ret, int nargs, TCGArg *args); |
| 569 | |
| 570 | void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, |
| 571 | int c, int right, int arith); |
| 572 | |
Kirill Batuzov | 8f2e8c0 | 2011-07-07 16:37:12 +0400 | [diff] [blame] | 573 | TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr, TCGArg *args, |
| 574 | TCGOpDef *tcg_op_def); |
| 575 | |
pbrook | a7812ae | 2008-11-17 14:43:54 +0000 | [diff] [blame] | 576 | /* only used for debugging purposes */ |
| 577 | void tcg_register_helper(void *func, const char *name); |
| 578 | const char *tcg_helper_get_name(TCGContext *s, void *func); |
| 579 | void tcg_dump_ops(TCGContext *s, FILE *outfile); |
| 580 | |
| 581 | void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf); |
| 582 | TCGv_i32 tcg_const_i32(int32_t val); |
| 583 | TCGv_i64 tcg_const_i64(int64_t val); |
| 584 | TCGv_i32 tcg_const_local_i32(int32_t val); |
| 585 | TCGv_i64 tcg_const_local_i64(int64_t val); |
| 586 | |
bellard | b03cce8 | 2008-05-10 10:52:05 +0000 | [diff] [blame] | 587 | extern uint8_t code_gen_prologue[]; |
Stefan Weil | ce285b1 | 2011-09-30 21:23:06 +0200 | [diff] [blame] | 588 | |
| 589 | /* TCG targets may use a different definition of tcg_qemu_tb_exec. */ |
| 590 | #if !defined(tcg_qemu_tb_exec) |
| 591 | # define tcg_qemu_tb_exec(env, tb_ptr) \ |
Blue Swirl | cea5f9a | 2011-05-15 16:03:25 +0000 | [diff] [blame] | 592 | ((long REGPARM (*)(void *, void *))code_gen_prologue)(env, tb_ptr) |
bellard | 932a690 | 2008-05-30 20:56:52 +0000 | [diff] [blame] | 593 | #endif |