blob: 5c282396822a7c9e797ec1de5e8d128ba8540d93 [file] [log] [blame]
bellardc896fe22008-02-01 10:05:41 +00001/*
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 */
aurel32f8393942009-04-13 18:45:38 +000024#include "qemu-common.h"
Stefan Weil817b8382011-09-17 22:00:27 +020025
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
bellardc896fe22008-02-01 10:05:41 +000035#include "tcg-target.h"
Blue Swirl96e132e2009-09-20 19:06:34 +000036#include "tcg-runtime.h"
bellardc896fe22008-02-01 10:05:41 +000037
38#if TCG_TARGET_REG_BITS == 32
39typedef int32_t tcg_target_long;
40typedef uint32_t tcg_target_ulong;
41#define TCG_PRIlx PRIx32
42#define TCG_PRIld PRId32
43#elif TCG_TARGET_REG_BITS == 64
44typedef int64_t tcg_target_long;
45typedef 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
53typedef uint32_t TCGRegSet;
54#elif TCG_TARGET_NB_REGS <= 64
55typedef uint64_t TCGRegSet;
56#else
57#error unsupported
58#endif
59
Richard Henderson25c4d9c2011-08-17 14:11:46 -070060/* 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 Kiszkaa4773322011-09-29 18:52:11 +020084#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 Henderson25c4d9c2011-08-17 14:11:46 -070091/* 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 Hendersona9751602010-03-19 11:12:29 -0700103typedef enum TCGOpcode {
Aurelien Jarnoc61aaf72010-06-03 19:40:04 +0200104#define DEF(name, oargs, iargs, cargs, flags) INDEX_op_ ## name,
bellardc896fe22008-02-01 10:05:41 +0000105#include "tcg-opc.h"
106#undef DEF
107 NB_OPS,
Richard Hendersona9751602010-03-19 11:12:29 -0700108} TCGOpcode;
bellardc896fe22008-02-01 10:05:41 +0000109
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 Jarno7d301752009-10-28 22:44:34 +0100113#define tcg_regset_set_reg(d, r) (d) |= 1L << (r)
114#define tcg_regset_reset_reg(d, r) (d) &= ~(1L << (r))
bellardc896fe22008-02-01 10:05:41 +0000115#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
121typedef struct TCGRelocation {
122 struct TCGRelocation *next;
123 int type;
124 uint8_t *ptr;
125 tcg_target_long addend;
126} TCGRelocation;
127
128typedef struct TCGLabel {
blueswir1c44f9452008-05-19 16:32:18 +0000129 int has_value;
bellardc896fe22008-02-01 10:05:41 +0000130 union {
131 tcg_target_ulong value;
132 TCGRelocation *first_reloc;
133 } u;
134} TCGLabel;
135
136typedef struct TCGPool {
137 struct TCGPool *next;
blueswir1c44f9452008-05-19 16:32:18 +0000138 int size;
139 uint8_t data[0] __attribute__ ((aligned));
bellardc896fe22008-02-01 10:05:41 +0000140} TCGPool;
141
142#define TCG_POOL_CHUNK_SIZE 32768
143
144#define TCG_MAX_LABELS 512
145
blueswir1c4071c92008-03-16 19:21:07 +0000146#define TCG_MAX_TEMPS 512
bellardc896fe22008-02-01 10:05:41 +0000147
bellardb03cce82008-05-10 10:52:05 +0000148/* 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 Hendersonc02244a2010-03-19 11:36:30 -0700152typedef enum TCGType {
153 TCG_TYPE_I32,
154 TCG_TYPE_I64,
155 TCG_TYPE_COUNT, /* number of different types */
bellardc896fe22008-02-01 10:05:41 +0000156
Richard Henderson3b6dac32010-06-02 17:26:55 -0700157 /* An alias for the size of the host register. */
bellardc896fe22008-02-01 10:05:41 +0000158#if TCG_TARGET_REG_BITS == 32
Richard Henderson3b6dac32010-06-02 17:26:55 -0700159 TCG_TYPE_REG = TCG_TYPE_I32,
bellardc896fe22008-02-01 10:05:41 +0000160#else
Richard Henderson3b6dac32010-06-02 17:26:55 -0700161 TCG_TYPE_REG = TCG_TYPE_I64,
bellardc896fe22008-02-01 10:05:41 +0000162#endif
Richard Henderson3b6dac32010-06-02 17:26:55 -0700163
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 Hendersonc02244a2010-03-19 11:36:30 -0700169#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;
bellardc896fe22008-02-01 10:05:41 +0000175
176typedef tcg_target_ulong TCGArg;
177
Stefan Weil8ef935b2011-10-11 19:43:15 +0200178/* Define a type and accessor macros for variables. Using a struct is
pbrookac56dd42008-02-03 19:56:33 +0000179 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 Wang9814dd22011-11-22 18:06:22 +0800181 especially on targets with braindamaged ABIs (e.g. i386).
pbrookac56dd42008-02-03 19:56:33 +0000182 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
pbrooka7812ae2008-11-17 14:43:54 +0000184 treat TCGv as an opaque type.
Stefan Weil06ea77b2011-05-22 14:02:40 +0200185 In addition we do typechecking for different types of variables. TCGv_i32
pbrooka7812ae2008-11-17 14:43:54 +0000186 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 */
pbrookac56dd42008-02-03 19:56:33 +0000189
Juan Quintela092c73e2009-07-27 16:13:04 +0200190#ifdef CONFIG_DEBUG_TCG
aurel32f8393942009-04-13 18:45:38 +0000191#define DEBUG_TCGV 1
192#endif
pbrookac56dd42008-02-03 19:56:33 +0000193
194#ifdef DEBUG_TCGV
195
196typedef struct
197{
blueswir1a810a2d2008-12-07 17:16:42 +0000198 int i32;
pbrooka7812ae2008-11-17 14:43:54 +0000199} TCGv_i32;
pbrookac56dd42008-02-03 19:56:33 +0000200
pbrooka7812ae2008-11-17 14:43:54 +0000201typedef struct
202{
blueswir1a810a2d2008-12-07 17:16:42 +0000203 int i64;
pbrooka7812ae2008-11-17 14:43:54 +0000204} TCGv_i64;
205
Peter Maydellebecf362011-05-27 13:12:13 +0100206typedef struct {
207 int iptr;
208} TCGv_ptr;
209
pbrooka7812ae2008-11-17 14:43:54 +0000210#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 Maydellebecf362011-05-27 13:12:13 +0100214#define MAKE_TCGV_PTR(i) __extension__ \
215 ({ TCGv_ptr make_tcgv_tmp = {i}; make_tcgv_tmp; })
blueswir1a810a2d2008-12-07 17:16:42 +0000216#define GET_TCGV_I32(t) ((t).i32)
217#define GET_TCGV_I64(t) ((t).i64)
Peter Maydellebecf362011-05-27 13:12:13 +0100218#define GET_TCGV_PTR(t) ((t).iptr)
pbrookac56dd42008-02-03 19:56:33 +0000219#if TCG_TARGET_REG_BITS == 32
pbrooka7812ae2008-11-17 14:43:54 +0000220#define TCGV_LOW(t) MAKE_TCGV_I32(GET_TCGV_I64(t))
221#define TCGV_HIGH(t) MAKE_TCGV_I32(GET_TCGV_I64(t) + 1)
pbrookac56dd42008-02-03 19:56:33 +0000222#endif
223
224#else /* !DEBUG_TCGV */
225
pbrooka7812ae2008-11-17 14:43:54 +0000226typedef int TCGv_i32;
227typedef int TCGv_i64;
Peter Maydellebecf362011-05-27 13:12:13 +0100228#if TCG_TARGET_REG_BITS == 32
229#define TCGv_ptr TCGv_i32
230#else
231#define TCGv_ptr TCGv_i64
232#endif
pbrooka7812ae2008-11-17 14:43:54 +0000233#define MAKE_TCGV_I32(x) (x)
234#define MAKE_TCGV_I64(x) (x)
Peter Maydellebecf362011-05-27 13:12:13 +0100235#define MAKE_TCGV_PTR(x) (x)
pbrooka7812ae2008-11-17 14:43:54 +0000236#define GET_TCGV_I32(t) (t)
237#define GET_TCGV_I64(t) (t)
Peter Maydellebecf362011-05-27 13:12:13 +0100238#define GET_TCGV_PTR(t) (t)
aurel3244e6acb2009-03-10 08:56:30 +0000239
pbrookac56dd42008-02-03 19:56:33 +0000240#if TCG_TARGET_REG_BITS == 32
pbrooka7812ae2008-11-17 14:43:54 +0000241#define TCGV_LOW(t) (t)
pbrookac56dd42008-02-03 19:56:33 +0000242#define TCGV_HIGH(t) ((t) + 1)
243#endif
244
245#endif /* DEBUG_TCGV */
246
aurel3243e860e2009-03-10 10:29:45 +0000247#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
pbrooka50f5b92008-06-29 15:25:29 +0000250/* Dummy definition to avoid compiler warnings. */
pbrooka7812ae2008-11-17 14:43:54 +0000251#define TCGV_UNUSED_I32(x) x = MAKE_TCGV_I32(-1)
252#define TCGV_UNUSED_I64(x) x = MAKE_TCGV_I64(-1)
pbrooka50f5b92008-06-29 15:25:29 +0000253
bellardc896fe22008-02-01 10:05:41 +0000254/* 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) */
aurel323e00b3f2009-04-07 19:57:24 +0000260/* A pure function only reads its arguments and TCG global variables
aurel3234d5a9f2009-04-06 12:33:51 +0000261 and cannot raise exceptions. Hence a call to a pure function can be
bellardc6e113f2008-05-17 12:42:15 +0000262 safely suppressed if the return value is not used. */
263#define TCG_CALL_PURE 0x0010
aurel32b9c18f52009-04-06 12:33:59 +0000264/* A const function only reads its arguments and does not use TCG
aurel323e00b3f2009-04-07 19:57:24 +0000265 global variables. Hence a call to such a function does not
266 save TCG global variables back to their canonical location. */
aurel32b9c18f52009-04-06 12:33:59 +0000267#define TCG_CALL_CONST 0x0020
bellardc896fe22008-02-01 10:05:41 +0000268
bellard39cf05d2008-05-22 14:59:57 +0000269/* used to align parameters */
pbrooka7812ae2008-11-17 14:43:54 +0000270#define TCG_CALL_DUMMY_TCGV MAKE_TCGV_I32(-1)
bellard39cf05d2008-05-22 14:59:57 +0000271#define TCG_CALL_DUMMY_ARG ((TCGArg)(-1))
272
bellardc896fe22008-02-01 10:05:41 +0000273typedef 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 Henderson1c086222010-02-09 12:33:09 -0800287/* Invert the sense of the comparison. */
Richard Henderson401d4662010-01-07 10:15:20 -0800288static inline TCGCond tcg_invert_cond(TCGCond c)
289{
290 return (TCGCond)(c ^ 1);
291}
292
Richard Henderson1c086222010-02-09 12:33:09 -0800293/* Swap the operands in a comparison. */
294static 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 Hendersonff44c2f2009-12-27 09:09:41 +0000300static inline TCGCond tcg_unsigned_cond(TCGCond c)
301{
302 return (c >= TCG_COND_LT && c <= TCG_COND_GT ? c + 4 : c);
303}
304
bellardc896fe22008-02-01 10:05:41 +0000305#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 */
311typedef 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 Weil5225d662011-04-28 17:20:26 +0200322 unsigned int temp_local:1; /* If true, the temp is saved across
bellard641d5fb2008-05-25 17:24:00 +0000323 basic blocks. Otherwise, it is not
Stefan Weil5225d662011-04-28 17:20:26 +0200324 preserved across basic blocks. */
bellarde8996ee2008-05-23 17:33:39 +0000325 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;
bellardc896fe22008-02-01 10:05:41 +0000328 const char *name;
329} TCGTemp;
330
331typedef struct TCGHelperInfo {
bellard4dc81f22008-05-22 16:08:32 +0000332 tcg_target_ulong func;
bellardc896fe22008-02-01 10:05:41 +0000333 const char *name;
334} TCGHelperInfo;
335
336typedef struct TCGContext TCGContext;
337
bellardc896fe22008-02-01 10:05:41 +0000338struct 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;
bellard641d5fb2008-05-25 17:24:00 +0000346 /* index of free temps, -1 if none */
347 int first_free_temp[TCG_TYPE_COUNT * 2];
bellardc896fe22008-02-01 10:05:41 +0000348
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
bellard641d5fb2008-05-25 17:24:00 +0000355 /* liveness analysis */
Aurelien Jarno866cb6c2011-05-17 18:25:45 +0200356 uint16_t *op_dead_args; /* for each operation, each bit tells if the
357 corresponding argument is dead */
bellard641d5fb2008-05-25 17:24:00 +0000358
bellardc896fe22008-02-01 10:05:41 +0000359 /* 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
bellardc896fe22008-02-01 10:05:41 +0000371 TCGHelperInfo *helpers;
372 int nb_helpers;
373 int allocated_helpers;
bellarde8996ee2008-05-23 17:33:39 +0000374 int helpers_sorted;
bellarda23a9ec2008-05-23 09:52:20 +0000375
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;
bellarda23a9ec2008-05-23 09:52:20 +0000384 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 Maydell27bfd832011-03-06 21:39:53 +0000393
394#ifdef CONFIG_DEBUG_TCG
395 int temps_in_use;
396#endif
bellardc896fe22008-02-01 10:05:41 +0000397};
398
399extern TCGContext tcg_ctx;
400extern uint16_t *gen_opc_ptr;
401extern TCGArg *gen_opparam_ptr;
402extern uint16_t gen_opc_buf[];
403extern TCGArg gen_opparam_buf[];
404
405/* pool based memory allocation */
406
407void *tcg_malloc_internal(TCGContext *s, int size);
408void tcg_pool_reset(TCGContext *s);
409void tcg_pool_delete(TCGContext *s);
410
411static 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
426void tcg_context_init(TCGContext *s);
Richard Henderson9002ec72010-05-06 08:50:41 -0700427void tcg_prologue_init(TCGContext *s);
bellardc896fe22008-02-01 10:05:41 +0000428void tcg_func_start(TCGContext *s);
429
aurel3254604f72008-12-07 20:35:00 +0000430int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf);
431int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset);
bellardc896fe22008-02-01 10:05:41 +0000432
433void tcg_set_frame(TCGContext *s, int reg,
434 tcg_target_long start, tcg_target_long size);
pbrooka7812ae2008-11-17 14:43:54 +0000435
436TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name);
437TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset,
438 const char *name);
439TCGv_i32 tcg_temp_new_internal_i32(int temp_local);
440static inline TCGv_i32 tcg_temp_new_i32(void)
bellard641d5fb2008-05-25 17:24:00 +0000441{
pbrooka7812ae2008-11-17 14:43:54 +0000442 return tcg_temp_new_internal_i32(0);
bellard641d5fb2008-05-25 17:24:00 +0000443}
pbrooka7812ae2008-11-17 14:43:54 +0000444static inline TCGv_i32 tcg_temp_local_new_i32(void)
bellard641d5fb2008-05-25 17:24:00 +0000445{
pbrooka7812ae2008-11-17 14:43:54 +0000446 return tcg_temp_new_internal_i32(1);
bellard641d5fb2008-05-25 17:24:00 +0000447}
pbrooka7812ae2008-11-17 14:43:54 +0000448void tcg_temp_free_i32(TCGv_i32 arg);
449char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg);
450
451TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name);
452TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset,
453 const char *name);
454TCGv_i64 tcg_temp_new_internal_i64(int temp_local);
455static inline TCGv_i64 tcg_temp_new_i64(void)
456{
457 return tcg_temp_new_internal_i64(0);
458}
459static inline TCGv_i64 tcg_temp_local_new_i64(void)
460{
461 return tcg_temp_new_internal_i64(1);
462}
463void tcg_temp_free_i64(TCGv_i64 arg);
464char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg);
465
Blue Swirle31b0a72011-08-06 13:58:47 +0000466static inline bool tcg_arg_is_local(TCGContext *s, TCGArg arg)
467{
468 return s->temps[arg].temp_local;
469}
470
Peter Maydell27bfd832011-03-06 21:39:53 +0000471#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 */
477void tcg_clear_temp_count(void);
478int 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 Weil405cf9f2010-10-22 23:03:31 +0200484void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf);
bellardc896fe22008-02-01 10:05:41 +0000485
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
491typedef struct TCGArgConstraint {
bellard5ff9d6a2008-02-04 00:37:54 +0000492 uint16_t ct;
493 uint8_t alias_index;
bellardc896fe22008-02-01 10:05:41 +0000494 union {
495 TCGRegSet regs;
496 } u;
497} TCGArgConstraint;
498
499#define TCG_MAX_OP_ARGS 16
500
Richard Henderson8399ad52011-08-17 14:11:45 -0700501/* Bits for TCGOpDef->flags, 8 bits available. */
502enum {
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 Henderson25c4d9c2011-08-17 14:11:46 -0700512 /* Instruction is optional and not implemented by the host. */
513 TCG_OPF_NOT_PRESENT = 0x10,
Richard Henderson8399ad52011-08-17 14:11:45 -0700514};
bellardc896fe22008-02-01 10:05:41 +0000515
516typedef struct TCGOpDef {
517 const char *name;
518 uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
519 uint8_t flags;
bellardc896fe22008-02-01 10:05:41 +0000520 TCGArgConstraint *args_ct;
521 int *sorted_args;
Stefan Weilc68aaa12010-02-15 17:17:21 +0100522#if defined(CONFIG_DEBUG_TCG)
523 int used;
524#endif
bellardc896fe22008-02-01 10:05:41 +0000525} TCGOpDef;
Richard Henderson8399ad52011-08-17 14:11:45 -0700526
527extern TCGOpDef tcg_op_defs[];
Stefan Weil2a243742011-09-29 18:33:21 +0200528extern const size_t tcg_op_defs_max;
529
bellardc896fe22008-02-01 10:05:41 +0000530typedef struct TCGTargetOpDef {
Richard Hendersona9751602010-03-19 11:12:29 -0700531 TCGOpcode op;
bellardc896fe22008-02-01 10:05:41 +0000532 const char *args_ct_str[TCG_MAX_OP_ARGS];
533} TCGTargetOpDef;
534
bellardc896fe22008-02-01 10:05:41 +0000535#define tcg_abort() \
536do {\
537 fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\
538 abort();\
539} while (0)
540
541void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);
542
bellardc896fe22008-02-01 10:05:41 +0000543#if TCG_TARGET_REG_BITS == 32
Peter Maydellebecf362011-05-27 13:12:13 +0100544#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 Maydell73f5e312011-12-10 16:35:31 +0000547#define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i32((tcg_target_long)(V)))
Peter Maydellebecf362011-05-27 13:12:13 +0100548#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))
bellardc896fe22008-02-01 10:05:41 +0000554#else
Peter Maydellebecf362011-05-27 13:12:13 +0100555#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 Maydell73f5e312011-12-10 16:35:31 +0000558#define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i64((tcg_target_long)(V)))
Peter Maydellebecf362011-05-27 13:12:13 +0100559#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))
bellardc896fe22008-02-01 10:05:41 +0000565#endif
566
pbrooka7812ae2008-11-17 14:43:54 +0000567void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags,
568 int sizemask, TCGArg ret, int nargs, TCGArg *args);
569
570void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
571 int c, int right, int arith);
572
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +0400573TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr, TCGArg *args,
574 TCGOpDef *tcg_op_def);
575
pbrooka7812ae2008-11-17 14:43:54 +0000576/* only used for debugging purposes */
577void tcg_register_helper(void *func, const char *name);
578const char *tcg_helper_get_name(TCGContext *s, void *func);
579void tcg_dump_ops(TCGContext *s, FILE *outfile);
580
581void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf);
582TCGv_i32 tcg_const_i32(int32_t val);
583TCGv_i64 tcg_const_i64(int64_t val);
584TCGv_i32 tcg_const_local_i32(int32_t val);
585TCGv_i64 tcg_const_local_i64(int64_t val);
586
bellardb03cce82008-05-10 10:52:05 +0000587extern uint8_t code_gen_prologue[];
Stefan Weilce285b12011-09-30 21:23:06 +0200588
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 Swirlcea5f9a2011-05-15 16:03:25 +0000592 ((long REGPARM (*)(void *, void *))code_gen_prologue)(env, tb_ptr)
bellard932a6902008-05-30 20:56:52 +0000593#endif