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