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 */
24 #include "qemu-common.h"
25 #include "tcg-target.h"
26 #include "tcg-runtime.h"
27
28 #if TCG_TARGET_REG_BITS == 32
29 typedef int32_t tcg_target_long;
30 typedef uint32_t tcg_target_ulong;
31 #define TCG_PRIlx PRIx32
32 #define TCG_PRIld PRId32
33 #elif TCG_TARGET_REG_BITS == 64
34 typedef int64_t tcg_target_long;
35 typedef uint64_t tcg_target_ulong;
36 #define TCG_PRIlx PRIx64
37 #define TCG_PRIld PRId64
38 #else
39 #error unsupported
40 #endif
41
42 #if TCG_TARGET_NB_REGS <= 32
43 typedef uint32_t TCGRegSet;
44 #elif TCG_TARGET_NB_REGS <= 64
45 typedef uint64_t TCGRegSet;
46 #else
47 #error unsupported
48 #endif
49
50 enum {
51 #define DEF(s, n, copy_size) INDEX_op_ ## s,
52 #include "tcg-opc.h"
53 #undef DEF
54 NB_OPS,
55 };
56
57 #define tcg_regset_clear(d) (d) = 0
58 #define tcg_regset_set(d, s) (d) = (s)
59 #define tcg_regset_set32(d, reg, val32) (d) |= (val32) << (reg)
60 #define tcg_regset_set_reg(d, r) (d) |= 1L << (r)
61 #define tcg_regset_reset_reg(d, r) (d) &= ~(1L << (r))
62 #define tcg_regset_test_reg(d, r) (((d) >> (r)) & 1)
63 #define tcg_regset_or(d, a, b) (d) = (a) | (b)
64 #define tcg_regset_and(d, a, b) (d) = (a) & (b)
65 #define tcg_regset_andnot(d, a, b) (d) = (a) & ~(b)
66 #define tcg_regset_not(d, a) (d) = ~(a)
67
68 typedef struct TCGRelocation {
69 struct TCGRelocation *next;
70 int type;
71 uint8_t *ptr;
72 tcg_target_long addend;
73 } TCGRelocation;
74
75 typedef struct TCGLabel {
76 int has_value;
77 union {
78 tcg_target_ulong value;
79 TCGRelocation *first_reloc;
80 } u;
81 } TCGLabel;
82
83 typedef struct TCGPool {
84 struct TCGPool *next;
85 int size;
86 uint8_t data[0] __attribute__ ((aligned));
87 } TCGPool;
88
89 #define TCG_POOL_CHUNK_SIZE 32768
90
91 #define TCG_MAX_LABELS 512
92
93 #define TCG_MAX_TEMPS 512
94
95 /* when the size of the arguments of a called function is smaller than
96 this value, they are statically allocated in the TB stack frame */
97 #define TCG_STATIC_CALL_ARGS_SIZE 128
98
99 typedef int TCGType;
100
101 #define TCG_TYPE_I32 0
102 #define TCG_TYPE_I64 1
103 #define TCG_TYPE_COUNT 2 /* number of different types */
104
105 #if TCG_TARGET_REG_BITS == 32
106 #define TCG_TYPE_PTR TCG_TYPE_I32
107 #else
108 #define TCG_TYPE_PTR TCG_TYPE_I64
109 #endif
110
111 typedef tcg_target_ulong TCGArg;
112
113 /* Define a type and accessor macros for varables. Using a struct is
114 nice because it gives some level of type safely. Ideally the compiler
115 be able to see through all this. However in practice this is not true,
116 expecially on targets with braindamaged ABIs (e.g. i386).
117 We use plain int by default to avoid this runtime overhead.
118 Users of tcg_gen_* don't need to know about any of this, and should
119 treat TCGv as an opaque type.
120 In additon we do typechecking for different types of variables. TCGv_i32
121 and TCGv_i64 are 32/64-bit variables respectively. TCGv and TCGv_ptr
122 are aliases for target_ulong and host pointer sized values respectively.
123 */
124
125 #ifdef CONFIG_DEBUG_TCG
126 #define DEBUG_TCGV 1
127 #endif
128
129 #ifdef DEBUG_TCGV
130
131 typedef struct
132 {
133 int i32;
134 } TCGv_i32;
135
136 typedef struct
137 {
138 int i64;
139 } TCGv_i64;
140
141 #define MAKE_TCGV_I32(i) __extension__ \
142 ({ TCGv_i32 make_tcgv_tmp = {i}; make_tcgv_tmp;})
143 #define MAKE_TCGV_I64(i) __extension__ \
144 ({ TCGv_i64 make_tcgv_tmp = {i}; make_tcgv_tmp;})
145 #define GET_TCGV_I32(t) ((t).i32)
146 #define GET_TCGV_I64(t) ((t).i64)
147 #if TCG_TARGET_REG_BITS == 32
148 #define TCGV_LOW(t) MAKE_TCGV_I32(GET_TCGV_I64(t))
149 #define TCGV_HIGH(t) MAKE_TCGV_I32(GET_TCGV_I64(t) + 1)
150 #endif
151
152 #else /* !DEBUG_TCGV */
153
154 typedef int TCGv_i32;
155 typedef int TCGv_i64;
156 #define MAKE_TCGV_I32(x) (x)
157 #define MAKE_TCGV_I64(x) (x)
158 #define GET_TCGV_I32(t) (t)
159 #define GET_TCGV_I64(t) (t)
160
161 #if TCG_TARGET_REG_BITS == 32
162 #define TCGV_LOW(t) (t)
163 #define TCGV_HIGH(t) ((t) + 1)
164 #endif
165
166 #endif /* DEBUG_TCGV */
167
168 #define TCGV_EQUAL_I32(a, b) (GET_TCGV_I32(a) == GET_TCGV_I32(b))
169 #define TCGV_EQUAL_I64(a, b) (GET_TCGV_I64(a) == GET_TCGV_I64(b))
170
171 /* Dummy definition to avoid compiler warnings. */
172 #define TCGV_UNUSED_I32(x) x = MAKE_TCGV_I32(-1)
173 #define TCGV_UNUSED_I64(x) x = MAKE_TCGV_I64(-1)
174
175 /* call flags */
176 #define TCG_CALL_TYPE_MASK 0x000f
177 #define TCG_CALL_TYPE_STD 0x0000 /* standard C call */
178 #define TCG_CALL_TYPE_REGPARM_1 0x0001 /* i386 style regparm call (1 reg) */
179 #define TCG_CALL_TYPE_REGPARM_2 0x0002 /* i386 style regparm call (2 regs) */
180 #define TCG_CALL_TYPE_REGPARM 0x0003 /* i386 style regparm call (3 regs) */
181 /* A pure function only reads its arguments and TCG global variables
182 and cannot raise exceptions. Hence a call to a pure function can be
183 safely suppressed if the return value is not used. */
184 #define TCG_CALL_PURE 0x0010
185 /* A const function only reads its arguments and does not use TCG
186 global variables. Hence a call to such a function does not
187 save TCG global variables back to their canonical location. */
188 #define TCG_CALL_CONST 0x0020
189
190 /* used to align parameters */
191 #define TCG_CALL_DUMMY_TCGV MAKE_TCGV_I32(-1)
192 #define TCG_CALL_DUMMY_ARG ((TCGArg)(-1))
193
194 typedef enum {
195 TCG_COND_EQ,
196 TCG_COND_NE,
197 TCG_COND_LT,
198 TCG_COND_GE,
199 TCG_COND_LE,
200 TCG_COND_GT,
201 /* unsigned */
202 TCG_COND_LTU,
203 TCG_COND_GEU,
204 TCG_COND_LEU,
205 TCG_COND_GTU,
206 } TCGCond;
207
208 /* Invert the sense of the comparison. */
tcg_invert_cond(TCGCond c)209 static inline TCGCond tcg_invert_cond(TCGCond c)
210 {
211 return (TCGCond)(c ^ 1);
212 }
213
214 /* Swap the operands in a comparison. */
tcg_swap_cond(TCGCond c)215 static inline TCGCond tcg_swap_cond(TCGCond c)
216 {
217 int mask = (c < TCG_COND_LT ? 0 : c < TCG_COND_LTU ? 7 : 15);
218 return (TCGCond)(c ^ mask);
219 }
220
tcg_unsigned_cond(TCGCond c)221 static inline TCGCond tcg_unsigned_cond(TCGCond c)
222 {
223 return (c >= TCG_COND_LT && c <= TCG_COND_GT ? c + 4 : c);
224 }
225
226 #define TEMP_VAL_DEAD 0
227 #define TEMP_VAL_REG 1
228 #define TEMP_VAL_MEM 2
229 #define TEMP_VAL_CONST 3
230
231 /* XXX: optimize memory layout */
232 typedef struct TCGTemp {
233 TCGType base_type;
234 TCGType type;
235 int val_type;
236 int reg;
237 tcg_target_long val;
238 int mem_reg;
239 tcg_target_long mem_offset;
240 unsigned int fixed_reg:1;
241 unsigned int mem_coherent:1;
242 unsigned int mem_allocated:1;
243 unsigned int temp_local:1; /* If true, the temp is saved accross
244 basic blocks. Otherwise, it is not
245 preserved accross basic blocks. */
246 unsigned int temp_allocated:1; /* never used for code gen */
247 /* index of next free temp of same base type, -1 if end */
248 int next_free_temp;
249 const char *name;
250 } TCGTemp;
251
252 typedef struct TCGHelperInfo {
253 tcg_target_ulong func;
254 const char *name;
255 } TCGHelperInfo;
256
257 typedef struct TCGContext TCGContext;
258
259 struct TCGContext {
260 uint8_t *pool_cur, *pool_end;
261 TCGPool *pool_first, *pool_current;
262 TCGLabel *labels;
263 int nb_labels;
264 TCGTemp *temps; /* globals first, temps after */
265 int nb_globals;
266 int nb_temps;
267 /* index of free temps, -1 if none */
268 int first_free_temp[TCG_TYPE_COUNT * 2];
269
270 /* goto_tb support */
271 uint8_t *code_buf;
272 unsigned long *tb_next;
273 uint16_t *tb_next_offset;
274 uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */
275
276 /* liveness analysis */
277 uint16_t *op_dead_iargs; /* for each operation, each bit tells if the
278 corresponding input argument is dead */
279
280 /* tells in which temporary a given register is. It does not take
281 into account fixed registers */
282 int reg_to_temp[TCG_TARGET_NB_REGS];
283 TCGRegSet reserved_regs;
284 tcg_target_long current_frame_offset;
285 tcg_target_long frame_start;
286 tcg_target_long frame_end;
287 int frame_reg;
288
289 uint8_t *code_ptr;
290 TCGTemp static_temps[TCG_MAX_TEMPS];
291
292 TCGHelperInfo *helpers;
293 int nb_helpers;
294 int allocated_helpers;
295 int helpers_sorted;
296
297 #ifdef CONFIG_PROFILER
298 /* profiling info */
299 int64_t tb_count1;
300 int64_t tb_count;
301 int64_t op_count; /* total insn count */
302 int op_count_max; /* max insn per TB */
303 int64_t temp_count;
304 int temp_count_max;
305 int64_t del_op_count;
306 int64_t code_in_len;
307 int64_t code_out_len;
308 int64_t interm_time;
309 int64_t code_time;
310 int64_t la_time;
311 int64_t restore_count;
312 int64_t restore_time;
313 #endif
314 };
315
316 extern TCGContext tcg_ctx;
317 extern uint16_t *gen_opc_ptr;
318 extern TCGArg *gen_opparam_ptr;
319 extern uint16_t gen_opc_buf[];
320 extern TCGArg gen_opparam_buf[];
321
322 /* pool based memory allocation */
323
324 void *tcg_malloc_internal(TCGContext *s, int size);
325 void tcg_pool_reset(TCGContext *s);
326 void tcg_pool_delete(TCGContext *s);
327
tcg_malloc(int size)328 static inline void *tcg_malloc(int size)
329 {
330 TCGContext *s = &tcg_ctx;
331 uint8_t *ptr, *ptr_end;
332 size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1);
333 ptr = s->pool_cur;
334 ptr_end = ptr + size;
335 if (unlikely(ptr_end > s->pool_end)) {
336 return tcg_malloc_internal(&tcg_ctx, size);
337 } else {
338 s->pool_cur = ptr_end;
339 return ptr;
340 }
341 }
342
343 void tcg_context_init(TCGContext *s);
344 void tcg_func_start(TCGContext *s);
345
346 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf);
347 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset);
348
349 void tcg_set_frame(TCGContext *s, int reg,
350 tcg_target_long start, tcg_target_long size);
351
352 TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name);
353 TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset,
354 const char *name);
355 TCGv_i32 tcg_temp_new_internal_i32(int temp_local);
tcg_temp_new_i32(void)356 static inline TCGv_i32 tcg_temp_new_i32(void)
357 {
358 return tcg_temp_new_internal_i32(0);
359 }
tcg_temp_local_new_i32(void)360 static inline TCGv_i32 tcg_temp_local_new_i32(void)
361 {
362 return tcg_temp_new_internal_i32(1);
363 }
364 void tcg_temp_free_i32(TCGv_i32 arg);
365 char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg);
366
367 TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name);
368 TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset,
369 const char *name);
370 TCGv_i64 tcg_temp_new_internal_i64(int temp_local);
tcg_temp_new_i64(void)371 static inline TCGv_i64 tcg_temp_new_i64(void)
372 {
373 return tcg_temp_new_internal_i64(0);
374 }
tcg_temp_local_new_i64(void)375 static inline TCGv_i64 tcg_temp_local_new_i64(void)
376 {
377 return tcg_temp_new_internal_i64(1);
378 }
379 void tcg_temp_free_i64(TCGv_i64 arg);
380 char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg);
381
382 void tcg_dump_info(FILE *f,
383 int (*cpu_fprintf)(FILE *f, const char *fmt, ...));
384
385 #define TCG_CT_ALIAS 0x80
386 #define TCG_CT_IALIAS 0x40
387 #define TCG_CT_REG 0x01
388 #define TCG_CT_CONST 0x02 /* any constant of register size */
389
390 typedef struct TCGArgConstraint {
391 uint16_t ct;
392 uint8_t alias_index;
393 union {
394 TCGRegSet regs;
395 } u;
396 } TCGArgConstraint;
397
398 #define TCG_MAX_OP_ARGS 16
399
400 #define TCG_OPF_BB_END 0x01 /* instruction defines the end of a basic
401 block */
402 #define TCG_OPF_CALL_CLOBBER 0x02 /* instruction clobbers call registers
403 and potentially update globals. */
404 #define TCG_OPF_SIDE_EFFECTS 0x04 /* instruction has side effects : it
405 cannot be removed if its output
406 are not used */
407
408 typedef struct TCGOpDef {
409 const char *name;
410 uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
411 uint8_t flags;
412 uint16_t copy_size;
413 TCGArgConstraint *args_ct;
414 int *sorted_args;
415 #if defined(CONFIG_DEBUG_TCG)
416 int used;
417 #endif
418 } TCGOpDef;
419
420 typedef struct TCGTargetOpDef {
421 int op;
422 const char *args_ct_str[TCG_MAX_OP_ARGS];
423 } TCGTargetOpDef;
424
425 void tcg_target_init(TCGContext *s);
426 void tcg_target_qemu_prologue(TCGContext *s);
427
428 #define tcg_abort() \
429 do {\
430 fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\
431 abort();\
432 } while (0)
433
434 void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);
435
436 #if TCG_TARGET_REG_BITS == 32
437 #define tcg_const_ptr tcg_const_i32
438 #define tcg_add_ptr tcg_add_i32
439 #define tcg_sub_ptr tcg_sub_i32
440 #define TCGv_ptr TCGv_i32
441 #define GET_TCGV_PTR GET_TCGV_I32
442 #define tcg_global_reg_new_ptr tcg_global_reg_new_i32
443 #define tcg_global_mem_new_ptr tcg_global_mem_new_i32
444 #define tcg_temp_new_ptr tcg_temp_new_i32
445 #define tcg_temp_free_ptr tcg_temp_free_i32
446 #else
447 #define tcg_const_ptr tcg_const_i64
448 #define tcg_add_ptr tcg_add_i64
449 #define tcg_sub_ptr tcg_sub_i64
450 #define TCGv_ptr TCGv_i64
451 #define GET_TCGV_PTR GET_TCGV_I64
452 #define tcg_global_reg_new_ptr tcg_global_reg_new_i64
453 #define tcg_global_mem_new_ptr tcg_global_mem_new_i64
454 #define tcg_temp_new_ptr tcg_temp_new_i64
455 #define tcg_temp_free_ptr tcg_temp_free_i64
456 #endif
457
458 void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags,
459 int sizemask, TCGArg ret, int nargs, TCGArg *args);
460
461 void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
462 int c, int right, int arith);
463
464 /* only used for debugging purposes */
465 void tcg_register_helper(void *func, const char *name);
466 const char *tcg_helper_get_name(TCGContext *s, void *func);
467 void tcg_dump_ops(TCGContext *s, FILE *outfile);
468
469 void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf);
470 TCGv_i32 tcg_const_i32(int32_t val);
471 TCGv_i64 tcg_const_i64(int64_t val);
472 TCGv_i32 tcg_const_local_i32(int32_t val);
473 TCGv_i64 tcg_const_local_i64(int64_t val);
474
475 void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type,
476 int label_index, long addend);
477
478 extern uint8_t code_gen_prologue[];
479 #if defined(_ARCH_PPC) && !defined(_ARCH_PPC64)
480 #define tcg_qemu_tb_exec(tb_ptr) \
481 ((long REGPARM __attribute__ ((longcall)) (*)(void *))code_gen_prologue)(tb_ptr)
482 #else
483 #define tcg_qemu_tb_exec(tb_ptr) ((long REGPARM (*)(void *))code_gen_prologue)(tb_ptr)
484 #endif
485