]>
Commit | Line | Data |
---|---|---|
c896fe29 FB |
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 "tcg-target.h" | |
25 | ||
26 | #if TCG_TARGET_REG_BITS == 32 | |
27 | typedef int32_t tcg_target_long; | |
28 | typedef uint32_t tcg_target_ulong; | |
29 | #define TCG_PRIlx PRIx32 | |
30 | #define TCG_PRIld PRId32 | |
31 | #elif TCG_TARGET_REG_BITS == 64 | |
32 | typedef int64_t tcg_target_long; | |
33 | typedef uint64_t tcg_target_ulong; | |
34 | #define TCG_PRIlx PRIx64 | |
35 | #define TCG_PRIld PRId64 | |
36 | #else | |
37 | #error unsupported | |
38 | #endif | |
39 | ||
40 | #if TCG_TARGET_NB_REGS <= 32 | |
41 | typedef uint32_t TCGRegSet; | |
42 | #elif TCG_TARGET_NB_REGS <= 64 | |
43 | typedef uint64_t TCGRegSet; | |
44 | #else | |
45 | #error unsupported | |
46 | #endif | |
47 | ||
48 | enum { | |
49 | #define DEF(s, n, copy_size) INDEX_op_ ## s, | |
50 | #include "tcg-opc.h" | |
51 | #undef DEF | |
52 | NB_OPS, | |
53 | }; | |
54 | ||
55 | #define tcg_regset_clear(d) (d) = 0 | |
56 | #define tcg_regset_set(d, s) (d) = (s) | |
57 | #define tcg_regset_set32(d, reg, val32) (d) |= (val32) << (reg) | |
58 | #define tcg_regset_set_reg(d, r) (d) |= 1 << (r) | |
59 | #define tcg_regset_reset_reg(d, r) (d) &= ~(1 << (r)) | |
60 | #define tcg_regset_test_reg(d, r) (((d) >> (r)) & 1) | |
61 | #define tcg_regset_or(d, a, b) (d) = (a) | (b) | |
62 | #define tcg_regset_and(d, a, b) (d) = (a) & (b) | |
63 | #define tcg_regset_andnot(d, a, b) (d) = (a) & ~(b) | |
64 | #define tcg_regset_not(d, a) (d) = ~(a) | |
65 | ||
66 | typedef struct TCGRelocation { | |
67 | struct TCGRelocation *next; | |
68 | int type; | |
69 | uint8_t *ptr; | |
70 | tcg_target_long addend; | |
71 | } TCGRelocation; | |
72 | ||
73 | typedef struct TCGLabel { | |
74 | int has_value; | |
75 | union { | |
76 | tcg_target_ulong value; | |
77 | TCGRelocation *first_reloc; | |
78 | } u; | |
79 | } TCGLabel; | |
80 | ||
81 | typedef struct TCGPool { | |
82 | struct TCGPool *next; | |
83 | int size; | |
84 | uint8_t data[0]; | |
85 | } TCGPool; | |
86 | ||
87 | #define TCG_POOL_CHUNK_SIZE 32768 | |
88 | ||
89 | #define TCG_MAX_LABELS 512 | |
90 | ||
91 | #define TCG_MAX_TEMPS 256 | |
92 | ||
93 | typedef int TCGType; | |
94 | ||
95 | #define TCG_TYPE_I32 0 | |
96 | #define TCG_TYPE_I64 1 | |
97 | ||
98 | #if TCG_TARGET_REG_BITS == 32 | |
99 | #define TCG_TYPE_PTR TCG_TYPE_I32 | |
100 | #else | |
101 | #define TCG_TYPE_PTR TCG_TYPE_I64 | |
102 | #endif | |
103 | ||
104 | typedef tcg_target_ulong TCGArg; | |
105 | ||
ac56dd48 PB |
106 | /* Define a type and accessor macros for varables. Using a struct is |
107 | nice because it gives some level of type safely. Ideally the compiler | |
108 | be able to see through all this. However in practice this is not true, | |
109 | expecially on targets with braindamaged ABIs (e.g. i386). | |
110 | We use plain int by default to avoid this runtime overhead. | |
111 | Users of tcg_gen_* don't need to know about any of this, and should | |
112 | treat TCGv as an opaque type. */ | |
113 | ||
114 | //#define DEBUG_TCGV 1 | |
115 | ||
116 | #ifdef DEBUG_TCGV | |
117 | ||
118 | typedef struct | |
119 | { | |
120 | int n; | |
121 | } TCGv; | |
122 | ||
123 | #define MAKE_TCGV(i) __extension__ \ | |
124 | ({ TCGv make_tcgv_tmp = {i}; make_tcgv_tmp;}) | |
125 | #define GET_TCGV(t) ((t).n) | |
126 | #if TCG_TARGET_REG_BITS == 32 | |
127 | #define TCGV_HIGH(t) MAKE_TCGV(GET_TCGV(t) + 1) | |
128 | #endif | |
129 | ||
130 | #else /* !DEBUG_TCGV */ | |
131 | ||
132 | typedef int TCGv; | |
133 | #define MAKE_TCGV(x) (x) | |
134 | #define GET_TCGV(t) (t) | |
135 | #if TCG_TARGET_REG_BITS == 32 | |
136 | #define TCGV_HIGH(t) ((t) + 1) | |
137 | #endif | |
138 | ||
139 | #endif /* DEBUG_TCGV */ | |
140 | ||
c896fe29 FB |
141 | /* call flags */ |
142 | #define TCG_CALL_TYPE_MASK 0x000f | |
143 | #define TCG_CALL_TYPE_STD 0x0000 /* standard C call */ | |
144 | #define TCG_CALL_TYPE_REGPARM_1 0x0001 /* i386 style regparm call (1 reg) */ | |
145 | #define TCG_CALL_TYPE_REGPARM_2 0x0002 /* i386 style regparm call (2 regs) */ | |
146 | #define TCG_CALL_TYPE_REGPARM 0x0003 /* i386 style regparm call (3 regs) */ | |
147 | ||
148 | typedef enum { | |
149 | TCG_COND_EQ, | |
150 | TCG_COND_NE, | |
151 | TCG_COND_LT, | |
152 | TCG_COND_GE, | |
153 | TCG_COND_LE, | |
154 | TCG_COND_GT, | |
155 | /* unsigned */ | |
156 | TCG_COND_LTU, | |
157 | TCG_COND_GEU, | |
158 | TCG_COND_LEU, | |
159 | TCG_COND_GTU, | |
160 | } TCGCond; | |
161 | ||
162 | #define TEMP_VAL_DEAD 0 | |
163 | #define TEMP_VAL_REG 1 | |
164 | #define TEMP_VAL_MEM 2 | |
165 | #define TEMP_VAL_CONST 3 | |
166 | ||
167 | /* XXX: optimize memory layout */ | |
168 | typedef struct TCGTemp { | |
169 | TCGType base_type; | |
170 | TCGType type; | |
171 | int val_type; | |
172 | int reg; | |
173 | tcg_target_long val; | |
174 | int mem_reg; | |
175 | tcg_target_long mem_offset; | |
176 | unsigned int fixed_reg:1; | |
177 | unsigned int mem_coherent:1; | |
178 | unsigned int mem_allocated:1; | |
179 | const char *name; | |
180 | } TCGTemp; | |
181 | ||
182 | typedef struct TCGHelperInfo { | |
183 | void *func; | |
184 | const char *name; | |
185 | } TCGHelperInfo; | |
186 | ||
187 | typedef struct TCGContext TCGContext; | |
188 | ||
189 | typedef void TCGMacroFunc(TCGContext *s, int macro_id, const int *dead_args); | |
190 | ||
191 | struct TCGContext { | |
192 | uint8_t *pool_cur, *pool_end; | |
193 | TCGPool *pool_first, *pool_current; | |
194 | TCGLabel *labels; | |
195 | int nb_labels; | |
196 | TCGTemp *temps; /* globals first, temps after */ | |
197 | int nb_globals; | |
198 | int nb_temps; | |
199 | /* constant indexes (end of temp array) */ | |
200 | int const_start; | |
201 | int const_end; | |
202 | ||
203 | /* goto_tb support */ | |
204 | uint8_t *code_buf; | |
205 | unsigned long *tb_next; | |
206 | uint16_t *tb_next_offset; | |
207 | uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */ | |
208 | ||
209 | uint16_t *op_dead_iargs; /* for each operation, each bit tells if the | |
210 | corresponding input argument is dead */ | |
211 | /* tells in which temporary a given register is. It does not take | |
212 | into account fixed registers */ | |
213 | int reg_to_temp[TCG_TARGET_NB_REGS]; | |
214 | TCGRegSet reserved_regs; | |
215 | tcg_target_long current_frame_offset; | |
216 | tcg_target_long frame_start; | |
217 | tcg_target_long frame_end; | |
218 | int frame_reg; | |
219 | ||
220 | uint8_t *code_ptr; | |
221 | TCGTemp static_temps[TCG_MAX_TEMPS]; | |
222 | ||
223 | TCGMacroFunc *macro_func; | |
224 | TCGHelperInfo *helpers; | |
225 | int nb_helpers; | |
226 | int allocated_helpers; | |
227 | }; | |
228 | ||
229 | extern TCGContext tcg_ctx; | |
230 | extern uint16_t *gen_opc_ptr; | |
231 | extern TCGArg *gen_opparam_ptr; | |
232 | extern uint16_t gen_opc_buf[]; | |
233 | extern TCGArg gen_opparam_buf[]; | |
234 | ||
235 | /* pool based memory allocation */ | |
236 | ||
237 | void *tcg_malloc_internal(TCGContext *s, int size); | |
238 | void tcg_pool_reset(TCGContext *s); | |
239 | void tcg_pool_delete(TCGContext *s); | |
240 | ||
241 | static inline void *tcg_malloc(int size) | |
242 | { | |
243 | TCGContext *s = &tcg_ctx; | |
244 | uint8_t *ptr, *ptr_end; | |
245 | size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1); | |
246 | ptr = s->pool_cur; | |
247 | ptr_end = ptr + size; | |
248 | if (unlikely(ptr_end > s->pool_end)) { | |
249 | return tcg_malloc_internal(&tcg_ctx, size); | |
250 | } else { | |
251 | s->pool_cur = ptr_end; | |
252 | return ptr; | |
253 | } | |
254 | } | |
255 | ||
256 | void tcg_context_init(TCGContext *s); | |
257 | void tcg_func_start(TCGContext *s); | |
258 | ||
259 | int dyngen_code(TCGContext *s, uint8_t *gen_code_buf); | |
623e265c | 260 | int dyngen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset); |
c896fe29 FB |
261 | |
262 | void tcg_set_frame(TCGContext *s, int reg, | |
263 | tcg_target_long start, tcg_target_long size); | |
264 | void tcg_set_macro_func(TCGContext *s, TCGMacroFunc *func); | |
ac56dd48 PB |
265 | TCGv tcg_global_reg_new(TCGType type, int reg, const char *name); |
266 | TCGv tcg_global_mem_new(TCGType type, int reg, tcg_target_long offset, | |
267 | const char *name); | |
268 | TCGv tcg_temp_new(TCGType type); | |
269 | char *tcg_get_arg_str(TCGContext *s, char *buf, int buf_size, TCGv arg); | |
c896fe29 FB |
270 | |
271 | #define TCG_CT_ALIAS 0x80 | |
272 | #define TCG_CT_IALIAS 0x40 | |
273 | #define TCG_CT_REG 0x01 | |
274 | #define TCG_CT_CONST 0x02 /* any constant of register size */ | |
275 | ||
276 | typedef struct TCGArgConstraint { | |
5ff9d6a4 FB |
277 | uint16_t ct; |
278 | uint8_t alias_index; | |
c896fe29 FB |
279 | union { |
280 | TCGRegSet regs; | |
281 | } u; | |
282 | } TCGArgConstraint; | |
283 | ||
284 | #define TCG_MAX_OP_ARGS 16 | |
285 | ||
286 | #define TCG_OPF_BB_END 0x01 /* instruction defines the end of a basic | |
287 | block */ | |
288 | #define TCG_OPF_CALL_CLOBBER 0x02 /* instruction clobbers call registers */ | |
5ff9d6a4 | 289 | #define TCG_OPF_SIDE_EFFECTS 0x04 /* instruction has side effects */ |
c896fe29 FB |
290 | |
291 | typedef struct TCGOpDef { | |
292 | const char *name; | |
293 | uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args; | |
294 | uint8_t flags; | |
295 | uint16_t copy_size; | |
296 | TCGArgConstraint *args_ct; | |
297 | int *sorted_args; | |
298 | } TCGOpDef; | |
299 | ||
300 | typedef struct TCGTargetOpDef { | |
301 | int op; | |
302 | const char *args_ct_str[TCG_MAX_OP_ARGS]; | |
303 | } TCGTargetOpDef; | |
304 | ||
305 | extern TCGOpDef tcg_op_defs[]; | |
306 | ||
307 | void tcg_target_init(TCGContext *s); | |
308 | ||
309 | #define tcg_abort() \ | |
310 | do {\ | |
311 | fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\ | |
312 | abort();\ | |
313 | } while (0) | |
314 | ||
315 | void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs); | |
316 | ||
ac56dd48 PB |
317 | void tcg_gen_call(TCGContext *s, TCGv func, unsigned int flags, |
318 | unsigned int nb_rets, const TCGv *rets, | |
319 | unsigned int nb_params, const TCGv *args1); | |
320 | void tcg_gen_shifti_i64(TCGv ret, TCGv arg1, | |
c896fe29 FB |
321 | int c, int right, int arith); |
322 | ||
323 | /* only used for debugging purposes */ | |
324 | void tcg_register_helper(void *func, const char *name); | |
325 | #define TCG_HELPER(func) tcg_register_helper(func, #func) | |
326 | const char *tcg_helper_get_name(TCGContext *s, void *func); | |
327 | void tcg_dump_ops(TCGContext *s, FILE *outfile); | |
328 | ||
329 | void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf); | |
ac56dd48 PB |
330 | TCGv tcg_const_i32(int32_t val); |
331 | TCGv tcg_const_i64(int64_t val); | |
c896fe29 FB |
332 | |
333 | #if TCG_TARGET_REG_BITS == 32 | |
334 | #define tcg_const_ptr tcg_const_i32 | |
335 | #define tcg_add_ptr tcg_add_i32 | |
336 | #define tcg_sub_ptr tcg_sub_i32 | |
337 | #else | |
338 | #define tcg_const_ptr tcg_const_i64 | |
339 | #define tcg_add_ptr tcg_add_i64 | |
340 | #define tcg_sub_ptr tcg_sub_i64 | |
341 | #endif | |
342 | ||
343 | void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, | |
344 | int label_index, long addend); | |
345 | void tcg_reg_alloc_start(TCGContext *s); | |
346 | void tcg_reg_alloc_bb_end(TCGContext *s); | |
347 | void tcg_liveness_analysis(TCGContext *s); | |
348 | const TCGArg *tcg_gen_code_op(TCGContext *s, int opc, const TCGArg *args1, | |
349 | unsigned int dead_iargs); | |
350 | ||
351 | const TCGArg *dyngen_op(TCGContext *s, int opc, const TCGArg *opparam_ptr); | |
352 | ||
353 | /* tcg-runtime.c */ | |
354 | int64_t tcg_helper_shl_i64(int64_t arg1, int64_t arg2); | |
355 | int64_t tcg_helper_shr_i64(int64_t arg1, int64_t arg2); | |
356 | int64_t tcg_helper_sar_i64(int64_t arg1, int64_t arg2); | |
357 | int64_t tcg_helper_div_i64(int64_t arg1, int64_t arg2); | |
358 | int64_t tcg_helper_rem_i64(int64_t arg1, int64_t arg2); | |
359 | uint64_t tcg_helper_divu_i64(uint64_t arg1, uint64_t arg2); | |
360 | uint64_t tcg_helper_remu_i64(uint64_t arg1, uint64_t arg2); |