![[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: #if TCG_TARGET_REG_BITS == 32
36: typedef int32_t tcg_target_long;
37: typedef uint32_t tcg_target_ulong;
38: #define TCG_PRIlx PRIx32
39: #define TCG_PRIld PRId32
40: #elif TCG_TARGET_REG_BITS == 64
41: typedef int64_t tcg_target_long;
42: typedef uint64_t tcg_target_ulong;
43: #define TCG_PRIlx PRIx64
44: #define TCG_PRIld PRId64
45: #else
46: #error unsupported
47: #endif
48:
1.1.1.8 ! root 49: #include "tcg-target.h"
! 50: #include "tcg-runtime.h"
! 51:
1.1 root 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,
1.1.1.8 ! root 181: especially on targets with braindamaged ABIs (e.g. i386).
1.1 root 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 */
1.1.1.2 root 255: /* A pure function only reads its arguments and TCG global variables
256: and cannot raise exceptions. Hence a call to a pure function can be
1.1 root 257: safely suppressed if the return value is not used. */
258: #define TCG_CALL_PURE 0x0010
1.1.1.2 root 259: /* A const function only reads its arguments and does not use TCG
260: global variables. Hence a call to such a function does not
261: save TCG global variables back to their canonical location. */
262: #define TCG_CALL_CONST 0x0020
1.1 root 263:
264: /* used to align parameters */
265: #define TCG_CALL_DUMMY_TCGV MAKE_TCGV_I32(-1)
266: #define TCG_CALL_DUMMY_ARG ((TCGArg)(-1))
267:
268: typedef enum {
269: TCG_COND_EQ,
270: TCG_COND_NE,
271: TCG_COND_LT,
272: TCG_COND_GE,
273: TCG_COND_LE,
274: TCG_COND_GT,
275: /* unsigned */
276: TCG_COND_LTU,
277: TCG_COND_GEU,
278: TCG_COND_LEU,
279: TCG_COND_GTU,
280: } TCGCond;
281:
1.1.1.4 root 282: /* Invert the sense of the comparison. */
283: static inline TCGCond tcg_invert_cond(TCGCond c)
284: {
285: return (TCGCond)(c ^ 1);
286: }
287:
288: /* Swap the operands in a comparison. */
289: static inline TCGCond tcg_swap_cond(TCGCond c)
290: {
291: int mask = (c < TCG_COND_LT ? 0 : c < TCG_COND_LTU ? 7 : 15);
292: return (TCGCond)(c ^ mask);
293: }
294:
295: static inline TCGCond tcg_unsigned_cond(TCGCond c)
296: {
297: return (c >= TCG_COND_LT && c <= TCG_COND_GT ? c + 4 : c);
298: }
299:
1.1 root 300: #define TEMP_VAL_DEAD 0
301: #define TEMP_VAL_REG 1
302: #define TEMP_VAL_MEM 2
303: #define TEMP_VAL_CONST 3
304:
305: /* XXX: optimize memory layout */
306: typedef struct TCGTemp {
307: TCGType base_type;
308: TCGType type;
309: int val_type;
310: int reg;
311: tcg_target_long val;
312: int mem_reg;
313: tcg_target_long mem_offset;
314: unsigned int fixed_reg:1;
315: unsigned int mem_coherent:1;
316: unsigned int mem_allocated:1;
1.1.1.6 root 317: unsigned int temp_local:1; /* If true, the temp is saved across
1.1 root 318: basic blocks. Otherwise, it is not
1.1.1.6 root 319: preserved across basic blocks. */
1.1 root 320: unsigned int temp_allocated:1; /* never used for code gen */
321: /* index of next free temp of same base type, -1 if end */
322: int next_free_temp;
323: const char *name;
324: } TCGTemp;
325:
326: typedef struct TCGHelperInfo {
327: tcg_target_ulong func;
328: const char *name;
329: } TCGHelperInfo;
330:
331: typedef struct TCGContext TCGContext;
332:
333: struct TCGContext {
334: uint8_t *pool_cur, *pool_end;
1.1.1.8 ! root 335: TCGPool *pool_first, *pool_current, *pool_first_large;
1.1 root 336: TCGLabel *labels;
337: int nb_labels;
338: TCGTemp *temps; /* globals first, temps after */
339: int nb_globals;
340: int nb_temps;
341: /* index of free temps, -1 if none */
342: int first_free_temp[TCG_TYPE_COUNT * 2];
343:
344: /* goto_tb support */
345: uint8_t *code_buf;
346: unsigned long *tb_next;
347: uint16_t *tb_next_offset;
348: uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */
349:
350: /* liveness analysis */
1.1.1.6 root 351: uint16_t *op_dead_args; /* for each operation, each bit tells if the
352: corresponding argument is dead */
1.1 root 353:
354: /* tells in which temporary a given register is. It does not take
355: into account fixed registers */
356: int reg_to_temp[TCG_TARGET_NB_REGS];
357: TCGRegSet reserved_regs;
358: tcg_target_long current_frame_offset;
359: tcg_target_long frame_start;
360: tcg_target_long frame_end;
361: int frame_reg;
362:
363: uint8_t *code_ptr;
364: TCGTemp static_temps[TCG_MAX_TEMPS];
365:
366: TCGHelperInfo *helpers;
367: int nb_helpers;
368: int allocated_helpers;
369: int helpers_sorted;
370:
371: #ifdef CONFIG_PROFILER
372: /* profiling info */
373: int64_t tb_count1;
374: int64_t tb_count;
375: int64_t op_count; /* total insn count */
376: int op_count_max; /* max insn per TB */
377: int64_t temp_count;
378: int temp_count_max;
379: int64_t del_op_count;
380: int64_t code_in_len;
381: int64_t code_out_len;
382: int64_t interm_time;
383: int64_t code_time;
384: int64_t la_time;
385: int64_t restore_count;
386: int64_t restore_time;
387: #endif
1.1.1.6 root 388:
389: #ifdef CONFIG_DEBUG_TCG
390: int temps_in_use;
391: #endif
1.1 root 392: };
393:
394: extern TCGContext tcg_ctx;
395: extern uint16_t *gen_opc_ptr;
396: extern TCGArg *gen_opparam_ptr;
397: extern uint16_t gen_opc_buf[];
398: extern TCGArg gen_opparam_buf[];
399:
400: /* pool based memory allocation */
401:
402: void *tcg_malloc_internal(TCGContext *s, int size);
403: void tcg_pool_reset(TCGContext *s);
404: void tcg_pool_delete(TCGContext *s);
405:
406: static inline void *tcg_malloc(int size)
407: {
408: TCGContext *s = &tcg_ctx;
409: uint8_t *ptr, *ptr_end;
410: size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1);
411: ptr = s->pool_cur;
412: ptr_end = ptr + size;
413: if (unlikely(ptr_end > s->pool_end)) {
414: return tcg_malloc_internal(&tcg_ctx, size);
415: } else {
416: s->pool_cur = ptr_end;
417: return ptr;
418: }
419: }
420:
421: void tcg_context_init(TCGContext *s);
1.1.1.4 root 422: void tcg_prologue_init(TCGContext *s);
1.1 root 423: void tcg_func_start(TCGContext *s);
424:
425: int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf);
426: int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset);
427:
428: void tcg_set_frame(TCGContext *s, int reg,
429: tcg_target_long start, tcg_target_long size);
430:
431: TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name);
432: TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset,
433: const char *name);
434: TCGv_i32 tcg_temp_new_internal_i32(int temp_local);
435: static inline TCGv_i32 tcg_temp_new_i32(void)
436: {
437: return tcg_temp_new_internal_i32(0);
438: }
439: static inline TCGv_i32 tcg_temp_local_new_i32(void)
440: {
441: return tcg_temp_new_internal_i32(1);
442: }
443: void tcg_temp_free_i32(TCGv_i32 arg);
444: char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg);
445:
446: TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name);
447: TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset,
448: const char *name);
449: TCGv_i64 tcg_temp_new_internal_i64(int temp_local);
450: static inline TCGv_i64 tcg_temp_new_i64(void)
451: {
452: return tcg_temp_new_internal_i64(0);
453: }
454: static inline TCGv_i64 tcg_temp_local_new_i64(void)
455: {
456: return tcg_temp_new_internal_i64(1);
457: }
458: void tcg_temp_free_i64(TCGv_i64 arg);
459: char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg);
460:
1.1.1.7 root 461: static inline bool tcg_arg_is_local(TCGContext *s, TCGArg arg)
462: {
463: return s->temps[arg].temp_local;
464: }
465:
1.1.1.6 root 466: #if defined(CONFIG_DEBUG_TCG)
467: /* If you call tcg_clear_temp_count() at the start of a section of
468: * code which is not supposed to leak any TCG temporaries, then
469: * calling tcg_check_temp_count() at the end of the section will
470: * return 1 if the section did in fact leak a temporary.
471: */
472: void tcg_clear_temp_count(void);
473: int tcg_check_temp_count(void);
474: #else
475: #define tcg_clear_temp_count() do { } while (0)
476: #define tcg_check_temp_count() 0
477: #endif
478:
1.1.1.5 root 479: void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf);
1.1 root 480:
481: #define TCG_CT_ALIAS 0x80
482: #define TCG_CT_IALIAS 0x40
483: #define TCG_CT_REG 0x01
484: #define TCG_CT_CONST 0x02 /* any constant of register size */
485:
486: typedef struct TCGArgConstraint {
487: uint16_t ct;
488: uint8_t alias_index;
489: union {
490: TCGRegSet regs;
491: } u;
492: } TCGArgConstraint;
493:
494: #define TCG_MAX_OP_ARGS 16
495:
1.1.1.7 root 496: /* Bits for TCGOpDef->flags, 8 bits available. */
497: enum {
498: /* Instruction defines the end of a basic block. */
499: TCG_OPF_BB_END = 0x01,
500: /* Instruction clobbers call registers and potentially update globals. */
501: TCG_OPF_CALL_CLOBBER = 0x02,
502: /* Instruction has side effects: it cannot be removed
503: if its outputs are not used. */
504: TCG_OPF_SIDE_EFFECTS = 0x04,
505: /* Instruction operands are 64-bits (otherwise 32-bits). */
506: TCG_OPF_64BIT = 0x08,
507: /* Instruction is optional and not implemented by the host. */
508: TCG_OPF_NOT_PRESENT = 0x10,
509: };
1.1 root 510:
511: typedef struct TCGOpDef {
512: const char *name;
513: uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
514: uint8_t flags;
515: TCGArgConstraint *args_ct;
516: int *sorted_args;
1.1.1.4 root 517: #if defined(CONFIG_DEBUG_TCG)
518: int used;
519: #endif
1.1 root 520: } TCGOpDef;
1.1.1.7 root 521:
522: extern TCGOpDef tcg_op_defs[];
523: extern const size_t tcg_op_defs_max;
524:
1.1 root 525: typedef struct TCGTargetOpDef {
1.1.1.4 root 526: TCGOpcode op;
1.1 root 527: const char *args_ct_str[TCG_MAX_OP_ARGS];
528: } TCGTargetOpDef;
529:
530: #define tcg_abort() \
531: do {\
532: fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\
533: abort();\
534: } while (0)
535:
536: void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);
537:
538: #if TCG_TARGET_REG_BITS == 32
1.1.1.6 root 539: #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I32(n))
540: #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I32(GET_TCGV_PTR(n))
541:
1.1.1.8 ! root 542: #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i32((tcg_target_long)(V)))
1.1.1.6 root 543: #define tcg_global_reg_new_ptr(R, N) \
544: TCGV_NAT_TO_PTR(tcg_global_reg_new_i32((R), (N)))
545: #define tcg_global_mem_new_ptr(R, O, N) \
546: TCGV_NAT_TO_PTR(tcg_global_mem_new_i32((R), (O), (N)))
547: #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i32())
548: #define tcg_temp_free_ptr(T) tcg_temp_free_i32(TCGV_PTR_TO_NAT(T))
1.1 root 549: #else
1.1.1.6 root 550: #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I64(n))
551: #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I64(GET_TCGV_PTR(n))
552:
1.1.1.8 ! root 553: #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i64((tcg_target_long)(V)))
1.1.1.6 root 554: #define tcg_global_reg_new_ptr(R, N) \
555: TCGV_NAT_TO_PTR(tcg_global_reg_new_i64((R), (N)))
556: #define tcg_global_mem_new_ptr(R, O, N) \
557: TCGV_NAT_TO_PTR(tcg_global_mem_new_i64((R), (O), (N)))
558: #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i64())
559: #define tcg_temp_free_ptr(T) tcg_temp_free_i64(TCGV_PTR_TO_NAT(T))
1.1 root 560: #endif
561:
562: void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags,
563: int sizemask, TCGArg ret, int nargs, TCGArg *args);
564:
565: void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
566: int c, int right, int arith);
567:
1.1.1.7 root 568: TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr, TCGArg *args,
569: TCGOpDef *tcg_op_def);
570:
1.1 root 571: /* only used for debugging purposes */
572: void tcg_register_helper(void *func, const char *name);
573: const char *tcg_helper_get_name(TCGContext *s, void *func);
574: void tcg_dump_ops(TCGContext *s, FILE *outfile);
575:
576: void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf);
577: TCGv_i32 tcg_const_i32(int32_t val);
578: TCGv_i64 tcg_const_i64(int64_t val);
579: TCGv_i32 tcg_const_local_i32(int32_t val);
580: TCGv_i64 tcg_const_local_i64(int64_t val);
581:
582: extern uint8_t code_gen_prologue[];
1.1.1.7 root 583:
584: /* TCG targets may use a different definition of tcg_qemu_tb_exec. */
585: #if !defined(tcg_qemu_tb_exec)
586: # define tcg_qemu_tb_exec(env, tb_ptr) \
1.1.1.8 ! root 587: ((tcg_target_ulong (*)(void *, void *))code_gen_prologue)(env, tb_ptr)
1.1 root 588: #endif
1.1.1.8 ! root 589:
! 590: void tcg_register_jit(void *buf, size_t buf_size);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.