?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qemu-ga: persist tracking of fsfreeze state via filesystem
[qemu/kevin.git] / tcg / tcg.c
blobab589c7ad262f05eda96b735802bfcdf8a8e0b40
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
25 /* define it to use liveness analysis (better code) */
26 #define USE_LIVENESS_ANALYSIS
27 #define USE_TCG_OPTIMIZATIONS
28
29 #include "config.h"
30
31 /* Define to jump the ELF file used to communicate with GDB. */
32 #undef DEBUG_JIT
33
34 #if !defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG)
35 /* define it to suppress various consistency checks (faster) */
36 #define NDEBUG
37 #endif
38
39 #include "qemu-common.h"
40 #include "cache-utils.h"
41 #include "host-utils.h"
42 #include "qemu-timer.h"
43
44 /* Note: the long term plan is to reduce the dependancies on the QEMU
45 CPU definitions. Currently they are used for qemu_ld/st
46 instructions */
47 #define NO_CPU_IO_DEFS
48 #include "cpu.h"
49
50 #include "tcg-op.h"
51
52 #if TCG_TARGET_REG_BITS == 64
53 # define ELF_CLASS ELFCLASS64
54 #else
55 # define ELF_CLASS ELFCLASS32
56 #endif
57 #ifdef HOST_WORDS_BIGENDIAN
58 # define ELF_DATA ELFDATA2MSB
59 #else
60 # define ELF_DATA ELFDATA2LSB
61 #endif
62
63 #include "elf.h"
64
65 #if defined(CONFIG_USE_GUEST_BASE) && !defined(TCG_TARGET_HAS_GUEST_BASE)
66 #error GUEST_BASE not supported on this host.
67 #endif
68
69 /* Forward declarations for functions declared in tcg-target.c and used here. */
70 static void tcg_target_init(TCGContext *s);
71 static void tcg_target_qemu_prologue(TCGContext *s);
72 static void patch_reloc(uint8_t *code_ptr, int type,
73 tcg_target_long value, tcg_target_long addend);
74
75 static void tcg_register_jit_int(void *buf, size_t size,
76 void *debug_frame, size_t debug_frame_size)
77 __attribute__((unused));
78
79 /* Forward declarations for functions declared and used in tcg-target.c. */
80 static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str);
81 static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1,
82 tcg_target_long arg2);
83 static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg);
84 static void tcg_out_movi(TCGContext *s, TCGType type,
85 TCGReg ret, tcg_target_long arg);
86 static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args,
87 const int *const_args);
88 static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1,
89 tcg_target_long arg2);
90 static int tcg_target_const_match(tcg_target_long val,
91 const TCGArgConstraint *arg_ct);
92 static int tcg_target_get_call_iarg_regs_count(int flags);
93
94 TCGOpDef tcg_op_defs[] = {
95 #define DEF(s, oargs, iargs, cargs, flags) { #s, oargs, iargs, cargs, iargs + oargs + cargs, flags },
96 #include "tcg-opc.h"
97 #undef DEF
98 };
99 const size_t tcg_op_defs_max = ARRAY_SIZE(tcg_op_defs);
100
101 static TCGRegSet tcg_target_available_regs[2];
102 static TCGRegSet tcg_target_call_clobber_regs;
103
104 /* XXX: move that inside the context */
105 uint16_t *gen_opc_ptr;
106 TCGArg *gen_opparam_ptr;
107
108 static inline void tcg_out8(TCGContext *s, uint8_t v)
109 {
110 *s->code_ptr++ = v;
111 }
112
113 static inline void tcg_out16(TCGContext *s, uint16_t v)
114 {
115 *(uint16_t *)s->code_ptr = v;
116 s->code_ptr += 2;
117 }
118
119 static inline void tcg_out32(TCGContext *s, uint32_t v)
120 {
121 *(uint32_t *)s->code_ptr = v;
122 s->code_ptr += 4;
123 }
124
125 /* label relocation processing */
126
127 static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type,
128 int label_index, long addend)
129 {
130 TCGLabel *l;
131 TCGRelocation *r;
132
133 l = &s->labels[label_index];
134 if (l->has_value) {
135 /* FIXME: This may break relocations on RISC targets that
136 modify instruction fields in place. The caller may not have
137 written the initial value. */
138 patch_reloc(code_ptr, type, l->u.value, addend);
139 } else {
140 /* add a new relocation entry */
141 r = tcg_malloc(sizeof(TCGRelocation));
142 r->type = type;
143 r->ptr = code_ptr;
144 r->addend = addend;
145 r->next = l->u.first_reloc;
146 l->u.first_reloc = r;
147 }
148 }
149
150 static void tcg_out_label(TCGContext *s, int label_index, void *ptr)
151 {
152 TCGLabel *l;
153 TCGRelocation *r;
154 tcg_target_long value = (tcg_target_long)ptr;
155
156 l = &s->labels[label_index];
157 if (l->has_value)
158 tcg_abort();
159 r = l->u.first_reloc;
160 while (r != NULL) {
161 patch_reloc(r->ptr, r->type, value, r->addend);
162 r = r->next;
163 }
164 l->has_value = 1;
165 l->u.value = value;
166 }
167
168 int gen_new_label(void)
169 {
170 TCGContext *s = &tcg_ctx;
171 int idx;
172 TCGLabel *l;
173
174 if (s->nb_labels >= TCG_MAX_LABELS)
175 tcg_abort();
176 idx = s->nb_labels++;
177 l = &s->labels[idx];
178 l->has_value = 0;
179 l->u.first_reloc = NULL;
180 return idx;
181 }
182
183 #include "tcg-target.c"
184
185 /* pool based memory allocation */
186 void *tcg_malloc_internal(TCGContext *s, int size)
187 {
188 TCGPool *p;
189 int pool_size;
190
191 if (size > TCG_POOL_CHUNK_SIZE) {
192 /* big malloc: insert a new pool (XXX: could optimize) */
193 p = g_malloc(sizeof(TCGPool) + size);
194 p->size = size;
195 p->next = s->pool_first_large;
196 s->pool_first_large = p;
197 return p->data;
198 } else {
199 p = s->pool_current;
200 if (!p) {
201 p = s->pool_first;
202 if (!p)
203 goto new_pool;
204 } else {
205 if (!p->next) {
206 new_pool:
207 pool_size = TCG_POOL_CHUNK_SIZE;
208 p = g_malloc(sizeof(TCGPool) + pool_size);
209 p->size = pool_size;
210 p->next = NULL;
211 if (s->pool_current)
212 s->pool_current->next = p;
213 else
214 s->pool_first = p;
215 } else {
216 p = p->next;
217 }
218 }
219 }
220 s->pool_current = p;
221 s->pool_cur = p->data + size;
222 s->pool_end = p->data + p->size;
223 return p->data;
224 }
225
226 void tcg_pool_reset(TCGContext *s)
227 {
228 TCGPool *p, *t;
229 for (p = s->pool_first_large; p; p = t) {
230 t = p->next;
231 g_free(p);
232 }
233 s->pool_first_large = NULL;
234 s->pool_cur = s->pool_end = NULL;
235 s->pool_current = NULL;
236 }
237
238 void tcg_context_init(TCGContext *s)
239 {
240 int op, total_args, n;
241 TCGOpDef *def;
242 TCGArgConstraint *args_ct;
243 int *sorted_args;
244
245 memset(s, 0, sizeof(*s));
246 s->temps = s->static_temps;
247 s->nb_globals = 0;
248
249 /* Count total number of arguments and allocate the corresponding
250 space */
251 total_args = 0;
252 for(op = 0; op < NB_OPS; op++) {
253 def = &tcg_op_defs[op];
254 n = def->nb_iargs + def->nb_oargs;
255 total_args += n;
256 }
257
258 args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args);
259 sorted_args = g_malloc(sizeof(int) * total_args);
260
261 for(op = 0; op < NB_OPS; op++) {
262 def = &tcg_op_defs[op];
263 def->args_ct = args_ct;
264 def->sorted_args = sorted_args;
265 n = def->nb_iargs + def->nb_oargs;
266 sorted_args += n;
267 args_ct += n;
268 }
269
270 tcg_target_init(s);
271 }
272
273 void tcg_prologue_init(TCGContext *s)
274 {
275 /* init global prologue and epilogue */
276 s->code_buf = code_gen_prologue;
277 s->code_ptr = s->code_buf;
278 tcg_target_qemu_prologue(s);
279 flush_icache_range((tcg_target_ulong)s->code_buf,
280 (tcg_target_ulong)s->code_ptr);
281 }
282
283 void tcg_set_frame(TCGContext *s, int reg,
284 tcg_target_long start, tcg_target_long size)
285 {
286 s->frame_start = start;
287 s->frame_end = start + size;
288 s->frame_reg = reg;
289 }
290
291 void tcg_func_start(TCGContext *s)
292 {
293 int i;
294 tcg_pool_reset(s);
295 s->nb_temps = s->nb_globals;
296 for(i = 0; i < (TCG_TYPE_COUNT * 2); i++)
297 s->first_free_temp[i] = -1;
298 s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS);
299 s->nb_labels = 0;
300 s->current_frame_offset = s->frame_start;
301
302 gen_opc_ptr = gen_opc_buf;
303 gen_opparam_ptr = gen_opparam_buf;
304 }
305
306 static inline void tcg_temp_alloc(TCGContext *s, int n)
307 {
308 if (n > TCG_MAX_TEMPS)
309 tcg_abort();
310 }
311
312 static inline int tcg_global_reg_new_internal(TCGType type, int reg,
313 const char *name)
314 {
315 TCGContext *s = &tcg_ctx;
316 TCGTemp *ts;
317 int idx;
318
319 #if TCG_TARGET_REG_BITS == 32
320 if (type != TCG_TYPE_I32)
321 tcg_abort();
322 #endif
323 if (tcg_regset_test_reg(s->reserved_regs, reg))
324 tcg_abort();
325 idx = s->nb_globals;
326 tcg_temp_alloc(s, s->nb_globals + 1);
327 ts = &s->temps[s->nb_globals];
328 ts->base_type = type;
329 ts->type = type;
330 ts->fixed_reg = 1;
331 ts->reg = reg;
332 ts->name = name;
333 s->nb_globals++;
334 tcg_regset_set_reg(s->reserved_regs, reg);
335 return idx;
336 }
337
338 TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name)
339 {
340 int idx;
341
342 idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name);
343 return MAKE_TCGV_I32(idx);
344 }
345
346 TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name)
347 {
348 int idx;
349
350 idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name);
351 return MAKE_TCGV_I64(idx);
352 }
353
354 static inline int tcg_global_mem_new_internal(TCGType type, int reg,
355 tcg_target_long offset,
356 const char *name)
357 {
358 TCGContext *s = &tcg_ctx;
359 TCGTemp *ts;
360 int idx;
361
362 idx = s->nb_globals;
363 #if TCG_TARGET_REG_BITS == 32
364 if (type == TCG_TYPE_I64) {
365 char buf[64];
366 tcg_temp_alloc(s, s->nb_globals + 2);
367 ts = &s->temps[s->nb_globals];
368 ts->base_type = type;
369 ts->type = TCG_TYPE_I32;
370 ts->fixed_reg = 0;
371 ts->mem_allocated = 1;
372 ts->mem_reg = reg;
373 #ifdef TCG_TARGET_WORDS_BIGENDIAN
374 ts->mem_offset = offset + 4;
375 #else
376 ts->mem_offset = offset;
377 #endif
378 pstrcpy(buf, sizeof(buf), name);
379 pstrcat(buf, sizeof(buf), "_0");
380 ts->name = strdup(buf);
381 ts++;
382
383 ts->base_type = type;
384 ts->type = TCG_TYPE_I32;
385 ts->fixed_reg = 0;
386 ts->mem_allocated = 1;
387 ts->mem_reg = reg;
388 #ifdef TCG_TARGET_WORDS_BIGENDIAN
389 ts->mem_offset = offset;
390 #else
391 ts->mem_offset = offset + 4;
392 #endif
393 pstrcpy(buf, sizeof(buf), name);
394 pstrcat(buf, sizeof(buf), "_1");
395 ts->name = strdup(buf);
396
397 s->nb_globals += 2;
398 } else
399 #endif
400 {
401 tcg_temp_alloc(s, s->nb_globals + 1);
402 ts = &s->temps[s->nb_globals];
403 ts->base_type = type;
404 ts->type = type;
405 ts->fixed_reg = 0;
406 ts->mem_allocated = 1;
407 ts->mem_reg = reg;
408 ts->mem_offset = offset;
409 ts->name = name;
410 s->nb_globals++;
411 }
412 return idx;
413 }
414
415 TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset,
416 const char *name)
417 {
418 int idx;
419
420 idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name);
421 return MAKE_TCGV_I32(idx);
422 }
423
424 TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset,
425 const char *name)
426 {
427 int idx;
428
429 idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name);
430 return MAKE_TCGV_I64(idx);
431 }
432
433 static inline int tcg_temp_new_internal(TCGType type, int temp_local)
434 {
435 TCGContext *s = &tcg_ctx;
436 TCGTemp *ts;
437 int idx, k;
438
439 k = type;
440 if (temp_local)
441 k += TCG_TYPE_COUNT;
442 idx = s->first_free_temp[k];
443 if (idx != -1) {
444 /* There is already an available temp with the
445 right type */
446 ts = &s->temps[idx];
447 s->first_free_temp[k] = ts->next_free_temp;
448 ts->temp_allocated = 1;
449 assert(ts->temp_local == temp_local);
450 } else {
451 idx = s->nb_temps;
452 #if TCG_TARGET_REG_BITS == 32
453 if (type == TCG_TYPE_I64) {
454 tcg_temp_alloc(s, s->nb_temps + 2);
455 ts = &s->temps[s->nb_temps];
456 ts->base_type = type;
457 ts->type = TCG_TYPE_I32;
458 ts->temp_allocated = 1;
459 ts->temp_local = temp_local;
460 ts->name = NULL;
461 ts++;
462 ts->base_type = TCG_TYPE_I32;
463 ts->type = TCG_TYPE_I32;
464 ts->temp_allocated = 1;
465 ts->temp_local = temp_local;
466 ts->name = NULL;
467 s->nb_temps += 2;
468 } else
469 #endif
470 {
471 tcg_temp_alloc(s, s->nb_temps + 1);
472 ts = &s->temps[s->nb_temps];
473 ts->base_type = type;
474 ts->type = type;
475 ts->temp_allocated = 1;
476 ts->temp_local = temp_local;
477 ts->name = NULL;
478 s->nb_temps++;
479 }
480 }
481
482 #if defined(CONFIG_DEBUG_TCG)
483 s->temps_in_use++;
484 #endif
485 return idx;
486 }
487
488 TCGv_i32 tcg_temp_new_internal_i32(int temp_local)
489 {
490 int idx;
491
492 idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local);
493 return MAKE_TCGV_I32(idx);
494 }
495
496 TCGv_i64 tcg_temp_new_internal_i64(int temp_local)
497 {
498 int idx;
499
500 idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local);
501 return MAKE_TCGV_I64(idx);
502 }
503
504 static inline void tcg_temp_free_internal(int idx)
505 {
506 TCGContext *s = &tcg_ctx;
507 TCGTemp *ts;
508 int k;
509
510 #if defined(CONFIG_DEBUG_TCG)
511 s->temps_in_use--;
512 if (s->temps_in_use < 0) {
513 fprintf(stderr, "More temporaries freed than allocated!\n");
514 }
515 #endif
516
517 assert(idx >= s->nb_globals && idx < s->nb_temps);
518 ts = &s->temps[idx];
519 assert(ts->temp_allocated != 0);
520 ts->temp_allocated = 0;
521 k = ts->base_type;
522 if (ts->temp_local)
523 k += TCG_TYPE_COUNT;
524 ts->next_free_temp = s->first_free_temp[k];
525 s->first_free_temp[k] = idx;
526 }
527
528 void tcg_temp_free_i32(TCGv_i32 arg)
529 {
530 tcg_temp_free_internal(GET_TCGV_I32(arg));
531 }
532
533 void tcg_temp_free_i64(TCGv_i64 arg)
534 {
535 tcg_temp_free_internal(GET_TCGV_I64(arg));
536 }
537
538 TCGv_i32 tcg_const_i32(int32_t val)
539 {
540 TCGv_i32 t0;
541 t0 = tcg_temp_new_i32();
542 tcg_gen_movi_i32(t0, val);
543 return t0;
544 }
545
546 TCGv_i64 tcg_const_i64(int64_t val)
547 {
548 TCGv_i64 t0;
549 t0 = tcg_temp_new_i64();
550 tcg_gen_movi_i64(t0, val);
551 return t0;
552 }
553
554 TCGv_i32 tcg_const_local_i32(int32_t val)
555 {
556 TCGv_i32 t0;
557 t0 = tcg_temp_local_new_i32();
558 tcg_gen_movi_i32(t0, val);
559 return t0;
560 }
561
562 TCGv_i64 tcg_const_local_i64(int64_t val)
563 {
564 TCGv_i64 t0;
565 t0 = tcg_temp_local_new_i64();
566 tcg_gen_movi_i64(t0, val);
567 return t0;
568 }
569
570 #if defined(CONFIG_DEBUG_TCG)
571 void tcg_clear_temp_count(void)
572 {
573 TCGContext *s = &tcg_ctx;
574 s->temps_in_use = 0;
575 }
576
577 int tcg_check_temp_count(void)
578 {
579 TCGContext *s = &tcg_ctx;
580 if (s->temps_in_use) {
581 /* Clear the count so that we don't give another
582 * warning immediately next time around.
583 */
584 s->temps_in_use = 0;
585 return 1;
586 }
587 return 0;
588 }
589 #endif
590
591 void tcg_register_helper(void *func, const char *name)
592 {
593 TCGContext *s = &tcg_ctx;
594 int n;
595 if ((s->nb_helpers + 1) > s->allocated_helpers) {
596 n = s->allocated_helpers;
597 if (n == 0) {
598 n = 4;
599 } else {
600 n *= 2;
601 }
602 s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo));
603 s->allocated_helpers = n;
604 }
605 s->helpers[s->nb_helpers].func = (tcg_target_ulong)func;
606 s->helpers[s->nb_helpers].name = name;
607 s->nb_helpers++;
608 }
609
610 /* Note: we convert the 64 bit args to 32 bit and do some alignment
611 and endian swap. Maybe it would be better to do the alignment
612 and endian swap in tcg_reg_alloc_call(). */
613 void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags,
614 int sizemask, TCGArg ret, int nargs, TCGArg *args)
615 {
616 int i;
617 int real_args;
618 int nb_rets;
619 TCGArg *nparam;
620
621 #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64
622 for (i = 0; i < nargs; ++i) {
623 int is_64bit = sizemask & (1 << (i+1)*2);
624 int is_signed = sizemask & (2 << (i+1)*2);
625 if (!is_64bit) {
626 TCGv_i64 temp = tcg_temp_new_i64();
627 TCGv_i64 orig = MAKE_TCGV_I64(args[i]);
628 if (is_signed) {
629 tcg_gen_ext32s_i64(temp, orig);
630 } else {
631 tcg_gen_ext32u_i64(temp, orig);
632 }
633 args[i] = GET_TCGV_I64(temp);
634 }
635 }
636 #endif /* TCG_TARGET_EXTEND_ARGS */
637
638 *gen_opc_ptr++ = INDEX_op_call;
639 nparam = gen_opparam_ptr++;
640 if (ret != TCG_CALL_DUMMY_ARG) {
641 #if TCG_TARGET_REG_BITS < 64
642 if (sizemask & 1) {
643 #ifdef TCG_TARGET_WORDS_BIGENDIAN
644 *gen_opparam_ptr++ = ret + 1;
645 *gen_opparam_ptr++ = ret;
646 #else
647 *gen_opparam_ptr++ = ret;
648 *gen_opparam_ptr++ = ret + 1;
649 #endif
650 nb_rets = 2;
651 } else
652 #endif
653 {
654 *gen_opparam_ptr++ = ret;
655 nb_rets = 1;
656 }
657 } else {
658 nb_rets = 0;
659 }
660 real_args = 0;
661 for (i = 0; i < nargs; i++) {
662 #if TCG_TARGET_REG_BITS < 64
663 int is_64bit = sizemask & (1 << (i+1)*2);
664 if (is_64bit) {
665 #ifdef TCG_TARGET_CALL_ALIGN_ARGS
666 /* some targets want aligned 64 bit args */
667 if (real_args & 1) {
668 *gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG;
669 real_args++;
670 }
671 #endif
672 /* If stack grows up, then we will be placing successive
673 arguments at lower addresses, which means we need to
674 reverse the order compared to how we would normally
675 treat either big or little-endian. For those arguments
676 that will wind up in registers, this still works for
677 HPPA (the only current STACK_GROWSUP target) since the
678 argument registers are *also* allocated in decreasing
679 order. If another such target is added, this logic may
680 have to get more complicated to differentiate between
681 stack arguments and register arguments. */
682 #if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP)
683 *gen_opparam_ptr++ = args[i] + 1;
684 *gen_opparam_ptr++ = args[i];
685 #else
686 *gen_opparam_ptr++ = args[i];
687 *gen_opparam_ptr++ = args[i] + 1;
688 #endif
689 real_args += 2;
690 continue;
691 }
692 #endif /* TCG_TARGET_REG_BITS < 64 */
693
694 *gen_opparam_ptr++ = args[i];
695 real_args++;
696 }
697 *gen_opparam_ptr++ = GET_TCGV_PTR(func);
698
699 *gen_opparam_ptr++ = flags;
700
701 *nparam = (nb_rets << 16) | (real_args + 1);
702
703 /* total parameters, needed to go backward in the instruction stream */
704 *gen_opparam_ptr++ = 1 + nb_rets + real_args + 3;
705
706 #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64
707 for (i = 0; i < nargs; ++i) {
708 int is_64bit = sizemask & (1 << (i+1)*2);
709 if (!is_64bit) {
710 TCGv_i64 temp = MAKE_TCGV_I64(args[i]);
711 tcg_temp_free_i64(temp);
712 }
713 }
714 #endif /* TCG_TARGET_EXTEND_ARGS */
715 }
716
717 #if TCG_TARGET_REG_BITS == 32
718 void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
719 int c, int right, int arith)
720 {
721 if (c == 0) {
722 tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1));
723 tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1));
724 } else if (c >= 32) {
725 c -= 32;
726 if (right) {
727 if (arith) {
728 tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c);
729 tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31);
730 } else {
731 tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c);
732 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
733 }
734 } else {
735 tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c);
736 tcg_gen_movi_i32(TCGV_LOW(ret), 0);
737 }
738 } else {
739 TCGv_i32 t0, t1;
740
741 t0 = tcg_temp_new_i32();
742 t1 = tcg_temp_new_i32();
743 if (right) {
744 tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c);
745 if (arith)
746 tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c);
747 else
748 tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c);
749 tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c);
750 tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0);
751 tcg_gen_mov_i32(TCGV_HIGH(ret), t1);
752 } else {
753 tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c);
754 /* Note: ret can be the same as arg1, so we use t1 */
755 tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c);
756 tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c);
757 tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0);
758 tcg_gen_mov_i32(TCGV_LOW(ret), t1);
759 }
760 tcg_temp_free_i32(t0);
761 tcg_temp_free_i32(t1);
762 }
763 }
764 #endif
765
766
767 static void tcg_reg_alloc_start(TCGContext *s)
768 {
769 int i;
770 TCGTemp *ts;
771 for(i = 0; i < s->nb_globals; i++) {
772 ts = &s->temps[i];
773 if (ts->fixed_reg) {
774 ts->val_type = TEMP_VAL_REG;
775 } else {
776 ts->val_type = TEMP_VAL_MEM;
777 }
778 }
779 for(i = s->nb_globals; i < s->nb_temps; i++) {
780 ts = &s->temps[i];
781 ts->val_type = TEMP_VAL_DEAD;
782 ts->mem_allocated = 0;
783 ts->fixed_reg = 0;
784 }
785 for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
786 s->reg_to_temp[i] = -1;
787 }
788 }
789
790 static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size,
791 int idx)
792 {
793 TCGTemp *ts;
794
795 assert(idx >= 0 && idx < s->nb_temps);
796 ts = &s->temps[idx];
797 assert(ts);
798 if (idx < s->nb_globals) {
799 pstrcpy(buf, buf_size, ts->name);
800 } else {
801 if (ts->temp_local)
802 snprintf(buf, buf_size, "loc%d", idx - s->nb_globals);
803 else
804 snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals);
805 }
806 return buf;
807 }
808
809 char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg)
810 {
811 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg));
812 }
813
814 char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg)
815 {
816 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg));
817 }
818
819 static int helper_cmp(const void *p1, const void *p2)
820 {
821 const TCGHelperInfo *th1 = p1;
822 const TCGHelperInfo *th2 = p2;
823 if (th1->func < th2->func)
824 return -1;
825 else if (th1->func == th2->func)
826 return 0;
827 else
828 return 1;
829 }
830
831 /* find helper definition (Note: A hash table would be better) */
832 static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val)
833 {
834 int m, m_min, m_max;
835 TCGHelperInfo *th;
836 tcg_target_ulong v;
837
838 if (unlikely(!s->helpers_sorted)) {
839 qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo),
840 helper_cmp);
841 s->helpers_sorted = 1;
842 }
843
844 /* binary search */
845 m_min = 0;
846 m_max = s->nb_helpers - 1;
847 while (m_min <= m_max) {
848 m = (m_min + m_max) >> 1;
849 th = &s->helpers[m];
850 v = th->func;
851 if (v == val)
852 return th;
853 else if (val < v) {
854 m_max = m - 1;
855 } else {
856 m_min = m + 1;
857 }
858 }
859 return NULL;
860 }
861
862 static const char * const cond_name[] =
863 {
864 [TCG_COND_EQ] = "eq",
865 [TCG_COND_NE] = "ne",
866 [TCG_COND_LT] = "lt",
867 [TCG_COND_GE] = "ge",
868 [TCG_COND_LE] = "le",
869 [TCG_COND_GT] = "gt",
870 [TCG_COND_LTU] = "ltu",
871 [TCG_COND_GEU] = "geu",
872 [TCG_COND_LEU] = "leu",
873 [TCG_COND_GTU] = "gtu"
874 };
875
876 void tcg_dump_ops(TCGContext *s, FILE *outfile)
877 {
878 const uint16_t *opc_ptr;
879 const TCGArg *args;
880 TCGArg arg;
881 TCGOpcode c;
882 int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn;
883 const TCGOpDef *def;
884 char buf[128];
885
886 first_insn = 1;
887 opc_ptr = gen_opc_buf;
888 args = gen_opparam_buf;
889 while (opc_ptr < gen_opc_ptr) {
890 c = *opc_ptr++;
891 def = &tcg_op_defs[c];
892 if (c == INDEX_op_debug_insn_start) {
893 uint64_t pc;
894 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
895 pc = ((uint64_t)args[1] << 32) | args[0];
896 #else
897 pc = args[0];
898 #endif
899 if (!first_insn)
900 fprintf(outfile, "\n");
901 fprintf(outfile, " ---- 0x%" PRIx64, pc);
902 first_insn = 0;
903 nb_oargs = def->nb_oargs;
904 nb_iargs = def->nb_iargs;
905 nb_cargs = def->nb_cargs;
906 } else if (c == INDEX_op_call) {
907 TCGArg arg;
908
909 /* variable number of arguments */
910 arg = *args++;
911 nb_oargs = arg >> 16;
912 nb_iargs = arg & 0xffff;
913 nb_cargs = def->nb_cargs;
914
915 fprintf(outfile, " %s ", def->name);
916
917 /* function name */
918 fprintf(outfile, "%s",
919 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + nb_iargs - 1]));
920 /* flags */
921 fprintf(outfile, ",$0x%" TCG_PRIlx,
922 args[nb_oargs + nb_iargs]);
923 /* nb out args */
924 fprintf(outfile, ",$%d", nb_oargs);
925 for(i = 0; i < nb_oargs; i++) {
926 fprintf(outfile, ",");
927 fprintf(outfile, "%s",
928 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[i]));
929 }
930 for(i = 0; i < (nb_iargs - 1); i++) {
931 fprintf(outfile, ",");
932 if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) {
933 fprintf(outfile, "<dummy>");
934 } else {
935 fprintf(outfile, "%s",
936 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + i]));
937 }
938 }
939 } else if (c == INDEX_op_movi_i32
940 #if TCG_TARGET_REG_BITS == 64
941 || c == INDEX_op_movi_i64
942 #endif
943 ) {
944 tcg_target_ulong val;
945 TCGHelperInfo *th;
946
947 nb_oargs = def->nb_oargs;
948 nb_iargs = def->nb_iargs;
949 nb_cargs = def->nb_cargs;
950 fprintf(outfile, " %s %s,$", def->name,
951 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0]));
952 val = args[1];
953 th = tcg_find_helper(s, val);
954 if (th) {
955 fprintf(outfile, "%s", th->name);
956 } else {
957 if (c == INDEX_op_movi_i32)
958 fprintf(outfile, "0x%x", (uint32_t)val);
959 else
960 fprintf(outfile, "0x%" PRIx64 , (uint64_t)val);
961 }
962 } else {
963 fprintf(outfile, " %s ", def->name);
964 if (c == INDEX_op_nopn) {
965 /* variable number of arguments */
966 nb_cargs = *args;
967 nb_oargs = 0;
968 nb_iargs = 0;
969 } else {
970 nb_oargs = def->nb_oargs;
971 nb_iargs = def->nb_iargs;
972 nb_cargs = def->nb_cargs;
973 }
974
975 k = 0;
976 for(i = 0; i < nb_oargs; i++) {
977 if (k != 0)
978 fprintf(outfile, ",");
979 fprintf(outfile, "%s",
980 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++]));
981 }
982 for(i = 0; i < nb_iargs; i++) {
983 if (k != 0)
984 fprintf(outfile, ",");
985 fprintf(outfile, "%s",
986 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++]));
987 }
988 switch (c) {
989 case INDEX_op_brcond_i32:
990 #if TCG_TARGET_REG_BITS == 32
991 case INDEX_op_brcond2_i32:
992 #elif TCG_TARGET_REG_BITS == 64
993 case INDEX_op_brcond_i64:
994 #endif
995 case INDEX_op_setcond_i32:
996 #if TCG_TARGET_REG_BITS == 32
997 case INDEX_op_setcond2_i32:
998 #elif TCG_TARGET_REG_BITS == 64
999 case INDEX_op_setcond_i64:
1000 #endif
1001 if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]])
1002 fprintf(outfile, ",%s", cond_name[args[k++]]);
1003 else
1004 fprintf(outfile, ",$0x%" TCG_PRIlx, args[k++]);
1005 i = 1;
1006 break;
1007 default:
1008 i = 0;
1009 break;
1010 }
1011 for(; i < nb_cargs; i++) {
1012 if (k != 0)
1013 fprintf(outfile, ",");
1014 arg = args[k++];
1015 fprintf(outfile, "$0x%" TCG_PRIlx, arg);
1016 }
1017 }
1018 fprintf(outfile, "\n");
1019 args += nb_iargs + nb_oargs + nb_cargs;
1020 }
1021 }
1022
1023 /* we give more priority to constraints with less registers */
1024 static int get_constraint_priority(const TCGOpDef *def, int k)
1025 {
1026 const TCGArgConstraint *arg_ct;
1027
1028 int i, n;
1029 arg_ct = &def->args_ct[k];
1030 if (arg_ct->ct & TCG_CT_ALIAS) {
1031 /* an alias is equivalent to a single register */
1032 n = 1;
1033 } else {
1034 if (!(arg_ct->ct & TCG_CT_REG))
1035 return 0;
1036 n = 0;
1037 for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
1038 if (tcg_regset_test_reg(arg_ct->u.regs, i))
1039 n++;
1040 }
1041 }
1042 return TCG_TARGET_NB_REGS - n + 1;
1043 }
1044
1045 /* sort from highest priority to lowest */
1046 static void sort_constraints(TCGOpDef *def, int start, int n)
1047 {
1048 int i, j, p1, p2, tmp;
1049
1050 for(i = 0; i < n; i++)
1051 def->sorted_args[start + i] = start + i;
1052 if (n <= 1)
1053 return;
1054 for(i = 0; i < n - 1; i++) {
1055 for(j = i + 1; j < n; j++) {
1056 p1 = get_constraint_priority(def, def->sorted_args[start + i]);
1057 p2 = get_constraint_priority(def, def->sorted_args[start + j]);
1058 if (p1 < p2) {
1059 tmp = def->sorted_args[start + i];
1060 def->sorted_args[start + i] = def->sorted_args[start + j];
1061 def->sorted_args[start + j] = tmp;
1062 }
1063 }
1064 }
1065 }
1066
1067 void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs)
1068 {
1069 TCGOpcode op;
1070 TCGOpDef *def;
1071 const char *ct_str;
1072 int i, nb_args;
1073
1074 for(;;) {
1075 if (tdefs->op == (TCGOpcode)-1)
1076 break;
1077 op = tdefs->op;
1078 assert((unsigned)op < NB_OPS);
1079 def = &tcg_op_defs[op];
1080 #if defined(CONFIG_DEBUG_TCG)
1081 /* Duplicate entry in op definitions? */
1082 assert(!def->used);
1083 def->used = 1;
1084 #endif
1085 nb_args = def->nb_iargs + def->nb_oargs;
1086 for(i = 0; i < nb_args; i++) {
1087 ct_str = tdefs->args_ct_str[i];
1088 /* Incomplete TCGTargetOpDef entry? */
1089 assert(ct_str != NULL);
1090 tcg_regset_clear(def->args_ct[i].u.regs);
1091 def->args_ct[i].ct = 0;
1092 if (ct_str[0] >= '0' && ct_str[0] <= '9') {
1093 int oarg;
1094 oarg = ct_str[0] - '0';
1095 assert(oarg < def->nb_oargs);
1096 assert(def->args_ct[oarg].ct & TCG_CT_REG);
1097 /* TCG_CT_ALIAS is for the output arguments. The input
1098 argument is tagged with TCG_CT_IALIAS. */
1099 def->args_ct[i] = def->args_ct[oarg];
1100 def->args_ct[oarg].ct = TCG_CT_ALIAS;
1101 def->args_ct[oarg].alias_index = i;
1102 def->args_ct[i].ct |= TCG_CT_IALIAS;
1103 def->args_ct[i].alias_index = oarg;
1104 } else {
1105 for(;;) {
1106 if (*ct_str == '\0')
1107 break;
1108 switch(*ct_str) {
1109 case 'i':
1110 def->args_ct[i].ct |= TCG_CT_CONST;
1111 ct_str++;
1112 break;
1113 default:
1114 if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) {
1115 fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n",
1116 ct_str, i, def->name);
1117 exit(1);
1118 }
1119 }
1120 }
1121 }
1122 }
1123
1124 /* TCGTargetOpDef entry with too much information? */
1125 assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL);
1126
1127 /* sort the constraints (XXX: this is just an heuristic) */
1128 sort_constraints(def, 0, def->nb_oargs);
1129 sort_constraints(def, def->nb_oargs, def->nb_iargs);
1130
1131 #if 0
1132 {
1133 int i;
1134
1135 printf("%s: sorted=", def->name);
1136 for(i = 0; i < def->nb_oargs + def->nb_iargs; i++)
1137 printf(" %d", def->sorted_args[i]);
1138 printf("\n");
1139 }
1140 #endif
1141 tdefs++;
1142 }
1143
1144 #if defined(CONFIG_DEBUG_TCG)
1145 i = 0;
1146 for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) {
1147 const TCGOpDef *def = &tcg_op_defs[op];
1148 if (op < INDEX_op_call
1149 || op == INDEX_op_debug_insn_start
1150 || (def->flags & TCG_OPF_NOT_PRESENT)) {
1151 /* Wrong entry in op definitions? */
1152 if (def->used) {
1153 fprintf(stderr, "Invalid op definition for %s\n", def->name);
1154 i = 1;
1155 }
1156 } else {
1157 /* Missing entry in op definitions? */
1158 if (!def->used) {
1159 fprintf(stderr, "Missing op definition for %s\n", def->name);
1160 i = 1;
1161 }
1162 }
1163 }
1164 if (i == 1) {
1165 tcg_abort();
1166 }
1167 #endif
1168 }
1169
1170 #ifdef USE_LIVENESS_ANALYSIS
1171
1172 /* set a nop for an operation using 'nb_args' */
1173 static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr,
1174 TCGArg *args, int nb_args)
1175 {
1176 if (nb_args == 0) {
1177 *opc_ptr = INDEX_op_nop;
1178 } else {
1179 *opc_ptr = INDEX_op_nopn;
1180 args[0] = nb_args;
1181 args[nb_args - 1] = nb_args;
1182 }
1183 }
1184
1185 /* liveness analysis: end of function: globals are live, temps are
1186 dead. */
1187 /* XXX: at this stage, not used as there would be little gains because
1188 most TBs end with a conditional jump. */
1189 static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps)
1190 {
1191 memset(dead_temps, 0, s->nb_globals);
1192 memset(dead_temps + s->nb_globals, 1, s->nb_temps - s->nb_globals);
1193 }
1194
1195 /* liveness analysis: end of basic block: globals are live, temps are
1196 dead, local temps are live. */
1197 static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps)
1198 {
1199 int i;
1200 TCGTemp *ts;
1201
1202 memset(dead_temps, 0, s->nb_globals);
1203 ts = &s->temps[s->nb_globals];
1204 for(i = s->nb_globals; i < s->nb_temps; i++) {
1205 if (ts->temp_local)
1206 dead_temps[i] = 0;
1207 else
1208 dead_temps[i] = 1;
1209 ts++;
1210 }
1211 }
1212
1213 /* Liveness analysis : update the opc_dead_args array to tell if a
1214 given input arguments is dead. Instructions updating dead
1215 temporaries are removed. */
1216 static void tcg_liveness_analysis(TCGContext *s)
1217 {
1218 int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops;
1219 TCGOpcode op;
1220 TCGArg *args;
1221 const TCGOpDef *def;
1222 uint8_t *dead_temps;
1223 unsigned int dead_args;
1224
1225 gen_opc_ptr++; /* skip end */
1226
1227 nb_ops = gen_opc_ptr - gen_opc_buf;
1228
1229 s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
1230
1231 dead_temps = tcg_malloc(s->nb_temps);
1232 memset(dead_temps, 1, s->nb_temps);
1233
1234 args = gen_opparam_ptr;
1235 op_index = nb_ops - 1;
1236 while (op_index >= 0) {
1237 op = gen_opc_buf[op_index];
1238 def = &tcg_op_defs[op];
1239 switch(op) {
1240 case INDEX_op_call:
1241 {
1242 int call_flags;
1243
1244 nb_args = args[-1];
1245 args -= nb_args;
1246 nb_iargs = args[0] & 0xffff;
1247 nb_oargs = args[0] >> 16;
1248 args++;
1249 call_flags = args[nb_oargs + nb_iargs];
1250
1251 /* pure functions can be removed if their result is not
1252 used */
1253 if (call_flags & TCG_CALL_PURE) {
1254 for(i = 0; i < nb_oargs; i++) {
1255 arg = args[i];
1256 if (!dead_temps[arg])
1257 goto do_not_remove_call;
1258 }
1259 tcg_set_nop(s, gen_opc_buf + op_index,
1260 args - 1, nb_args);
1261 } else {
1262 do_not_remove_call:
1263
1264 /* output args are dead */
1265 dead_args = 0;
1266 for(i = 0; i < nb_oargs; i++) {
1267 arg = args[i];
1268 if (dead_temps[arg]) {
1269 dead_args |= (1 << i);
1270 }
1271 dead_temps[arg] = 1;
1272 }
1273
1274 if (!(call_flags & TCG_CALL_CONST)) {
1275 /* globals are live (they may be used by the call) */
1276 memset(dead_temps, 0, s->nb_globals);
1277 }
1278
1279 /* input args are live */
1280 for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) {
1281 arg = args[i];
1282 if (arg != TCG_CALL_DUMMY_ARG) {
1283 if (dead_temps[arg]) {
1284 dead_args |= (1 << i);
1285 }
1286 dead_temps[arg] = 0;
1287 }
1288 }
1289 s->op_dead_args[op_index] = dead_args;
1290 }
1291 args--;
1292 }
1293 break;
1294 case INDEX_op_set_label:
1295 args--;
1296 /* mark end of basic block */
1297 tcg_la_bb_end(s, dead_temps);
1298 break;
1299 case INDEX_op_debug_insn_start:
1300 args -= def->nb_args;
1301 break;
1302 case INDEX_op_nopn:
1303 nb_args = args[-1];
1304 args -= nb_args;
1305 break;
1306 case INDEX_op_discard:
1307 args--;
1308 /* mark the temporary as dead */
1309 dead_temps[args[0]] = 1;
1310 break;
1311 case INDEX_op_end:
1312 break;
1313 /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */
1314 default:
1315 args -= def->nb_args;
1316 nb_iargs = def->nb_iargs;
1317 nb_oargs = def->nb_oargs;
1318
1319 /* Test if the operation can be removed because all
1320 its outputs are dead. We assume that nb_oargs == 0
1321 implies side effects */
1322 if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) {
1323 for(i = 0; i < nb_oargs; i++) {
1324 arg = args[i];
1325 if (!dead_temps[arg])
1326 goto do_not_remove;
1327 }
1328 tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args);
1329 #ifdef CONFIG_PROFILER
1330 s->del_op_count++;
1331 #endif
1332 } else {
1333 do_not_remove:
1334
1335 /* output args are dead */
1336 dead_args = 0;
1337 for(i = 0; i < nb_oargs; i++) {
1338 arg = args[i];
1339 if (dead_temps[arg]) {
1340 dead_args |= (1 << i);
1341 }
1342 dead_temps[arg] = 1;
1343 }
1344
1345 /* if end of basic block, update */
1346 if (def->flags & TCG_OPF_BB_END) {
1347 tcg_la_bb_end(s, dead_temps);
1348 } else if (def->flags & TCG_OPF_CALL_CLOBBER) {
1349 /* globals are live */
1350 memset(dead_temps, 0, s->nb_globals);
1351 }
1352
1353 /* input args are live */
1354 for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) {
1355 arg = args[i];
1356 if (dead_temps[arg]) {
1357 dead_args |= (1 << i);
1358 }
1359 dead_temps[arg] = 0;
1360 }
1361 s->op_dead_args[op_index] = dead_args;
1362 }
1363 break;
1364 }
1365 op_index--;
1366 }
1367
1368 if (args != gen_opparam_buf)
1369 tcg_abort();
1370 }
1371 #else
1372 /* dummy liveness analysis */
1373 static void tcg_liveness_analysis(TCGContext *s)
1374 {
1375 int nb_ops;
1376 nb_ops = gen_opc_ptr - gen_opc_buf;
1377
1378 s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
1379 memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t));
1380 }
1381 #endif
1382
1383 #ifndef NDEBUG
1384 static void dump_regs(TCGContext *s)
1385 {
1386 TCGTemp *ts;
1387 int i;
1388 char buf[64];
1389
1390 for(i = 0; i < s->nb_temps; i++) {
1391 ts = &s->temps[i];
1392 printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i));
1393 switch(ts->val_type) {
1394 case TEMP_VAL_REG:
1395 printf("%s", tcg_target_reg_names[ts->reg]);
1396 break;
1397 case TEMP_VAL_MEM:
1398 printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]);
1399 break;
1400 case TEMP_VAL_CONST:
1401 printf("$0x%" TCG_PRIlx, ts->val);
1402 break;
1403 case TEMP_VAL_DEAD:
1404 printf("D");
1405 break;
1406 default:
1407 printf("???");
1408 break;
1409 }
1410 printf("\n");
1411 }
1412
1413 for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
1414 if (s->reg_to_temp[i] >= 0) {
1415 printf("%s: %s\n",
1416 tcg_target_reg_names[i],
1417 tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i]));
1418 }
1419 }
1420 }
1421
1422 static void check_regs(TCGContext *s)
1423 {
1424 int reg, k;
1425 TCGTemp *ts;
1426 char buf[64];
1427
1428 for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
1429 k = s->reg_to_temp[reg];
1430 if (k >= 0) {
1431 ts = &s->temps[k];
1432 if (ts->val_type != TEMP_VAL_REG ||
1433 ts->reg != reg) {
1434 printf("Inconsistency for register %s:\n",
1435 tcg_target_reg_names[reg]);
1436 goto fail;
1437 }
1438 }
1439 }
1440 for(k = 0; k < s->nb_temps; k++) {
1441 ts = &s->temps[k];
1442 if (ts->val_type == TEMP_VAL_REG &&
1443 !ts->fixed_reg &&
1444 s->reg_to_temp[ts->reg] != k) {
1445 printf("Inconsistency for temp %s:\n",
1446 tcg_get_arg_str_idx(s, buf, sizeof(buf), k));
1447 fail:
1448 printf("reg state:\n");
1449 dump_regs(s);
1450 tcg_abort();
1451 }
1452 }
1453 }
1454 #endif
1455
1456 static void temp_allocate_frame(TCGContext *s, int temp)
1457 {
1458 TCGTemp *ts;
1459 ts = &s->temps[temp];
1460 #ifndef __sparc_v9__ /* Sparc64 stack is accessed with offset of 2047 */
1461 s->current_frame_offset = (s->current_frame_offset +
1462 (tcg_target_long)sizeof(tcg_target_long) - 1) &
1463 ~(sizeof(tcg_target_long) - 1);
1464 #endif
1465 if (s->current_frame_offset + (tcg_target_long)sizeof(tcg_target_long) >
1466 s->frame_end) {
1467 tcg_abort();
1468 }
1469 ts->mem_offset = s->current_frame_offset;
1470 ts->mem_reg = s->frame_reg;
1471 ts->mem_allocated = 1;
1472 s->current_frame_offset += (tcg_target_long)sizeof(tcg_target_long);
1473 }
1474
1475 /* free register 'reg' by spilling the corresponding temporary if necessary */
1476 static void tcg_reg_free(TCGContext *s, int reg)
1477 {
1478 TCGTemp *ts;
1479 int temp;
1480
1481 temp = s->reg_to_temp[reg];
1482 if (temp != -1) {
1483 ts = &s->temps[temp];
1484 assert(ts->val_type == TEMP_VAL_REG);
1485 if (!ts->mem_coherent) {
1486 if (!ts->mem_allocated)
1487 temp_allocate_frame(s, temp);
1488 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1489 }
1490 ts->val_type = TEMP_VAL_MEM;
1491 s->reg_to_temp[reg] = -1;
1492 }
1493 }
1494
1495 /* Allocate a register belonging to reg1 & ~reg2 */
1496 static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2)
1497 {
1498 int i, reg;
1499 TCGRegSet reg_ct;
1500
1501 tcg_regset_andnot(reg_ct, reg1, reg2);
1502
1503 /* first try free registers */
1504 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) {
1505 reg = tcg_target_reg_alloc_order[i];
1506 if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1)
1507 return reg;
1508 }
1509
1510 /* XXX: do better spill choice */
1511 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) {
1512 reg = tcg_target_reg_alloc_order[i];
1513 if (tcg_regset_test_reg(reg_ct, reg)) {
1514 tcg_reg_free(s, reg);
1515 return reg;
1516 }
1517 }
1518
1519 tcg_abort();
1520 }
1521
1522 /* save a temporary to memory. 'allocated_regs' is used in case a
1523 temporary registers needs to be allocated to store a constant. */
1524 static void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs)
1525 {
1526 TCGTemp *ts;
1527 int reg;
1528
1529 ts = &s->temps[temp];
1530 if (!ts->fixed_reg) {
1531 switch(ts->val_type) {
1532 case TEMP_VAL_REG:
1533 tcg_reg_free(s, ts->reg);
1534 break;
1535 case TEMP_VAL_DEAD:
1536 ts->val_type = TEMP_VAL_MEM;
1537 break;
1538 case TEMP_VAL_CONST:
1539 reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type],
1540 allocated_regs);
1541 if (!ts->mem_allocated)
1542 temp_allocate_frame(s, temp);
1543 tcg_out_movi(s, ts->type, reg, ts->val);
1544 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1545 ts->val_type = TEMP_VAL_MEM;
1546 break;
1547 case TEMP_VAL_MEM:
1548 break;
1549 default:
1550 tcg_abort();
1551 }
1552 }
1553 }
1554
1555 /* save globals to their canonical location and assume they can be
1556 modified be the following code. 'allocated_regs' is used in case a
1557 temporary registers needs to be allocated to store a constant. */
1558 static void save_globals(TCGContext *s, TCGRegSet allocated_regs)
1559 {
1560 int i;
1561
1562 for(i = 0; i < s->nb_globals; i++) {
1563 temp_save(s, i, allocated_regs);
1564 }
1565 }
1566
1567 /* at the end of a basic block, we assume all temporaries are dead and
1568 all globals are stored at their canonical location. */
1569 static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs)
1570 {
1571 TCGTemp *ts;
1572 int i;
1573
1574 for(i = s->nb_globals; i < s->nb_temps; i++) {
1575 ts = &s->temps[i];
1576 if (ts->temp_local) {
1577 temp_save(s, i, allocated_regs);
1578 } else {
1579 if (ts->val_type == TEMP_VAL_REG) {
1580 s->reg_to_temp[ts->reg] = -1;
1581 }
1582 ts->val_type = TEMP_VAL_DEAD;
1583 }
1584 }
1585
1586 save_globals(s, allocated_regs);
1587 }
1588
1589 #define IS_DEAD_ARG(n) ((dead_args >> (n)) & 1)
1590
1591 static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args)
1592 {
1593 TCGTemp *ots;
1594 tcg_target_ulong val;
1595
1596 ots = &s->temps[args[0]];
1597 val = args[1];
1598
1599 if (ots->fixed_reg) {
1600 /* for fixed registers, we do not do any constant
1601 propagation */
1602 tcg_out_movi(s, ots->type, ots->reg, val);
1603 } else {
1604 /* The movi is not explicitly generated here */
1605 if (ots->val_type == TEMP_VAL_REG)
1606 s->reg_to_temp[ots->reg] = -1;
1607 ots->val_type = TEMP_VAL_CONST;
1608 ots->val = val;
1609 }
1610 }
1611
1612 static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def,
1613 const TCGArg *args,
1614 unsigned int dead_args)
1615 {
1616 TCGTemp *ts, *ots;
1617 int reg;
1618 const TCGArgConstraint *arg_ct;
1619
1620 ots = &s->temps[args[0]];
1621 ts = &s->temps[args[1]];
1622 arg_ct = &def->args_ct[0];
1623
1624 /* XXX: always mark arg dead if IS_DEAD_ARG(1) */
1625 if (ts->val_type == TEMP_VAL_REG) {
1626 if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) {
1627 /* the mov can be suppressed */
1628 if (ots->val_type == TEMP_VAL_REG)
1629 s->reg_to_temp[ots->reg] = -1;
1630 reg = ts->reg;
1631 s->reg_to_temp[reg] = -1;
1632 ts->val_type = TEMP_VAL_DEAD;
1633 } else {
1634 if (ots->val_type == TEMP_VAL_REG) {
1635 reg = ots->reg;
1636 } else {
1637 reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs);
1638 }
1639 if (ts->reg != reg) {
1640 tcg_out_mov(s, ots->type, reg, ts->reg);
1641 }
1642 }
1643 } else if (ts->val_type == TEMP_VAL_MEM) {
1644 if (ots->val_type == TEMP_VAL_REG) {
1645 reg = ots->reg;
1646 } else {
1647 reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs);
1648 }
1649 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1650 } else if (ts->val_type == TEMP_VAL_CONST) {
1651 if (ots->fixed_reg) {
1652 reg = ots->reg;
1653 tcg_out_movi(s, ots->type, reg, ts->val);
1654 } else {
1655 /* propagate constant */
1656 if (ots->val_type == TEMP_VAL_REG)
1657 s->reg_to_temp[ots->reg] = -1;
1658 ots->val_type = TEMP_VAL_CONST;
1659 ots->val = ts->val;
1660 return;
1661 }
1662 } else {
1663 tcg_abort();
1664 }
1665 s->reg_to_temp[reg] = args[0];
1666 ots->reg = reg;
1667 ots->val_type = TEMP_VAL_REG;
1668 ots->mem_coherent = 0;
1669 }
1670
1671 static void tcg_reg_alloc_op(TCGContext *s,
1672 const TCGOpDef *def, TCGOpcode opc,
1673 const TCGArg *args,
1674 unsigned int dead_args)
1675 {
1676 TCGRegSet allocated_regs;
1677 int i, k, nb_iargs, nb_oargs, reg;
1678 TCGArg arg;
1679 const TCGArgConstraint *arg_ct;
1680 TCGTemp *ts;
1681 TCGArg new_args[TCG_MAX_OP_ARGS];
1682 int const_args[TCG_MAX_OP_ARGS];
1683
1684 nb_oargs = def->nb_oargs;
1685 nb_iargs = def->nb_iargs;
1686
1687 /* copy constants */
1688 memcpy(new_args + nb_oargs + nb_iargs,
1689 args + nb_oargs + nb_iargs,
1690 sizeof(TCGArg) * def->nb_cargs);
1691
1692 /* satisfy input constraints */
1693 tcg_regset_set(allocated_regs, s->reserved_regs);
1694 for(k = 0; k < nb_iargs; k++) {
1695 i = def->sorted_args[nb_oargs + k];
1696 arg = args[i];
1697 arg_ct = &def->args_ct[i];
1698 ts = &s->temps[arg];
1699 if (ts->val_type == TEMP_VAL_MEM) {
1700 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1701 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1702 ts->val_type = TEMP_VAL_REG;
1703 ts->reg = reg;
1704 ts->mem_coherent = 1;
1705 s->reg_to_temp[reg] = arg;
1706 } else if (ts->val_type == TEMP_VAL_CONST) {
1707 if (tcg_target_const_match(ts->val, arg_ct)) {
1708 /* constant is OK for instruction */
1709 const_args[i] = 1;
1710 new_args[i] = ts->val;
1711 goto iarg_end;
1712 } else {
1713 /* need to move to a register */
1714 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1715 tcg_out_movi(s, ts->type, reg, ts->val);
1716 ts->val_type = TEMP_VAL_REG;
1717 ts->reg = reg;
1718 ts->mem_coherent = 0;
1719 s->reg_to_temp[reg] = arg;
1720 }
1721 }
1722 assert(ts->val_type == TEMP_VAL_REG);
1723 if (arg_ct->ct & TCG_CT_IALIAS) {
1724 if (ts->fixed_reg) {
1725 /* if fixed register, we must allocate a new register
1726 if the alias is not the same register */
1727 if (arg != args[arg_ct->alias_index])
1728 goto allocate_in_reg;
1729 } else {
1730 /* if the input is aliased to an output and if it is
1731 not dead after the instruction, we must allocate
1732 a new register and move it */
1733 if (!IS_DEAD_ARG(i)) {
1734 goto allocate_in_reg;
1735 }
1736 }
1737 }
1738 reg = ts->reg;
1739 if (tcg_regset_test_reg(arg_ct->u.regs, reg)) {
1740 /* nothing to do : the constraint is satisfied */
1741 } else {
1742 allocate_in_reg:
1743 /* allocate a new register matching the constraint
1744 and move the temporary register into it */
1745 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1746 tcg_out_mov(s, ts->type, reg, ts->reg);
1747 }
1748 new_args[i] = reg;
1749 const_args[i] = 0;
1750 tcg_regset_set_reg(allocated_regs, reg);
1751 iarg_end: ;
1752 }
1753
1754 if (def->flags & TCG_OPF_BB_END) {
1755 tcg_reg_alloc_bb_end(s, allocated_regs);
1756 } else {
1757 /* mark dead temporaries and free the associated registers */
1758 for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) {
1759 arg = args[i];
1760 if (IS_DEAD_ARG(i)) {
1761 ts = &s->temps[arg];
1762 if (!ts->fixed_reg) {
1763 if (ts->val_type == TEMP_VAL_REG)
1764 s->reg_to_temp[ts->reg] = -1;
1765 ts->val_type = TEMP_VAL_DEAD;
1766 }
1767 }
1768 }
1769
1770 if (def->flags & TCG_OPF_CALL_CLOBBER) {
1771 /* XXX: permit generic clobber register list ? */
1772 for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
1773 if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) {
1774 tcg_reg_free(s, reg);
1775 }
1776 }
1777 /* XXX: for load/store we could do that only for the slow path
1778 (i.e. when a memory callback is called) */
1779
1780 /* store globals and free associated registers (we assume the insn
1781 can modify any global. */
1782 save_globals(s, allocated_regs);
1783 }
1784
1785 /* satisfy the output constraints */
1786 tcg_regset_set(allocated_regs, s->reserved_regs);
1787 for(k = 0; k < nb_oargs; k++) {
1788 i = def->sorted_args[k];
1789 arg = args[i];
1790 arg_ct = &def->args_ct[i];
1791 ts = &s->temps[arg];
1792 if (arg_ct->ct & TCG_CT_ALIAS) {
1793 reg = new_args[arg_ct->alias_index];
1794 } else {
1795 /* if fixed register, we try to use it */
1796 reg = ts->reg;
1797 if (ts->fixed_reg &&
1798 tcg_regset_test_reg(arg_ct->u.regs, reg)) {
1799 goto oarg_end;
1800 }
1801 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1802 }
1803 tcg_regset_set_reg(allocated_regs, reg);
1804 /* if a fixed register is used, then a move will be done afterwards */
1805 if (!ts->fixed_reg) {
1806 if (ts->val_type == TEMP_VAL_REG)
1807 s->reg_to_temp[ts->reg] = -1;
1808 if (IS_DEAD_ARG(i)) {
1809 ts->val_type = TEMP_VAL_DEAD;
1810 } else {
1811 ts->val_type = TEMP_VAL_REG;
1812 ts->reg = reg;
1813 /* temp value is modified, so the value kept in memory is
1814 potentially not the same */
1815 ts->mem_coherent = 0;
1816 s->reg_to_temp[reg] = arg;
1817 }
1818 }
1819 oarg_end:
1820 new_args[i] = reg;
1821 }
1822 }
1823
1824 /* emit instruction */
1825 tcg_out_op(s, opc, new_args, const_args);
1826
1827 /* move the outputs in the correct register if needed */
1828 for(i = 0; i < nb_oargs; i++) {
1829 ts = &s->temps[args[i]];
1830 reg = new_args[i];
1831 if (ts->fixed_reg && ts->reg != reg) {
1832 tcg_out_mov(s, ts->type, ts->reg, reg);
1833 }
1834 }
1835 }
1836
1837 #ifdef TCG_TARGET_STACK_GROWSUP
1838 #define STACK_DIR(x) (-(x))
1839 #else
1840 #define STACK_DIR(x) (x)
1841 #endif
1842
1843 static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
1844 TCGOpcode opc, const TCGArg *args,
1845 unsigned int dead_args)
1846 {
1847 int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params;
1848 TCGArg arg, func_arg;
1849 TCGTemp *ts;
1850 tcg_target_long stack_offset, call_stack_size, func_addr;
1851 int const_func_arg, allocate_args;
1852 TCGRegSet allocated_regs;
1853 const TCGArgConstraint *arg_ct;
1854
1855 arg = *args++;
1856
1857 nb_oargs = arg >> 16;
1858 nb_iargs = arg & 0xffff;
1859 nb_params = nb_iargs - 1;
1860
1861 flags = args[nb_oargs + nb_iargs];
1862
1863 nb_regs = tcg_target_get_call_iarg_regs_count(flags);
1864 if (nb_regs > nb_params)
1865 nb_regs = nb_params;
1866
1867 /* assign stack slots first */
1868 call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long);
1869 call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) &
1870 ~(TCG_TARGET_STACK_ALIGN - 1);
1871 allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE);
1872 if (allocate_args) {
1873 /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed,
1874 preallocate call stack */
1875 tcg_abort();
1876 }
1877
1878 stack_offset = TCG_TARGET_CALL_STACK_OFFSET;
1879 for(i = nb_regs; i < nb_params; i++) {
1880 arg = args[nb_oargs + i];
1881 #ifdef TCG_TARGET_STACK_GROWSUP
1882 stack_offset -= sizeof(tcg_target_long);
1883 #endif
1884 if (arg != TCG_CALL_DUMMY_ARG) {
1885 ts = &s->temps[arg];
1886 if (ts->val_type == TEMP_VAL_REG) {
1887 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset);
1888 } else if (ts->val_type == TEMP_VAL_MEM) {
1889 reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type],
1890 s->reserved_regs);
1891 /* XXX: not correct if reading values from the stack */
1892 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1893 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);
1894 } else if (ts->val_type == TEMP_VAL_CONST) {
1895 reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type],
1896 s->reserved_regs);
1897 /* XXX: sign extend may be needed on some targets */
1898 tcg_out_movi(s, ts->type, reg, ts->val);
1899 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);
1900 } else {
1901 tcg_abort();
1902 }
1903 }
1904 #ifndef TCG_TARGET_STACK_GROWSUP
1905 stack_offset += sizeof(tcg_target_long);
1906 #endif
1907 }
1908
1909 /* assign input registers */
1910 tcg_regset_set(allocated_regs, s->reserved_regs);
1911 for(i = 0; i < nb_regs; i++) {
1912 arg = args[nb_oargs + i];
1913 if (arg != TCG_CALL_DUMMY_ARG) {
1914 ts = &s->temps[arg];
1915 reg = tcg_target_call_iarg_regs[i];
1916 tcg_reg_free(s, reg);
1917 if (ts->val_type == TEMP_VAL_REG) {
1918 if (ts->reg != reg) {
1919 tcg_out_mov(s, ts->type, reg, ts->reg);
1920 }
1921 } else if (ts->val_type == TEMP_VAL_MEM) {
1922 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1923 } else if (ts->val_type == TEMP_VAL_CONST) {
1924 /* XXX: sign extend ? */
1925 tcg_out_movi(s, ts->type, reg, ts->val);
1926 } else {
1927 tcg_abort();
1928 }
1929 tcg_regset_set_reg(allocated_regs, reg);
1930 }
1931 }
1932
1933 /* assign function address */
1934 func_arg = args[nb_oargs + nb_iargs - 1];
1935 arg_ct = &def->args_ct[0];
1936 ts = &s->temps[func_arg];
1937 func_addr = ts->val;
1938 const_func_arg = 0;
1939 if (ts->val_type == TEMP_VAL_MEM) {
1940 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1941 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1942 func_arg = reg;
1943 tcg_regset_set_reg(allocated_regs, reg);
1944 } else if (ts->val_type == TEMP_VAL_REG) {
1945 reg = ts->reg;
1946 if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) {
1947 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1948 tcg_out_mov(s, ts->type, reg, ts->reg);
1949 }
1950 func_arg = reg;
1951 tcg_regset_set_reg(allocated_regs, reg);
1952 } else if (ts->val_type == TEMP_VAL_CONST) {
1953 if (tcg_target_const_match(func_addr, arg_ct)) {
1954 const_func_arg = 1;
1955 func_arg = func_addr;
1956 } else {
1957 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1958 tcg_out_movi(s, ts->type, reg, func_addr);
1959 func_arg = reg;
1960 tcg_regset_set_reg(allocated_regs, reg);
1961 }
1962 } else {
1963 tcg_abort();
1964 }
1965
1966
1967 /* mark dead temporaries and free the associated registers */
1968 for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) {
1969 arg = args[i];
1970 if (IS_DEAD_ARG(i)) {
1971 ts = &s->temps[arg];
1972 if (!ts->fixed_reg) {
1973 if (ts->val_type == TEMP_VAL_REG)
1974 s->reg_to_temp[ts->reg] = -1;
1975 ts->val_type = TEMP_VAL_DEAD;
1976 }
1977 }
1978 }
1979
1980 /* clobber call registers */
1981 for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
1982 if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) {
1983 tcg_reg_free(s, reg);
1984 }
1985 }
1986
1987 /* store globals and free associated registers (we assume the call
1988 can modify any global. */
1989 if (!(flags & TCG_CALL_CONST)) {
1990 save_globals(s, allocated_regs);
1991 }
1992
1993 tcg_out_op(s, opc, &func_arg, &const_func_arg);
1994
1995 /* assign output registers and emit moves if needed */
1996 for(i = 0; i < nb_oargs; i++) {
1997 arg = args[i];
1998 ts = &s->temps[arg];
1999 reg = tcg_target_call_oarg_regs[i];
2000 assert(s->reg_to_temp[reg] == -1);
2001 if (ts->fixed_reg) {
2002 if (ts->reg != reg) {
2003 tcg_out_mov(s, ts->type, ts->reg, reg);
2004 }
2005 } else {
2006 if (ts->val_type == TEMP_VAL_REG)
2007 s->reg_to_temp[ts->reg] = -1;
2008 if (IS_DEAD_ARG(i)) {
2009 ts->val_type = TEMP_VAL_DEAD;
2010 } else {
2011 ts->val_type = TEMP_VAL_REG;
2012 ts->reg = reg;
2013 ts->mem_coherent = 0;
2014 s->reg_to_temp[reg] = arg;
2015 }
2016 }
2017 }
2018
2019 return nb_iargs + nb_oargs + def->nb_cargs + 1;
2020 }
2021
2022 #ifdef CONFIG_PROFILER
2023
2024 static int64_t tcg_table_op_count[NB_OPS];
2025
2026 static void dump_op_count(void)
2027 {
2028 int i;
2029 FILE *f;
2030 f = fopen("/tmp/op.log", "w");
2031 for(i = INDEX_op_end; i < NB_OPS; i++) {
2032 fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]);
2033 }
2034 fclose(f);
2035 }
2036 #endif
2037
2038
2039 static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
2040 long search_pc)
2041 {
2042 TCGOpcode opc;
2043 int op_index;
2044 const TCGOpDef *def;
2045 unsigned int dead_args;
2046 const TCGArg *args;
2047
2048 #ifdef DEBUG_DISAS
2049 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
2050 qemu_log("OP:\n");
2051 tcg_dump_ops(s, logfile);
2052 qemu_log("\n");
2053 }
2054 #endif
2055
2056 #ifdef USE_TCG_OPTIMIZATIONS
2057 gen_opparam_ptr =
2058 tcg_optimize(s, gen_opc_ptr, gen_opparam_buf, tcg_op_defs);
2059 #endif
2060
2061 #ifdef CONFIG_PROFILER
2062 s->la_time -= profile_getclock();
2063 #endif
2064 tcg_liveness_analysis(s);
2065 #ifdef CONFIG_PROFILER
2066 s->la_time += profile_getclock();
2067 #endif
2068
2069 #ifdef DEBUG_DISAS
2070 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) {
2071 qemu_log("OP after liveness analysis:\n");
2072 tcg_dump_ops(s, logfile);
2073 qemu_log("\n");
2074 }
2075 #endif
2076
2077 tcg_reg_alloc_start(s);
2078
2079 s->code_buf = gen_code_buf;
2080 s->code_ptr = gen_code_buf;
2081
2082 args = gen_opparam_buf;
2083 op_index = 0;
2084
2085 for(;;) {
2086 opc = gen_opc_buf[op_index];
2087 #ifdef CONFIG_PROFILER
2088 tcg_table_op_count[opc]++;
2089 #endif
2090 def = &tcg_op_defs[opc];
2091 #if 0
2092 printf("%s: %d %d %d\n", def->name,
2093 def->nb_oargs, def->nb_iargs, def->nb_cargs);
2094 // dump_regs(s);
2095 #endif
2096 switch(opc) {
2097 case INDEX_op_mov_i32:
2098 #if TCG_TARGET_REG_BITS == 64
2099 case INDEX_op_mov_i64:
2100 #endif
2101 dead_args = s->op_dead_args[op_index];
2102 tcg_reg_alloc_mov(s, def, args, dead_args);
2103 break;
2104 case INDEX_op_movi_i32:
2105 #if TCG_TARGET_REG_BITS == 64
2106 case INDEX_op_movi_i64:
2107 #endif
2108 tcg_reg_alloc_movi(s, args);
2109 break;
2110 case INDEX_op_debug_insn_start:
2111 /* debug instruction */
2112 break;
2113 case INDEX_op_nop:
2114 case INDEX_op_nop1:
2115 case INDEX_op_nop2:
2116 case INDEX_op_nop3:
2117 break;
2118 case INDEX_op_nopn:
2119 args += args[0];
2120 goto next;
2121 case INDEX_op_discard:
2122 {
2123 TCGTemp *ts;
2124 ts = &s->temps[args[0]];
2125 /* mark the temporary as dead */
2126 if (!ts->fixed_reg) {
2127 if (ts->val_type == TEMP_VAL_REG)
2128 s->reg_to_temp[ts->reg] = -1;
2129 ts->val_type = TEMP_VAL_DEAD;
2130 }
2131 }
2132 break;
2133 case INDEX_op_set_label:
2134 tcg_reg_alloc_bb_end(s, s->reserved_regs);
2135 tcg_out_label(s, args[0], s->code_ptr);
2136 break;
2137 case INDEX_op_call:
2138 dead_args = s->op_dead_args[op_index];
2139 args += tcg_reg_alloc_call(s, def, opc, args, dead_args);
2140 goto next;
2141 case INDEX_op_end:
2142 goto the_end;
2143 default:
2144 /* Sanity check that we've not introduced any unhandled opcodes. */
2145 if (def->flags & TCG_OPF_NOT_PRESENT) {
2146 tcg_abort();
2147 }
2148 /* Note: in order to speed up the code, it would be much
2149 faster to have specialized register allocator functions for
2150 some common argument patterns */
2151 dead_args = s->op_dead_args[op_index];
2152 tcg_reg_alloc_op(s, def, opc, args, dead_args);
2153 break;
2154 }
2155 args += def->nb_args;
2156 next:
2157 if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) {
2158 return op_index;
2159 }
2160 op_index++;
2161 #ifndef NDEBUG
2162 check_regs(s);
2163 #endif
2164 }
2165 the_end:
2166 return -1;
2167 }
2168
2169 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
2170 {
2171 #ifdef CONFIG_PROFILER
2172 {
2173 int n;
2174 n = (gen_opc_ptr - gen_opc_buf);
2175 s->op_count += n;
2176 if (n > s->op_count_max)
2177 s->op_count_max = n;
2178
2179 s->temp_count += s->nb_temps;
2180 if (s->nb_temps > s->temp_count_max)
2181 s->temp_count_max = s->nb_temps;
2182 }
2183 #endif
2184
2185 tcg_gen_code_common(s, gen_code_buf, -1);
2186
2187 /* flush instruction cache */
2188 flush_icache_range((tcg_target_ulong)gen_code_buf,
2189 (tcg_target_ulong)s->code_ptr);
2190
2191 return s->code_ptr - gen_code_buf;
2192 }
2193
2194 /* Return the index of the micro operation such as the pc after is <
2195 offset bytes from the start of the TB. The contents of gen_code_buf must
2196 not be changed, though writing the same values is ok.
2197 Return -1 if not found. */
2198 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset)
2199 {
2200 return tcg_gen_code_common(s, gen_code_buf, offset);
2201 }
2202
2203 #ifdef CONFIG_PROFILER
2204 void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf)
2205 {
2206 TCGContext *s = &tcg_ctx;
2207 int64_t tot;
2208
2209 tot = s->interm_time + s->code_time;
2210 cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n",
2211 tot, tot / 2.4e9);
2212 cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n",
2213 s->tb_count,
2214 s->tb_count1 - s->tb_count,
2215 s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0);
2216 cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n",
2217 s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max);
2218 cpu_fprintf(f, "deleted ops/TB %0.2f\n",
2219 s->tb_count ?
2220 (double)s->del_op_count / s->tb_count : 0);
2221 cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n",
2222 s->tb_count ?
2223 (double)s->temp_count / s->tb_count : 0,
2224 s->temp_count_max);
2225
2226 cpu_fprintf(f, "cycles/op %0.1f\n",
2227 s->op_count ? (double)tot / s->op_count : 0);
2228 cpu_fprintf(f, "cycles/in byte %0.1f\n",
2229 s->code_in_len ? (double)tot / s->code_in_len : 0);
2230 cpu_fprintf(f, "cycles/out byte %0.1f\n",
2231 s->code_out_len ? (double)tot / s->code_out_len : 0);
2232 if (tot == 0)
2233 tot = 1;
2234 cpu_fprintf(f, " gen_interm time %0.1f%%\n",
2235 (double)s->interm_time / tot * 100.0);
2236 cpu_fprintf(f, " gen_code time %0.1f%%\n",
2237 (double)s->code_time / tot * 100.0);
2238 cpu_fprintf(f, "liveness/code time %0.1f%%\n",
2239 (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0);
2240 cpu_fprintf(f, "cpu_restore count %" PRId64 "\n",
2241 s->restore_count);
2242 cpu_fprintf(f, " avg cycles %0.1f\n",
2243 s->restore_count ? (double)s->restore_time / s->restore_count : 0);
2244
2245 dump_op_count();
2246 }
2247 #else
2248 void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf)
2249 {
2250 cpu_fprintf(f, "[TCG profiler not compiled]\n");
2251 }
2252 #endif
2253
2254 #ifdef ELF_HOST_MACHINE
2255 /* In order to use this feature, the backend needs to do three things:
2256
2257 (1) Define ELF_HOST_MACHINE to indicate both what value to
2258 put into the ELF image and to indicate support for the feature.
2259
2260 (2) Define tcg_register_jit. This should create a buffer containing
2261 the contents of a .debug_frame section that describes the post-
2262 prologue unwind info for the tcg machine.
2263
2264 (3) Call tcg_register_jit_int, with the constructed .debug_frame.
2265 */
2266
2267 /* Begin GDB interface. THE FOLLOWING MUST MATCH GDB DOCS. */
2268 typedef enum {
2269 JIT_NOACTION = 0,
2270 JIT_REGISTER_FN,
2271 JIT_UNREGISTER_FN
2272 } jit_actions_t;
2273
2274 struct jit_code_entry {
2275 struct jit_code_entry *next_entry;
2276 struct jit_code_entry *prev_entry;
2277 const void *symfile_addr;
2278 uint64_t symfile_size;
2279 };
2280
2281 struct jit_descriptor {
2282 uint32_t version;
2283 uint32_t action_flag;
2284 struct jit_code_entry *relevant_entry;
2285 struct jit_code_entry *first_entry;
2286 };
2287
2288 void __jit_debug_register_code(void) __attribute__((noinline));
2289 void __jit_debug_register_code(void)
2290 {
2291 asm("");
2292 }
2293
2294 /* Must statically initialize the version, because GDB may check
2295 the version before we can set it. */
2296 struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 };
2297
2298 /* End GDB interface. */
2299
2300 static int find_string(const char *strtab, const char *str)
2301 {
2302 const char *p = strtab + 1;
2303
2304 while (1) {
2305 if (strcmp(p, str) == 0) {
2306 return p - strtab;
2307 }
2308 p += strlen(p) + 1;
2309 }
2310 }
2311
2312 static void tcg_register_jit_int(void *buf_ptr, size_t buf_size,
2313 void *debug_frame, size_t debug_frame_size)
2314 {
2315 struct __attribute__((packed)) DebugInfo {
2316 uint32_t len;
2317 uint16_t version;
2318 uint32_t abbrev;
2319 uint8_t ptr_size;
2320 uint8_t cu_die;
2321 uint16_t cu_lang;
2322 uintptr_t cu_low_pc;
2323 uintptr_t cu_high_pc;
2324 uint8_t fn_die;
2325 char fn_name[16];
2326 uintptr_t fn_low_pc;
2327 uintptr_t fn_high_pc;
2328 uint8_t cu_eoc;
2329 };
2330
2331 struct ElfImage {
2332 ElfW(Ehdr) ehdr;
2333 ElfW(Phdr) phdr;
2334 ElfW(Shdr) shdr[7];
2335 ElfW(Sym) sym[2];
2336 struct DebugInfo di;
2337 uint8_t da[24];
2338 char str[80];
2339 };
2340
2341 struct ElfImage *img;
2342
2343 static const struct ElfImage img_template = {
2344 .ehdr = {
2345 .e_ident[EI_MAG0] = ELFMAG0,
2346 .e_ident[EI_MAG1] = ELFMAG1,
2347 .e_ident[EI_MAG2] = ELFMAG2,
2348 .e_ident[EI_MAG3] = ELFMAG3,
2349 .e_ident[EI_CLASS] = ELF_CLASS,
2350 .e_ident[EI_DATA] = ELF_DATA,
2351 .e_ident[EI_VERSION] = EV_CURRENT,
2352 .e_type = ET_EXEC,
2353 .e_machine = ELF_HOST_MACHINE,
2354 .e_version = EV_CURRENT,
2355 .e_phoff = offsetof(struct ElfImage, phdr),
2356 .e_shoff = offsetof(struct ElfImage, shdr),
2357 .e_ehsize = sizeof(ElfW(Shdr)),
2358 .e_phentsize = sizeof(ElfW(Phdr)),
2359 .e_phnum = 1,
2360 .e_shentsize = sizeof(ElfW(Shdr)),
2361 .e_shnum = ARRAY_SIZE(img->shdr),
2362 .e_shstrndx = ARRAY_SIZE(img->shdr) - 1,
2363 #ifdef ELF_HOST_FLAGS
2364 .e_flags = ELF_HOST_FLAGS,
2365 #endif
2366 #ifdef ELF_OSABI
2367 .e_ident[EI_OSABI] = ELF_OSABI,
2368 #endif
2369 },
2370 .phdr = {
2371 .p_type = PT_LOAD,
2372 .p_flags = PF_X,
2373 },
2374 .shdr = {
2375 [0] = { .sh_type = SHT_NULL },
2376 /* Trick: The contents of code_gen_buffer are not present in
2377 this fake ELF file; that got allocated elsewhere. Therefore
2378 we mark .text as SHT_NOBITS (similar to .bss) so that readers
2379 will not look for contents. We can record any address. */
2380 [1] = { /* .text */
2381 .sh_type = SHT_NOBITS,
2382 .sh_flags = SHF_EXECINSTR | SHF_ALLOC,
2383 },
2384 [2] = { /* .debug_info */
2385 .sh_type = SHT_PROGBITS,
2386 .sh_offset = offsetof(struct ElfImage, di),
2387 .sh_size = sizeof(struct DebugInfo),
2388 },
2389 [3] = { /* .debug_abbrev */
2390 .sh_type = SHT_PROGBITS,
2391 .sh_offset = offsetof(struct ElfImage, da),
2392 .sh_size = sizeof(img->da),
2393 },
2394 [4] = { /* .debug_frame */
2395 .sh_type = SHT_PROGBITS,
2396 .sh_offset = sizeof(struct ElfImage),
2397 },
2398 [5] = { /* .symtab */
2399 .sh_type = SHT_SYMTAB,
2400 .sh_offset = offsetof(struct ElfImage, sym),
2401 .sh_size = sizeof(img->sym),
2402 .sh_info = 1,
2403 .sh_link = ARRAY_SIZE(img->shdr) - 1,
2404 .sh_entsize = sizeof(ElfW(Sym)),
2405 },
2406 [6] = { /* .strtab */
2407 .sh_type = SHT_STRTAB,
2408 .sh_offset = offsetof(struct ElfImage, str),
2409 .sh_size = sizeof(img->str),
2410 }
2411 },
2412 .sym = {
2413 [1] = { /* code_gen_buffer */
2414 .st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC),
2415 .st_shndx = 1,
2416 }
2417 },
2418 .di = {
2419 .len = sizeof(struct DebugInfo) - 4,
2420 .version = 2,
2421 .ptr_size = sizeof(void *),
2422 .cu_die = 1,
2423 .cu_lang = 0x8001, /* DW_LANG_Mips_Assembler */
2424 .fn_die = 2,
2425 .fn_name = "code_gen_buffer"
2426 },
2427 .da = {
2428 1, /* abbrev number (the cu) */
2429 0x11, 1, /* DW_TAG_compile_unit, has children */
2430 0x13, 0x5, /* DW_AT_language, DW_FORM_data2 */
2431 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */
2432 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */
2433 0, 0, /* end of abbrev */
2434 2, /* abbrev number (the fn) */
2435 0x2e, 0, /* DW_TAG_subprogram, no children */
2436 0x3, 0x8, /* DW_AT_name, DW_FORM_string */
2437 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */
2438 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */
2439 0, 0, /* end of abbrev */
2440 0 /* no more abbrev */
2441 },
2442 .str = "\0" ".text\0" ".debug_info\0" ".debug_abbrev\0"
2443 ".debug_frame\0" ".symtab\0" ".strtab\0" "code_gen_buffer",
2444 };
2445
2446 /* We only need a single jit entry; statically allocate it. */
2447 static struct jit_code_entry one_entry;
2448
2449 uintptr_t buf = (uintptr_t)buf_ptr;
2450 size_t img_size = sizeof(struct ElfImage) + debug_frame_size;
2451
2452 img = g_malloc(img_size);
2453 *img = img_template;
2454 memcpy(img + 1, debug_frame, debug_frame_size);
2455
2456 img->phdr.p_vaddr = buf;
2457 img->phdr.p_paddr = buf;
2458 img->phdr.p_memsz = buf_size;
2459
2460 img->shdr[1].sh_name = find_string(img->str, ".text");
2461 img->shdr[1].sh_addr = buf;
2462 img->shdr[1].sh_size = buf_size;
2463
2464 img->shdr[2].sh_name = find_string(img->str, ".debug_info");
2465 img->shdr[3].sh_name = find_string(img->str, ".debug_abbrev");
2466
2467 img->shdr[4].sh_name = find_string(img->str, ".debug_frame");
2468 img->shdr[4].sh_size = debug_frame_size;
2469
2470 img->shdr[5].sh_name = find_string(img->str, ".symtab");
2471 img->shdr[6].sh_name = find_string(img->str, ".strtab");
2472
2473 img->sym[1].st_name = find_string(img->str, "code_gen_buffer");
2474 img->sym[1].st_value = buf;
2475 img->sym[1].st_size = buf_size;
2476
2477 img->di.cu_low_pc = buf;
2478 img->di.cu_high_pc = buf_size;
2479 img->di.fn_low_pc = buf;
2480 img->di.fn_high_pc = buf_size;
2481
2482 #ifdef DEBUG_JIT
2483 /* Enable this block to be able to debug the ELF image file creation.
2484 One can use readelf, objdump, or other inspection utilities. */
2485 {
2486 FILE *f = fopen("/tmp/qemu.jit", "w+b");
2487 if (f) {
2488 if (fwrite(img, img_size, 1, f) != img_size) {
2489 /* Avoid stupid unused return value warning for fwrite. */
2490 }
2491 fclose(f);
2492 }
2493 }
2494 #endif
2495
2496 one_entry.symfile_addr = img;
2497 one_entry.symfile_size = img_size;
2498
2499 __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
2500 __jit_debug_descriptor.relevant_entry = &one_entry;
2501 __jit_debug_descriptor.first_entry = &one_entry;
2502 __jit_debug_register_code();
2503 }
2504 #else
2505 /* No support for the feature. Provide the entry point expected by exec.c,
2506 and implement the internal function we declared earlier. */
2507
2508 static void tcg_register_jit_int(void *buf, size_t size,
2509 void *debug_frame, size_t debug_frame_size)
2510 {
2511 }
2512
2513 void tcg_register_jit(void *buf, size_t buf_size)
2514 {
2515 }
2516 #endif /* ELF_HOST_MACHINE */
Random patches