![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcg.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / tcg|
Return to tcg.h CVS log | Up to [Qemu by Fabrice Bellard] / qemu / tcg |
1.1 root 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: */
1.1.1.2 root 24: #include "qemu-common.h"
1.1.1.7 ! root 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:
1.1 root 35: #include "tcg-target.h"
1.1.1.3 root 36: #include "tcg-runtime.h"
1.1 root 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:
1.1.1.7 ! root 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:
1.1.1.4 root 103: typedef enum TCGOpcode {
104: #define DEF(name, oargs, iargs, cargs, flags) INDEX_op_ ## name,
1.1 root 105: #include "tcg-opc.h"
106: #undef DEF
107: NB_OPS,
1.1.1.4 root 108: } TCGOpcode;
1.1 root 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)
1.1.1.3 root 113: #define tcg_regset_set_reg(d, r) (d) |= 1L << (r)
114: #define tcg_regset_reset_reg(d, r) (d) &= ~(1L << (r))
1.1 root 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:
1.1.1.4 root 152: typedef enum TCGType {
153: TCG_TYPE_I32,
154: TCG_TYPE_I64,
155: TCG_TYPE_COUNT, /* number of different types */
1.1 root 156:
1.1.1.4 root 157: /* An alias for the size of the host register. */
1.1 root 158: #if TCG_TARGET_REG_BITS == 32
1.1.1.4 root 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,
1.1 root 171: #else
1.1.1.4 root 172: TCG_TYPE_TL = TCG_TYPE_I32,
1.1 root 173: #endif
1.1.1.4 root 174: } TCGType;
1.1 root 175:
176: typedef tcg_target_ulong TCGArg;
177:
1.1.1.7 ! root 178: /* Define a type and accessor macros for variables. Using a struct is
1.1 root 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: expecially 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.
1.1.1.6 root 185: In addition we do typechecking for different types of variables. TCGv_i32
1.1 root 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:
1.1.1.3 root 190: #ifdef CONFIG_DEBUG_TCG
1.1.1.2 root 191: #define DEBUG_TCGV 1
192: #endif
1.1 root 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:
1.1.1.6 root 206: typedef struct {
207: int iptr;
208: } TCGv_ptr;
209:
1.1 root 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;})
1.1.1.6 root 214: #define MAKE_TCGV_PTR(i) __extension__ \
215: ({ TCGv_ptr make_tcgv_tmp = {i}; make_tcgv_tmp; })
1.1 root 216: #define GET_TCGV_I32(t) ((t).i32)
217: #define GET_TCGV_I64(t) ((t).i64)
1.1.1.6 root 218: #define GET_TCGV_PTR(t) ((t).iptr)
1.1 root 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;
1.1.1.6 root 228: #if TCG_TARGET_REG_BITS == 32
229: #define TCGv_ptr TCGv_i32
230: #else
231: #define TCGv_ptr TCGv_i64
232: #endif
1.1 root 233: #define MAKE_TCGV_I32(x) (x)
234: #define MAKE_TCGV_I64(x) (x)
1.1.1.6 root 235: #define MAKE_TCGV_PTR(x) (x)
1.1 root 236: #define GET_TCGV_I32(t) (t)
237: #define GET_TCGV_I64(t) (t)
1.1.1.6 root 238: #define GET_TCGV_PTR(t) (t)
1.1.1.2 root 239:
1.1 root 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:
1.1.1.2 root 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:
1.1 root 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) */
1.1.1.2 root 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
1.1 root 262: safely suppressed if the return value is not used. */
263: #define TCG_CALL_PURE 0x0010
1.1.1.2 root 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
1.1 root 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:
1.1.1.4 root 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:
1.1 root 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;
1.1.1.6 root 322: unsigned int temp_local:1; /* If true, the temp is saved across
1.1 root 323: basic blocks. Otherwise, it is not
1.1.1.6 root 324: preserved across basic blocks. */
1.1 root 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 */
1.1.1.6 root 356: uint16_t *op_dead_args; /* for each operation, each bit tells if the
357: corresponding argument is dead */
1.1 root 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
1.1.1.6 root 393:
394: #ifdef CONFIG_DEBUG_TCG
395: int temps_in_use;
396: #endif
1.1 root 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);
1.1.1.4 root 427: void tcg_prologue_init(TCGContext *s);
1.1 root 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:
1.1.1.7 ! root 466: static inline bool tcg_arg_is_local(TCGContext *s, TCGArg arg)
! 467: {
! 468: return s->temps[arg].temp_local;
! 469: }
! 470:
1.1.1.6 root 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:
1.1.1.5 root 484: void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf);
1.1 root 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:
1.1.1.7 ! root 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: };
1.1 root 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;
1.1.1.4 root 522: #if defined(CONFIG_DEBUG_TCG)
523: int used;
524: #endif
1.1 root 525: } TCGOpDef;
1.1.1.7 ! root 526:
! 527: extern TCGOpDef tcg_op_defs[];
! 528: extern const size_t tcg_op_defs_max;
! 529:
1.1 root 530: typedef struct TCGTargetOpDef {
1.1.1.4 root 531: TCGOpcode op;
1.1 root 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
1.1.1.6 root 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(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))
1.1 root 554: #else
1.1.1.6 root 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(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))
1.1 root 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:
1.1.1.7 ! root 573: TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr, TCGArg *args,
! 574: TCGOpDef *tcg_op_def);
! 575:
1.1 root 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[];
1.1.1.7 ! root 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) \
1.1.1.6 root 592: ((long REGPARM (*)(void *, void *))code_gen_prologue)(env, tb_ptr)
1.1 root 593: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.