linux-user: add SO_PEERCRED support for getsockopt
[qemu.git] / tcg / tcg.h
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
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
35 #include "tcg-target.h"
36 #include "tcg-runtime.h"
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
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
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
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
103 typedef enum TCGOpcode {
104 #define DEF(name, oargs, iargs, cargs, flags) INDEX_op_ ## name,
105 #include "tcg-opc.h"
106 #undef DEF
107 NB_OPS,
108 } TCGOpcode;
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)
113 #define tcg_regset_set_reg(d, r) (d) |= 1L << (r)
114 #define tcg_regset_reset_reg(d, r) (d) &= ~(1L << (r))
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 {
129 int has_value;
130 union {
131 tcg_target_ulong value;
132 TCGRelocation *first_reloc;
133 } u;
134 } TCGLabel;
135
136 typedef struct TCGPool {
137 struct TCGPool *next;
138 int size;
139 uint8_t data[0] __attribute__ ((aligned));
140 } TCGPool;
141
142 #define TCG_POOL_CHUNK_SIZE 32768
143
144 #define TCG_MAX_LABELS 512
145
146 #define TCG_MAX_TEMPS 512
147
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
152 typedef enum TCGType {
153 TCG_TYPE_I32,
154 TCG_TYPE_I64,
155 TCG_TYPE_COUNT, /* number of different types */
156
157 /* An alias for the size of the host register. */
158 #if TCG_TARGET_REG_BITS == 32
159 TCG_TYPE_REG = TCG_TYPE_I32,
160 #else
161 TCG_TYPE_REG = TCG_TYPE_I64,
162 #endif
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. */
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;
175
176 typedef tcg_target_ulong TCGArg;
177
178 /* Define a type and accessor macros for variables. Using a struct is
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,
181 especially on targets with braindamaged ABIs (e.g. i386).
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
184 treat TCGv as an opaque type.
185 In addition we do typechecking for different types of variables. TCGv_i32
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 */
189
190 #ifdef CONFIG_DEBUG_TCG
191 #define DEBUG_TCGV 1
192 #endif
193
194 #ifdef DEBUG_TCGV
195
196 typedef struct
197 {
198 int i32;
199 } TCGv_i32;
200
201 typedef struct
202 {
203 int i64;
204 } TCGv_i64;
205
206 typedef struct {
207 int iptr;
208 } TCGv_ptr;
209
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;})
214 #define MAKE_TCGV_PTR(i) __extension__ \
215 ({ TCGv_ptr make_tcgv_tmp = {i}; make_tcgv_tmp; })
216 #define GET_TCGV_I32(t) ((t).i32)
217 #define GET_TCGV_I64(t) ((t).i64)
218 #define GET_TCGV_PTR(t) ((t).iptr)
219 #if TCG_TARGET_REG_BITS == 32
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)
222 #endif
223
224 #else /* !DEBUG_TCGV */
225
226 typedef int TCGv_i32;
227 typedef int TCGv_i64;
228 #if TCG_TARGET_REG_BITS == 32
229 #define TCGv_ptr TCGv_i32
230 #else
231 #define TCGv_ptr TCGv_i64
232 #endif
233 #define MAKE_TCGV_I32(x) (x)
234 #define MAKE_TCGV_I64(x) (x)
235 #define MAKE_TCGV_PTR(x) (x)
236 #define GET_TCGV_I32(t) (t)
237 #define GET_TCGV_I64(t) (t)
238 #define GET_TCGV_PTR(t) (t)
239
240 #if TCG_TARGET_REG_BITS == 32
241 #define TCGV_LOW(t) (t)
242 #define TCGV_HIGH(t) ((t) + 1)
243 #endif
244
245 #endif /* DEBUG_TCGV */
246
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
250 /* Dummy definition to avoid compiler warnings. */
251 #define TCGV_UNUSED_I32(x) x = MAKE_TCGV_I32(-1)
252 #define TCGV_UNUSED_I64(x) x = MAKE_TCGV_I64(-1)
253
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) */
260 /* A pure function only reads its arguments and TCG global variables
261 and cannot raise exceptions. Hence a call to a pure function can be
262 safely suppressed if the return value is not used. */
263 #define TCG_CALL_PURE 0x0010
264 /* A const function only reads its arguments and does not use TCG
265 global variables. Hence a call to such a function does not
266 save TCG global variables back to their canonical location. */
267 #define TCG_CALL_CONST 0x0020
268
269 /* used to align parameters */
270 #define TCG_CALL_DUMMY_TCGV MAKE_TCGV_I32(-1)
271 #define TCG_CALL_DUMMY_ARG ((TCGArg)(-1))
272
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
287 /* Invert the sense of the comparison. */
288 static inline TCGCond tcg_invert_cond(TCGCond c)
289 {
290 return (TCGCond)(c ^ 1);
291 }
292
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
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
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;
322 unsigned int temp_local:1; /* If true, the temp is saved across
323 basic blocks. Otherwise, it is not
324 preserved across basic blocks. */
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;
328 const char *name;
329 } TCGTemp;
330
331 typedef struct TCGHelperInfo {
332 tcg_target_ulong func;
333 const char *name;
334 } TCGHelperInfo;
335
336 typedef struct TCGContext TCGContext;
337
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;
346 /* index of free temps, -1 if none */
347 int first_free_temp[TCG_TYPE_COUNT * 2];
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
355 /* liveness analysis */
356 uint16_t *op_dead_args; /* for each operation, each bit tells if the
357 corresponding argument is dead */
358
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
371 TCGHelperInfo *helpers;
372 int nb_helpers;
373 int allocated_helpers;
374 int helpers_sorted;
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;
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
393
394 #ifdef CONFIG_DEBUG_TCG
395 int temps_in_use;
396 #endif
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);
427 void tcg_prologue_init(TCGContext *s);
428 void tcg_func_start(TCGContext *s);
429
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);
432
433 void tcg_set_frame(TCGContext *s, int reg,
434 tcg_target_long start, tcg_target_long size);
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)
441 {
442 return tcg_temp_new_internal_i32(0);
443 }
444 static inline TCGv_i32 tcg_temp_local_new_i32(void)
445 {
446 return tcg_temp_new_internal_i32(1);
447 }
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
466 static inline bool tcg_arg_is_local(TCGContext *s, TCGArg arg)
467 {
468 return s->temps[arg].temp_local;
469 }
470
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
484 void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf);
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 {
492 uint16_t ct;
493 uint8_t alias_index;
494 union {
495 TCGRegSet regs;
496 } u;
497 } TCGArgConstraint;
498
499 #define TCG_MAX_OP_ARGS 16
500
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,
512 /* Instruction is optional and not implemented by the host. */
513 TCG_OPF_NOT_PRESENT = 0x10,
514 };
515
516 typedef struct TCGOpDef {
517 const char *name;
518 uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
519 uint8_t flags;
520 TCGArgConstraint *args_ct;
521 int *sorted_args;
522 #if defined(CONFIG_DEBUG_TCG)
523 int used;
524 #endif
525 } TCGOpDef;
526
527 extern TCGOpDef tcg_op_defs[];
528 extern const size_t tcg_op_defs_max;
529
530 typedef struct TCGTargetOpDef {
531 TCGOpcode op;
532 const char *args_ct_str[TCG_MAX_OP_ARGS];
533 } TCGTargetOpDef;
534
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
543 #if TCG_TARGET_REG_BITS == 32
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
547 #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i32((tcg_target_long)(V)))
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))
554 #else
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
558 #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i64((tcg_target_long)(V)))
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))
565 #endif
566
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
573 TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr, TCGArg *args,
574 TCGOpDef *tcg_op_def);
575
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
587 extern uint8_t code_gen_prologue[];
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) \
592 ((long REGPARM (*)(void *, void *))code_gen_prologue)(env, tb_ptr)
593 #endif