Statistics
| Branch: | Revision:

root / tcg / tcg.c @ 2bece2c8

History | View | Annotate | Download (64.9 kB)

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

    
28
#include "config.h"
29

    
30
#if !defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG)
31
/* define it to suppress various consistency checks (faster) */
32
#define NDEBUG
33
#endif
34

    
35
#include <stdarg.h>
36
#include <stdlib.h>
37
#include <stdio.h>
38
#include <string.h>
39
#include <inttypes.h>
40
#ifdef _WIN32
41
#include <malloc.h>
42
#endif
43
#ifdef _AIX
44
#include <alloca.h>
45
#endif
46

    
47
#include "qemu-common.h"
48
#include "cache-utils.h"
49
#include "host-utils.h"
50
#include "qemu-timer.h"
51

    
52
/* Note: the long term plan is to reduce the dependancies on the QEMU
53
   CPU definitions. Currently they are used for qemu_ld/st
54
   instructions */
55
#define NO_CPU_IO_DEFS
56
#include "cpu.h"
57
#include "exec-all.h"
58

    
59
#include "tcg-op.h"
60
#include "elf.h"
61

    
62
#if defined(CONFIG_USE_GUEST_BASE) && !defined(TCG_TARGET_HAS_GUEST_BASE)
63
#error GUEST_BASE not supported on this host.
64
#endif
65

    
66
static void tcg_target_init(TCGContext *s);
67
static void tcg_target_qemu_prologue(TCGContext *s);
68
static void patch_reloc(uint8_t *code_ptr, int type, 
69
                        tcg_target_long value, tcg_target_long addend);
70

    
71
static TCGOpDef tcg_op_defs[] = {
72
#define DEF(s, oargs, iargs, cargs, flags) { #s, oargs, iargs, cargs, iargs + oargs + cargs, flags },
73
#include "tcg-opc.h"
74
#undef DEF
75
};
76

    
77
static TCGRegSet tcg_target_available_regs[2];
78
static TCGRegSet tcg_target_call_clobber_regs;
79

    
80
/* XXX: move that inside the context */
81
uint16_t *gen_opc_ptr;
82
TCGArg *gen_opparam_ptr;
83

    
84
static inline void tcg_out8(TCGContext *s, uint8_t v)
85
{
86
    *s->code_ptr++ = v;
87
}
88

    
89
static inline void tcg_out16(TCGContext *s, uint16_t v)
90
{
91
    *(uint16_t *)s->code_ptr = v;
92
    s->code_ptr += 2;
93
}
94

    
95
static inline void tcg_out32(TCGContext *s, uint32_t v)
96
{
97
    *(uint32_t *)s->code_ptr = v;
98
    s->code_ptr += 4;
99
}
100

    
101
/* label relocation processing */
102

    
103
static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type,
104
                          int label_index, long addend)
105
{
106
    TCGLabel *l;
107
    TCGRelocation *r;
108

    
109
    l = &s->labels[label_index];
110
    if (l->has_value) {
111
        /* FIXME: This may break relocations on RISC targets that
112
           modify instruction fields in place.  The caller may not have 
113
           written the initial value.  */
114
        patch_reloc(code_ptr, type, l->u.value, addend);
115
    } else {
116
        /* add a new relocation entry */
117
        r = tcg_malloc(sizeof(TCGRelocation));
118
        r->type = type;
119
        r->ptr = code_ptr;
120
        r->addend = addend;
121
        r->next = l->u.first_reloc;
122
        l->u.first_reloc = r;
123
    }
124
}
125

    
126
static void tcg_out_label(TCGContext *s, int label_index, 
127
                          tcg_target_long value)
128
{
129
    TCGLabel *l;
130
    TCGRelocation *r;
131

    
132
    l = &s->labels[label_index];
133
    if (l->has_value)
134
        tcg_abort();
135
    r = l->u.first_reloc;
136
    while (r != NULL) {
137
        patch_reloc(r->ptr, r->type, value, r->addend);
138
        r = r->next;
139
    }
140
    l->has_value = 1;
141
    l->u.value = value;
142
}
143

    
144
int gen_new_label(void)
145
{
146
    TCGContext *s = &tcg_ctx;
147
    int idx;
148
    TCGLabel *l;
149

    
150
    if (s->nb_labels >= TCG_MAX_LABELS)
151
        tcg_abort();
152
    idx = s->nb_labels++;
153
    l = &s->labels[idx];
154
    l->has_value = 0;
155
    l->u.first_reloc = NULL;
156
    return idx;
157
}
158

    
159
#include "tcg-target.c"
160

    
161
/* pool based memory allocation */
162
void *tcg_malloc_internal(TCGContext *s, int size)
163
{
164
    TCGPool *p;
165
    int pool_size;
166
    
167
    if (size > TCG_POOL_CHUNK_SIZE) {
168
        /* big malloc: insert a new pool (XXX: could optimize) */
169
        p = qemu_malloc(sizeof(TCGPool) + size);
170
        p->size = size;
171
        if (s->pool_current)
172
            s->pool_current->next = p;
173
        else
174
            s->pool_first = p;
175
        p->next = s->pool_current;
176
    } else {
177
        p = s->pool_current;
178
        if (!p) {
179
            p = s->pool_first;
180
            if (!p)
181
                goto new_pool;
182
        } else {
183
            if (!p->next) {
184
            new_pool:
185
                pool_size = TCG_POOL_CHUNK_SIZE;
186
                p = qemu_malloc(sizeof(TCGPool) + pool_size);
187
                p->size = pool_size;
188
                p->next = NULL;
189
                if (s->pool_current) 
190
                    s->pool_current->next = p;
191
                else
192
                    s->pool_first = p;
193
            } else {
194
                p = p->next;
195
            }
196
        }
197
    }
198
    s->pool_current = p;
199
    s->pool_cur = p->data + size;
200
    s->pool_end = p->data + p->size;
201
    return p->data;
202
}
203

    
204
void tcg_pool_reset(TCGContext *s)
205
{
206
    s->pool_cur = s->pool_end = NULL;
207
    s->pool_current = NULL;
208
}
209

    
210
void tcg_context_init(TCGContext *s)
211
{
212
    int op, total_args, n;
213
    TCGOpDef *def;
214
    TCGArgConstraint *args_ct;
215
    int *sorted_args;
216

    
217
    memset(s, 0, sizeof(*s));
218
    s->temps = s->static_temps;
219
    s->nb_globals = 0;
220
    
221
    /* Count total number of arguments and allocate the corresponding
222
       space */
223
    total_args = 0;
224
    for(op = 0; op < NB_OPS; op++) {
225
        def = &tcg_op_defs[op];
226
        n = def->nb_iargs + def->nb_oargs;
227
        total_args += n;
228
    }
229

    
230
    args_ct = qemu_malloc(sizeof(TCGArgConstraint) * total_args);
231
    sorted_args = qemu_malloc(sizeof(int) * total_args);
232

    
233
    for(op = 0; op < NB_OPS; op++) {
234
        def = &tcg_op_defs[op];
235
        def->args_ct = args_ct;
236
        def->sorted_args = sorted_args;
237
        n = def->nb_iargs + def->nb_oargs;
238
        sorted_args += n;
239
        args_ct += n;
240
    }
241
    
242
    tcg_target_init(s);
243
}
244

    
245
void tcg_prologue_init(TCGContext *s)
246
{
247
    /* init global prologue and epilogue */
248
    s->code_buf = code_gen_prologue;
249
    s->code_ptr = s->code_buf;
250
    tcg_target_qemu_prologue(s);
251
    flush_icache_range((unsigned long)s->code_buf, 
252
                       (unsigned long)s->code_ptr);
253
}
254

    
255
void tcg_set_frame(TCGContext *s, int reg,
256
                   tcg_target_long start, tcg_target_long size)
257
{
258
    s->frame_start = start;
259
    s->frame_end = start + size;
260
    s->frame_reg = reg;
261
}
262

    
263
void tcg_func_start(TCGContext *s)
264
{
265
    int i;
266
    tcg_pool_reset(s);
267
    s->nb_temps = s->nb_globals;
268
    for(i = 0; i < (TCG_TYPE_COUNT * 2); i++)
269
        s->first_free_temp[i] = -1;
270
    s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS);
271
    s->nb_labels = 0;
272
    s->current_frame_offset = s->frame_start;
273

    
274
    gen_opc_ptr = gen_opc_buf;
275
    gen_opparam_ptr = gen_opparam_buf;
276
}
277

    
278
static inline void tcg_temp_alloc(TCGContext *s, int n)
279
{
280
    if (n > TCG_MAX_TEMPS)
281
        tcg_abort();
282
}
283

    
284
static inline int tcg_global_reg_new_internal(TCGType type, int reg,
285
                                              const char *name)
286
{
287
    TCGContext *s = &tcg_ctx;
288
    TCGTemp *ts;
289
    int idx;
290

    
291
#if TCG_TARGET_REG_BITS == 32
292
    if (type != TCG_TYPE_I32)
293
        tcg_abort();
294
#endif
295
    if (tcg_regset_test_reg(s->reserved_regs, reg))
296
        tcg_abort();
297
    idx = s->nb_globals;
298
    tcg_temp_alloc(s, s->nb_globals + 1);
299
    ts = &s->temps[s->nb_globals];
300
    ts->base_type = type;
301
    ts->type = type;
302
    ts->fixed_reg = 1;
303
    ts->reg = reg;
304
    ts->name = name;
305
    s->nb_globals++;
306
    tcg_regset_set_reg(s->reserved_regs, reg);
307
    return idx;
308
}
309

    
310
TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name)
311
{
312
    int idx;
313

    
314
    idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name);
315
    return MAKE_TCGV_I32(idx);
316
}
317

    
318
TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name)
319
{
320
    int idx;
321

    
322
    idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name);
323
    return MAKE_TCGV_I64(idx);
324
}
325

    
326
static inline int tcg_global_mem_new_internal(TCGType type, int reg,
327
                                              tcg_target_long offset,
328
                                              const char *name)
329
{
330
    TCGContext *s = &tcg_ctx;
331
    TCGTemp *ts;
332
    int idx;
333

    
334
    idx = s->nb_globals;
335
#if TCG_TARGET_REG_BITS == 32
336
    if (type == TCG_TYPE_I64) {
337
        char buf[64];
338
        tcg_temp_alloc(s, s->nb_globals + 2);
339
        ts = &s->temps[s->nb_globals];
340
        ts->base_type = type;
341
        ts->type = TCG_TYPE_I32;
342
        ts->fixed_reg = 0;
343
        ts->mem_allocated = 1;
344
        ts->mem_reg = reg;
345
#ifdef TCG_TARGET_WORDS_BIGENDIAN
346
        ts->mem_offset = offset + 4;
347
#else
348
        ts->mem_offset = offset;
349
#endif
350
        pstrcpy(buf, sizeof(buf), name);
351
        pstrcat(buf, sizeof(buf), "_0");
352
        ts->name = strdup(buf);
353
        ts++;
354

    
355
        ts->base_type = type;
356
        ts->type = TCG_TYPE_I32;
357
        ts->fixed_reg = 0;
358
        ts->mem_allocated = 1;
359
        ts->mem_reg = reg;
360
#ifdef TCG_TARGET_WORDS_BIGENDIAN
361
        ts->mem_offset = offset;
362
#else
363
        ts->mem_offset = offset + 4;
364
#endif
365
        pstrcpy(buf, sizeof(buf), name);
366
        pstrcat(buf, sizeof(buf), "_1");
367
        ts->name = strdup(buf);
368

    
369
        s->nb_globals += 2;
370
    } else
371
#endif
372
    {
373
        tcg_temp_alloc(s, s->nb_globals + 1);
374
        ts = &s->temps[s->nb_globals];
375
        ts->base_type = type;
376
        ts->type = type;
377
        ts->fixed_reg = 0;
378
        ts->mem_allocated = 1;
379
        ts->mem_reg = reg;
380
        ts->mem_offset = offset;
381
        ts->name = name;
382
        s->nb_globals++;
383
    }
384
    return idx;
385
}
386

    
387
TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset,
388
                                const char *name)
389
{
390
    int idx;
391

    
392
    idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name);
393
    return MAKE_TCGV_I32(idx);
394
}
395

    
396
TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset,
397
                                const char *name)
398
{
399
    int idx;
400

    
401
    idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name);
402
    return MAKE_TCGV_I64(idx);
403
}
404

    
405
static inline int tcg_temp_new_internal(TCGType type, int temp_local)
406
{
407
    TCGContext *s = &tcg_ctx;
408
    TCGTemp *ts;
409
    int idx, k;
410

    
411
    k = type;
412
    if (temp_local)
413
        k += TCG_TYPE_COUNT;
414
    idx = s->first_free_temp[k];
415
    if (idx != -1) {
416
        /* There is already an available temp with the
417
           right type */
418
        ts = &s->temps[idx];
419
        s->first_free_temp[k] = ts->next_free_temp;
420
        ts->temp_allocated = 1;
421
        assert(ts->temp_local == temp_local);
422
    } else {
423
        idx = s->nb_temps;
424
#if TCG_TARGET_REG_BITS == 32
425
        if (type == TCG_TYPE_I64) {
426
            tcg_temp_alloc(s, s->nb_temps + 2);
427
            ts = &s->temps[s->nb_temps];
428
            ts->base_type = type;
429
            ts->type = TCG_TYPE_I32;
430
            ts->temp_allocated = 1;
431
            ts->temp_local = temp_local;
432
            ts->name = NULL;
433
            ts++;
434
            ts->base_type = TCG_TYPE_I32;
435
            ts->type = TCG_TYPE_I32;
436
            ts->temp_allocated = 1;
437
            ts->temp_local = temp_local;
438
            ts->name = NULL;
439
            s->nb_temps += 2;
440
        } else
441
#endif
442
        {
443
            tcg_temp_alloc(s, s->nb_temps + 1);
444
            ts = &s->temps[s->nb_temps];
445
            ts->base_type = type;
446
            ts->type = type;
447
            ts->temp_allocated = 1;
448
            ts->temp_local = temp_local;
449
            ts->name = NULL;
450
            s->nb_temps++;
451
        }
452
    }
453
    return idx;
454
}
455

    
456
TCGv_i32 tcg_temp_new_internal_i32(int temp_local)
457
{
458
    int idx;
459

    
460
    idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local);
461
    return MAKE_TCGV_I32(idx);
462
}
463

    
464
TCGv_i64 tcg_temp_new_internal_i64(int temp_local)
465
{
466
    int idx;
467

    
468
    idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local);
469
    return MAKE_TCGV_I64(idx);
470
}
471

    
472
static inline void tcg_temp_free_internal(int idx)
473
{
474
    TCGContext *s = &tcg_ctx;
475
    TCGTemp *ts;
476
    int k;
477

    
478
    assert(idx >= s->nb_globals && idx < s->nb_temps);
479
    ts = &s->temps[idx];
480
    assert(ts->temp_allocated != 0);
481
    ts->temp_allocated = 0;
482
    k = ts->base_type;
483
    if (ts->temp_local)
484
        k += TCG_TYPE_COUNT;
485
    ts->next_free_temp = s->first_free_temp[k];
486
    s->first_free_temp[k] = idx;
487
}
488

    
489
void tcg_temp_free_i32(TCGv_i32 arg)
490
{
491
    tcg_temp_free_internal(GET_TCGV_I32(arg));
492
}
493

    
494
void tcg_temp_free_i64(TCGv_i64 arg)
495
{
496
    tcg_temp_free_internal(GET_TCGV_I64(arg));
497
}
498

    
499
TCGv_i32 tcg_const_i32(int32_t val)
500
{
501
    TCGv_i32 t0;
502
    t0 = tcg_temp_new_i32();
503
    tcg_gen_movi_i32(t0, val);
504
    return t0;
505
}
506

    
507
TCGv_i64 tcg_const_i64(int64_t val)
508
{
509
    TCGv_i64 t0;
510
    t0 = tcg_temp_new_i64();
511
    tcg_gen_movi_i64(t0, val);
512
    return t0;
513
}
514

    
515
TCGv_i32 tcg_const_local_i32(int32_t val)
516
{
517
    TCGv_i32 t0;
518
    t0 = tcg_temp_local_new_i32();
519
    tcg_gen_movi_i32(t0, val);
520
    return t0;
521
}
522

    
523
TCGv_i64 tcg_const_local_i64(int64_t val)
524
{
525
    TCGv_i64 t0;
526
    t0 = tcg_temp_local_new_i64();
527
    tcg_gen_movi_i64(t0, val);
528
    return t0;
529
}
530

    
531
void tcg_register_helper(void *func, const char *name)
532
{
533
    TCGContext *s = &tcg_ctx;
534
    int n;
535
    if ((s->nb_helpers + 1) > s->allocated_helpers) {
536
        n = s->allocated_helpers;
537
        if (n == 0) {
538
            n = 4;
539
        } else {
540
            n *= 2;
541
        }
542
        s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo));
543
        s->allocated_helpers = n;
544
    }
545
    s->helpers[s->nb_helpers].func = (tcg_target_ulong)func;
546
    s->helpers[s->nb_helpers].name = name;
547
    s->nb_helpers++;
548
}
549

    
550
/* Note: we convert the 64 bit args to 32 bit and do some alignment
551
   and endian swap. Maybe it would be better to do the alignment
552
   and endian swap in tcg_reg_alloc_call(). */
553
void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags,
554
                   int sizemask, TCGArg ret, int nargs, TCGArg *args)
555
{
556
#ifdef TCG_TARGET_I386
557
    int call_type;
558
#endif
559
    int i;
560
    int real_args;
561
    int nb_rets;
562
    TCGArg *nparam;
563

    
564
#if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64
565
    for (i = 0; i < nargs; ++i) {
566
        int is_64bit = sizemask & (1 << (i+1)*2);
567
        int is_signed = sizemask & (2 << (i+1)*2);
568
        if (!is_64bit) {
569
            TCGv_i64 temp = tcg_temp_new_i64();
570
            TCGv_i64 orig = MAKE_TCGV_I64(args[i]);
571
            if (is_signed) {
572
                tcg_gen_ext32s_i64(temp, orig);
573
            } else {
574
                tcg_gen_ext32u_i64(temp, orig);
575
            }
576
            args[i] = GET_TCGV_I64(temp);
577
        }
578
    }
579
#endif /* TCG_TARGET_EXTEND_ARGS */
580

    
581
    *gen_opc_ptr++ = INDEX_op_call;
582
    nparam = gen_opparam_ptr++;
583
#ifdef TCG_TARGET_I386
584
    call_type = (flags & TCG_CALL_TYPE_MASK);
585
#endif
586
    if (ret != TCG_CALL_DUMMY_ARG) {
587
#if TCG_TARGET_REG_BITS < 64
588
        if (sizemask & 1) {
589
#ifdef TCG_TARGET_WORDS_BIGENDIAN
590
            *gen_opparam_ptr++ = ret + 1;
591
            *gen_opparam_ptr++ = ret;
592
#else
593
            *gen_opparam_ptr++ = ret;
594
            *gen_opparam_ptr++ = ret + 1;
595
#endif
596
            nb_rets = 2;
597
        } else
598
#endif
599
        {
600
            *gen_opparam_ptr++ = ret;
601
            nb_rets = 1;
602
        }
603
    } else {
604
        nb_rets = 0;
605
    }
606
    real_args = 0;
607
    for (i = 0; i < nargs; i++) {
608
#if TCG_TARGET_REG_BITS < 64
609
        int is_64bit = sizemask & (1 << (i+1)*2);
610
        if (is_64bit) {
611
#ifdef TCG_TARGET_I386
612
            /* REGPARM case: if the third parameter is 64 bit, it is
613
               allocated on the stack */
614
            if (i == 2 && call_type == TCG_CALL_TYPE_REGPARM) {
615
                call_type = TCG_CALL_TYPE_REGPARM_2;
616
                flags = (flags & ~TCG_CALL_TYPE_MASK) | call_type;
617
            }
618
#endif
619
#ifdef TCG_TARGET_CALL_ALIGN_ARGS
620
            /* some targets want aligned 64 bit args */
621
            if (real_args & 1) {
622
                *gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG;
623
                real_args++;
624
            }
625
#endif
626
            /* If stack grows up, then we will be placing successive
627
               arguments at lower addresses, which means we need to
628
               reverse the order compared to how we would normally
629
               treat either big or little-endian.  For those arguments
630
               that will wind up in registers, this still works for
631
               HPPA (the only current STACK_GROWSUP target) since the
632
               argument registers are *also* allocated in decreasing
633
               order.  If another such target is added, this logic may
634
               have to get more complicated to differentiate between
635
               stack arguments and register arguments.  */
636
#if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP)
637
            *gen_opparam_ptr++ = args[i] + 1;
638
            *gen_opparam_ptr++ = args[i];
639
#else
640
            *gen_opparam_ptr++ = args[i];
641
            *gen_opparam_ptr++ = args[i] + 1;
642
#endif
643
            real_args += 2;
644
            continue;
645
        }
646
#endif /* TCG_TARGET_REG_BITS < 64 */
647

    
648
        *gen_opparam_ptr++ = args[i];
649
        real_args++;
650
    }
651
    *gen_opparam_ptr++ = GET_TCGV_PTR(func);
652

    
653
    *gen_opparam_ptr++ = flags;
654

    
655
    *nparam = (nb_rets << 16) | (real_args + 1);
656

    
657
    /* total parameters, needed to go backward in the instruction stream */
658
    *gen_opparam_ptr++ = 1 + nb_rets + real_args + 3;
659

    
660
#if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64
661
    for (i = 0; i < nargs; ++i) {
662
        int is_64bit = sizemask & (1 << (i+1)*2);
663
        if (!is_64bit) {
664
            TCGv_i64 temp = MAKE_TCGV_I64(args[i]);
665
            tcg_temp_free_i64(temp);
666
        }
667
    }
668
#endif /* TCG_TARGET_EXTEND_ARGS */
669
}
670

    
671
#if TCG_TARGET_REG_BITS == 32
672
void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
673
                        int c, int right, int arith)
674
{
675
    if (c == 0) {
676
        tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1));
677
        tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1));
678
    } else if (c >= 32) {
679
        c -= 32;
680
        if (right) {
681
            if (arith) {
682
                tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c);
683
                tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31);
684
            } else {
685
                tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c);
686
                tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
687
            }
688
        } else {
689
            tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c);
690
            tcg_gen_movi_i32(TCGV_LOW(ret), 0);
691
        }
692
    } else {
693
        TCGv_i32 t0, t1;
694

    
695
        t0 = tcg_temp_new_i32();
696
        t1 = tcg_temp_new_i32();
697
        if (right) {
698
            tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c);
699
            if (arith)
700
                tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c);
701
            else
702
                tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c);
703
            tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c);
704
            tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0);
705
            tcg_gen_mov_i32(TCGV_HIGH(ret), t1);
706
        } else {
707
            tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c);
708
            /* Note: ret can be the same as arg1, so we use t1 */
709
            tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c);
710
            tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c);
711
            tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0);
712
            tcg_gen_mov_i32(TCGV_LOW(ret), t1);
713
        }
714
        tcg_temp_free_i32(t0);
715
        tcg_temp_free_i32(t1);
716
    }
717
}
718
#endif
719

    
720

    
721
static void tcg_reg_alloc_start(TCGContext *s)
722
{
723
    int i;
724
    TCGTemp *ts;
725
    for(i = 0; i < s->nb_globals; i++) {
726
        ts = &s->temps[i];
727
        if (ts->fixed_reg) {
728
            ts->val_type = TEMP_VAL_REG;
729
        } else {
730
            ts->val_type = TEMP_VAL_MEM;
731
        }
732
    }
733
    for(i = s->nb_globals; i < s->nb_temps; i++) {
734
        ts = &s->temps[i];
735
        ts->val_type = TEMP_VAL_DEAD;
736
        ts->mem_allocated = 0;
737
        ts->fixed_reg = 0;
738
    }
739
    for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
740
        s->reg_to_temp[i] = -1;
741
    }
742
}
743

    
744
static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size,
745
                                 int idx)
746
{
747
    TCGTemp *ts;
748

    
749
    ts = &s->temps[idx];
750
    if (idx < s->nb_globals) {
751
        pstrcpy(buf, buf_size, ts->name);
752
    } else {
753
        if (ts->temp_local) 
754
            snprintf(buf, buf_size, "loc%d", idx - s->nb_globals);
755
        else
756
            snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals);
757
    }
758
    return buf;
759
}
760

    
761
char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg)
762
{
763
    return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg));
764
}
765

    
766
char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg)
767
{
768
    return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg));
769
}
770

    
771
static int helper_cmp(const void *p1, const void *p2)
772
{
773
    const TCGHelperInfo *th1 = p1;
774
    const TCGHelperInfo *th2 = p2;
775
    if (th1->func < th2->func)
776
        return -1;
777
    else if (th1->func == th2->func)
778
        return 0;
779
    else
780
        return 1;
781
}
782

    
783
/* find helper definition (Note: A hash table would be better) */
784
static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val)
785
{
786
    int m, m_min, m_max;
787
    TCGHelperInfo *th;
788
    tcg_target_ulong v;
789

    
790
    if (unlikely(!s->helpers_sorted)) {
791
        qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 
792
              helper_cmp);
793
        s->helpers_sorted = 1;
794
    }
795

    
796
    /* binary search */
797
    m_min = 0;
798
    m_max = s->nb_helpers - 1;
799
    while (m_min <= m_max) {
800
        m = (m_min + m_max) >> 1;
801
        th = &s->helpers[m];
802
        v = th->func;
803
        if (v == val)
804
            return th;
805
        else if (val < v) {
806
            m_max = m - 1;
807
        } else {
808
            m_min = m + 1;
809
        }
810
    }
811
    return NULL;
812
}
813

    
814
static const char * const cond_name[] =
815
{
816
    [TCG_COND_EQ] = "eq",
817
    [TCG_COND_NE] = "ne",
818
    [TCG_COND_LT] = "lt",
819
    [TCG_COND_GE] = "ge",
820
    [TCG_COND_LE] = "le",
821
    [TCG_COND_GT] = "gt",
822
    [TCG_COND_LTU] = "ltu",
823
    [TCG_COND_GEU] = "geu",
824
    [TCG_COND_LEU] = "leu",
825
    [TCG_COND_GTU] = "gtu"
826
};
827

    
828
void tcg_dump_ops(TCGContext *s, FILE *outfile)
829
{
830
    const uint16_t *opc_ptr;
831
    const TCGArg *args;
832
    TCGArg arg;
833
    TCGOpcode c;
834
    int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn;
835
    const TCGOpDef *def;
836
    char buf[128];
837

    
838
    first_insn = 1;
839
    opc_ptr = gen_opc_buf;
840
    args = gen_opparam_buf;
841
    while (opc_ptr < gen_opc_ptr) {
842
        c = *opc_ptr++;
843
        def = &tcg_op_defs[c];
844
        if (c == INDEX_op_debug_insn_start) {
845
            uint64_t pc;
846
#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
847
            pc = ((uint64_t)args[1] << 32) | args[0];
848
#else
849
            pc = args[0];
850
#endif
851
            if (!first_insn) 
852
                fprintf(outfile, "\n");
853
            fprintf(outfile, " ---- 0x%" PRIx64, pc);
854
            first_insn = 0;
855
            nb_oargs = def->nb_oargs;
856
            nb_iargs = def->nb_iargs;
857
            nb_cargs = def->nb_cargs;
858
        } else if (c == INDEX_op_call) {
859
            TCGArg arg;
860

    
861
            /* variable number of arguments */
862
            arg = *args++;
863
            nb_oargs = arg >> 16;
864
            nb_iargs = arg & 0xffff;
865
            nb_cargs = def->nb_cargs;
866

    
867
            fprintf(outfile, " %s ", def->name);
868

    
869
            /* function name */
870
            fprintf(outfile, "%s",
871
                    tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + nb_iargs - 1]));
872
            /* flags */
873
            fprintf(outfile, ",$0x%" TCG_PRIlx,
874
                    args[nb_oargs + nb_iargs]);
875
            /* nb out args */
876
            fprintf(outfile, ",$%d", nb_oargs);
877
            for(i = 0; i < nb_oargs; i++) {
878
                fprintf(outfile, ",");
879
                fprintf(outfile, "%s",
880
                        tcg_get_arg_str_idx(s, buf, sizeof(buf), args[i]));
881
            }
882
            for(i = 0; i < (nb_iargs - 1); i++) {
883
                fprintf(outfile, ",");
884
                if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) {
885
                    fprintf(outfile, "<dummy>");
886
                } else {
887
                    fprintf(outfile, "%s",
888
                            tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + i]));
889
                }
890
            }
891
        } else if (c == INDEX_op_movi_i32 
892
#if TCG_TARGET_REG_BITS == 64
893
                   || c == INDEX_op_movi_i64
894
#endif
895
                   ) {
896
            tcg_target_ulong val;
897
            TCGHelperInfo *th;
898

    
899
            nb_oargs = def->nb_oargs;
900
            nb_iargs = def->nb_iargs;
901
            nb_cargs = def->nb_cargs;
902
            fprintf(outfile, " %s %s,$", def->name, 
903
                    tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0]));
904
            val = args[1];
905
            th = tcg_find_helper(s, val);
906
            if (th) {
907
                fprintf(outfile, "%s", th->name);
908
            } else {
909
                if (c == INDEX_op_movi_i32)
910
                    fprintf(outfile, "0x%x", (uint32_t)val);
911
                else
912
                    fprintf(outfile, "0x%" PRIx64 , (uint64_t)val);
913
            }
914
        } else {
915
            fprintf(outfile, " %s ", def->name);
916
            if (c == INDEX_op_nopn) {
917
                /* variable number of arguments */
918
                nb_cargs = *args;
919
                nb_oargs = 0;
920
                nb_iargs = 0;
921
            } else {
922
                nb_oargs = def->nb_oargs;
923
                nb_iargs = def->nb_iargs;
924
                nb_cargs = def->nb_cargs;
925
            }
926
            
927
            k = 0;
928
            for(i = 0; i < nb_oargs; i++) {
929
                if (k != 0)
930
                    fprintf(outfile, ",");
931
                fprintf(outfile, "%s",
932
                        tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++]));
933
            }
934
            for(i = 0; i < nb_iargs; i++) {
935
                if (k != 0)
936
                    fprintf(outfile, ",");
937
                fprintf(outfile, "%s",
938
                        tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++]));
939
            }
940
            switch (c) {
941
            case INDEX_op_brcond_i32:
942
#if TCG_TARGET_REG_BITS == 32
943
            case INDEX_op_brcond2_i32:
944
#elif TCG_TARGET_REG_BITS == 64
945
            case INDEX_op_brcond_i64:
946
#endif
947
            case INDEX_op_setcond_i32:
948
#if TCG_TARGET_REG_BITS == 32
949
            case INDEX_op_setcond2_i32:
950
#elif TCG_TARGET_REG_BITS == 64
951
            case INDEX_op_setcond_i64:
952
#endif
953
                if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]])
954
                    fprintf(outfile, ",%s", cond_name[args[k++]]);
955
                else
956
                    fprintf(outfile, ",$0x%" TCG_PRIlx, args[k++]);
957
                i = 1;
958
                break;
959
            default:
960
                i = 0;
961
                break;
962
            }
963
            for(; i < nb_cargs; i++) {
964
                if (k != 0)
965
                    fprintf(outfile, ",");
966
                arg = args[k++];
967
                fprintf(outfile, "$0x%" TCG_PRIlx, arg);
968
            }
969
        }
970
        fprintf(outfile, "\n");
971
        args += nb_iargs + nb_oargs + nb_cargs;
972
    }
973
}
974

    
975
/* we give more priority to constraints with less registers */
976
static int get_constraint_priority(const TCGOpDef *def, int k)
977
{
978
    const TCGArgConstraint *arg_ct;
979

    
980
    int i, n;
981
    arg_ct = &def->args_ct[k];
982
    if (arg_ct->ct & TCG_CT_ALIAS) {
983
        /* an alias is equivalent to a single register */
984
        n = 1;
985
    } else {
986
        if (!(arg_ct->ct & TCG_CT_REG))
987
            return 0;
988
        n = 0;
989
        for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
990
            if (tcg_regset_test_reg(arg_ct->u.regs, i))
991
                n++;
992
        }
993
    }
994
    return TCG_TARGET_NB_REGS - n + 1;
995
}
996

    
997
/* sort from highest priority to lowest */
998
static void sort_constraints(TCGOpDef *def, int start, int n)
999
{
1000
    int i, j, p1, p2, tmp;
1001

    
1002
    for(i = 0; i < n; i++)
1003
        def->sorted_args[start + i] = start + i;
1004
    if (n <= 1)
1005
        return;
1006
    for(i = 0; i < n - 1; i++) {
1007
        for(j = i + 1; j < n; j++) {
1008
            p1 = get_constraint_priority(def, def->sorted_args[start + i]);
1009
            p2 = get_constraint_priority(def, def->sorted_args[start + j]);
1010
            if (p1 < p2) {
1011
                tmp = def->sorted_args[start + i];
1012
                def->sorted_args[start + i] = def->sorted_args[start + j];
1013
                def->sorted_args[start + j] = tmp;
1014
            }
1015
        }
1016
    }
1017
}
1018

    
1019
void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs)
1020
{
1021
    TCGOpcode op;
1022
    TCGOpDef *def;
1023
    const char *ct_str;
1024
    int i, nb_args;
1025

    
1026
    for(;;) {
1027
        if (tdefs->op == (TCGOpcode)-1)
1028
            break;
1029
        op = tdefs->op;
1030
        assert(op >= 0 && op < NB_OPS);
1031
        def = &tcg_op_defs[op];
1032
#if defined(CONFIG_DEBUG_TCG)
1033
        /* Duplicate entry in op definitions? */
1034
        assert(!def->used);
1035
        def->used = 1;
1036
#endif
1037
        nb_args = def->nb_iargs + def->nb_oargs;
1038
        for(i = 0; i < nb_args; i++) {
1039
            ct_str = tdefs->args_ct_str[i];
1040
            /* Incomplete TCGTargetOpDef entry? */
1041
            assert(ct_str != NULL);
1042
            tcg_regset_clear(def->args_ct[i].u.regs);
1043
            def->args_ct[i].ct = 0;
1044
            if (ct_str[0] >= '0' && ct_str[0] <= '9') {
1045
                int oarg;
1046
                oarg = ct_str[0] - '0';
1047
                assert(oarg < def->nb_oargs);
1048
                assert(def->args_ct[oarg].ct & TCG_CT_REG);
1049
                /* TCG_CT_ALIAS is for the output arguments. The input
1050
                   argument is tagged with TCG_CT_IALIAS. */
1051
                def->args_ct[i] = def->args_ct[oarg];
1052
                def->args_ct[oarg].ct = TCG_CT_ALIAS;
1053
                def->args_ct[oarg].alias_index = i;
1054
                def->args_ct[i].ct |= TCG_CT_IALIAS;
1055
                def->args_ct[i].alias_index = oarg;
1056
            } else {
1057
                for(;;) {
1058
                    if (*ct_str == '\0')
1059
                        break;
1060
                    switch(*ct_str) {
1061
                    case 'i':
1062
                        def->args_ct[i].ct |= TCG_CT_CONST;
1063
                        ct_str++;
1064
                        break;
1065
                    default:
1066
                        if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) {
1067
                            fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n",
1068
                                    ct_str, i, def->name);
1069
                            exit(1);
1070
                        }
1071
                    }
1072
                }
1073
            }
1074
        }
1075

    
1076
        /* TCGTargetOpDef entry with too much information? */
1077
        assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL);
1078

    
1079
        /* sort the constraints (XXX: this is just an heuristic) */
1080
        sort_constraints(def, 0, def->nb_oargs);
1081
        sort_constraints(def, def->nb_oargs, def->nb_iargs);
1082

    
1083
#if 0
1084
        {
1085
            int i;
1086

1087
            printf("%s: sorted=", def->name);
1088
            for(i = 0; i < def->nb_oargs + def->nb_iargs; i++)
1089
                printf(" %d", def->sorted_args[i]);
1090
            printf("\n");
1091
        }
1092
#endif
1093
        tdefs++;
1094
    }
1095

    
1096
#if defined(CONFIG_DEBUG_TCG)
1097
    i = 0;
1098
    for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) {
1099
        if (op < INDEX_op_call || op == INDEX_op_debug_insn_start) {
1100
            /* Wrong entry in op definitions? */
1101
            if (tcg_op_defs[op].used) {
1102
                fprintf(stderr, "Invalid op definition for %s\n",
1103
                        tcg_op_defs[op].name);
1104
                i = 1;
1105
            }
1106
        } else {
1107
            /* Missing entry in op definitions? */
1108
            if (!tcg_op_defs[op].used) {
1109
                fprintf(stderr, "Missing op definition for %s\n",
1110
                        tcg_op_defs[op].name);
1111
                i = 1;
1112
            }
1113
        }
1114
    }
1115
    if (i == 1) {
1116
        tcg_abort();
1117
    }
1118
#endif
1119
}
1120

    
1121
#ifdef USE_LIVENESS_ANALYSIS
1122

    
1123
/* set a nop for an operation using 'nb_args' */
1124
static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 
1125
                               TCGArg *args, int nb_args)
1126
{
1127
    if (nb_args == 0) {
1128
        *opc_ptr = INDEX_op_nop;
1129
    } else {
1130
        *opc_ptr = INDEX_op_nopn;
1131
        args[0] = nb_args;
1132
        args[nb_args - 1] = nb_args;
1133
    }
1134
}
1135

    
1136
/* liveness analysis: end of function: globals are live, temps are
1137
   dead. */
1138
/* XXX: at this stage, not used as there would be little gains because
1139
   most TBs end with a conditional jump. */
1140
static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps)
1141
{
1142
    memset(dead_temps, 0, s->nb_globals);
1143
    memset(dead_temps + s->nb_globals, 1, s->nb_temps - s->nb_globals);
1144
}
1145

    
1146
/* liveness analysis: end of basic block: globals are live, temps are
1147
   dead, local temps are live. */
1148
static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps)
1149
{
1150
    int i;
1151
    TCGTemp *ts;
1152

    
1153
    memset(dead_temps, 0, s->nb_globals);
1154
    ts = &s->temps[s->nb_globals];
1155
    for(i = s->nb_globals; i < s->nb_temps; i++) {
1156
        if (ts->temp_local)
1157
            dead_temps[i] = 0;
1158
        else
1159
            dead_temps[i] = 1;
1160
        ts++;
1161
    }
1162
}
1163

    
1164
/* Liveness analysis : update the opc_dead_iargs array to tell if a
1165
   given input arguments is dead. Instructions updating dead
1166
   temporaries are removed. */
1167
static void tcg_liveness_analysis(TCGContext *s)
1168
{
1169
    int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops;
1170
    TCGOpcode op;
1171
    TCGArg *args;
1172
    const TCGOpDef *def;
1173
    uint8_t *dead_temps;
1174
    unsigned int dead_iargs;
1175
    
1176
    gen_opc_ptr++; /* skip end */
1177

    
1178
    nb_ops = gen_opc_ptr - gen_opc_buf;
1179

    
1180
    s->op_dead_iargs = tcg_malloc(nb_ops * sizeof(uint16_t));
1181
    
1182
    dead_temps = tcg_malloc(s->nb_temps);
1183
    memset(dead_temps, 1, s->nb_temps);
1184

    
1185
    args = gen_opparam_ptr;
1186
    op_index = nb_ops - 1;
1187
    while (op_index >= 0) {
1188
        op = gen_opc_buf[op_index];
1189
        def = &tcg_op_defs[op];
1190
        switch(op) {
1191
        case INDEX_op_call:
1192
            {
1193
                int call_flags;
1194

    
1195
                nb_args = args[-1];
1196
                args -= nb_args;
1197
                nb_iargs = args[0] & 0xffff;
1198
                nb_oargs = args[0] >> 16;
1199
                args++;
1200
                call_flags = args[nb_oargs + nb_iargs];
1201

    
1202
                /* pure functions can be removed if their result is not
1203
                   used */
1204
                if (call_flags & TCG_CALL_PURE) {
1205
                    for(i = 0; i < nb_oargs; i++) {
1206
                        arg = args[i];
1207
                        if (!dead_temps[arg])
1208
                            goto do_not_remove_call;
1209
                    }
1210
                    tcg_set_nop(s, gen_opc_buf + op_index, 
1211
                                args - 1, nb_args);
1212
                } else {
1213
                do_not_remove_call:
1214

    
1215
                    /* output args are dead */
1216
                    for(i = 0; i < nb_oargs; i++) {
1217
                        arg = args[i];
1218
                        dead_temps[arg] = 1;
1219
                    }
1220
                    
1221
                    if (!(call_flags & TCG_CALL_CONST)) {
1222
                        /* globals are live (they may be used by the call) */
1223
                        memset(dead_temps, 0, s->nb_globals);
1224
                    }
1225

    
1226
                    /* input args are live */
1227
                    dead_iargs = 0;
1228
                    for(i = 0; i < nb_iargs; i++) {
1229
                        arg = args[i + nb_oargs];
1230
                        if (arg != TCG_CALL_DUMMY_ARG) {
1231
                            if (dead_temps[arg]) {
1232
                                dead_iargs |= (1 << i);
1233
                            }
1234
                            dead_temps[arg] = 0;
1235
                        }
1236
                    }
1237
                    s->op_dead_iargs[op_index] = dead_iargs;
1238
                }
1239
                args--;
1240
            }
1241
            break;
1242
        case INDEX_op_set_label:
1243
            args--;
1244
            /* mark end of basic block */
1245
            tcg_la_bb_end(s, dead_temps);
1246
            break;
1247
        case INDEX_op_debug_insn_start:
1248
            args -= def->nb_args;
1249
            break;
1250
        case INDEX_op_nopn:
1251
            nb_args = args[-1];
1252
            args -= nb_args;
1253
            break;
1254
        case INDEX_op_discard:
1255
            args--;
1256
            /* mark the temporary as dead */
1257
            dead_temps[args[0]] = 1;
1258
            break;
1259
        case INDEX_op_end:
1260
            break;
1261
            /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */
1262
        default:
1263
            args -= def->nb_args;
1264
            nb_iargs = def->nb_iargs;
1265
            nb_oargs = def->nb_oargs;
1266

    
1267
            /* Test if the operation can be removed because all
1268
               its outputs are dead. We assume that nb_oargs == 0
1269
               implies side effects */
1270
            if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) {
1271
                for(i = 0; i < nb_oargs; i++) {
1272
                    arg = args[i];
1273
                    if (!dead_temps[arg])
1274
                        goto do_not_remove;
1275
                }
1276
                tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args);
1277
#ifdef CONFIG_PROFILER
1278
                s->del_op_count++;
1279
#endif
1280
            } else {
1281
            do_not_remove:
1282

    
1283
                /* output args are dead */
1284
                for(i = 0; i < nb_oargs; i++) {
1285
                    arg = args[i];
1286
                    dead_temps[arg] = 1;
1287
                }
1288

    
1289
                /* if end of basic block, update */
1290
                if (def->flags & TCG_OPF_BB_END) {
1291
                    tcg_la_bb_end(s, dead_temps);
1292
                } else if (def->flags & TCG_OPF_CALL_CLOBBER) {
1293
                    /* globals are live */
1294
                    memset(dead_temps, 0, s->nb_globals);
1295
                }
1296

    
1297
                /* input args are live */
1298
                dead_iargs = 0;
1299
                for(i = 0; i < nb_iargs; i++) {
1300
                    arg = args[i + nb_oargs];
1301
                    if (dead_temps[arg]) {
1302
                        dead_iargs |= (1 << i);
1303
                    }
1304
                    dead_temps[arg] = 0;
1305
                }
1306
                s->op_dead_iargs[op_index] = dead_iargs;
1307
            }
1308
            break;
1309
        }
1310
        op_index--;
1311
    }
1312

    
1313
    if (args != gen_opparam_buf)
1314
        tcg_abort();
1315
}
1316
#else
1317
/* dummy liveness analysis */
1318
static void tcg_liveness_analysis(TCGContext *s)
1319
{
1320
    int nb_ops;
1321
    nb_ops = gen_opc_ptr - gen_opc_buf;
1322

    
1323
    s->op_dead_iargs = tcg_malloc(nb_ops * sizeof(uint16_t));
1324
    memset(s->op_dead_iargs, 0, nb_ops * sizeof(uint16_t));
1325
}
1326
#endif
1327

    
1328
#ifndef NDEBUG
1329
static void dump_regs(TCGContext *s)
1330
{
1331
    TCGTemp *ts;
1332
    int i;
1333
    char buf[64];
1334

    
1335
    for(i = 0; i < s->nb_temps; i++) {
1336
        ts = &s->temps[i];
1337
        printf("  %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i));
1338
        switch(ts->val_type) {
1339
        case TEMP_VAL_REG:
1340
            printf("%s", tcg_target_reg_names[ts->reg]);
1341
            break;
1342
        case TEMP_VAL_MEM:
1343
            printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]);
1344
            break;
1345
        case TEMP_VAL_CONST:
1346
            printf("$0x%" TCG_PRIlx, ts->val);
1347
            break;
1348
        case TEMP_VAL_DEAD:
1349
            printf("D");
1350
            break;
1351
        default:
1352
            printf("???");
1353
            break;
1354
        }
1355
        printf("\n");
1356
    }
1357

    
1358
    for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
1359
        if (s->reg_to_temp[i] >= 0) {
1360
            printf("%s: %s\n", 
1361
                   tcg_target_reg_names[i], 
1362
                   tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i]));
1363
        }
1364
    }
1365
}
1366

    
1367
static void check_regs(TCGContext *s)
1368
{
1369
    int reg, k;
1370
    TCGTemp *ts;
1371
    char buf[64];
1372

    
1373
    for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
1374
        k = s->reg_to_temp[reg];
1375
        if (k >= 0) {
1376
            ts = &s->temps[k];
1377
            if (ts->val_type != TEMP_VAL_REG ||
1378
                ts->reg != reg) {
1379
                printf("Inconsistency for register %s:\n", 
1380
                       tcg_target_reg_names[reg]);
1381
                goto fail;
1382
            }
1383
        }
1384
    }
1385
    for(k = 0; k < s->nb_temps; k++) {
1386
        ts = &s->temps[k];
1387
        if (ts->val_type == TEMP_VAL_REG &&
1388
            !ts->fixed_reg &&
1389
            s->reg_to_temp[ts->reg] != k) {
1390
                printf("Inconsistency for temp %s:\n", 
1391
                       tcg_get_arg_str_idx(s, buf, sizeof(buf), k));
1392
        fail:
1393
                printf("reg state:\n");
1394
                dump_regs(s);
1395
                tcg_abort();
1396
        }
1397
    }
1398
}
1399
#endif
1400

    
1401
static void temp_allocate_frame(TCGContext *s, int temp)
1402
{
1403
    TCGTemp *ts;
1404
    ts = &s->temps[temp];
1405
    s->current_frame_offset = (s->current_frame_offset + sizeof(tcg_target_long) - 1) & ~(sizeof(tcg_target_long) - 1);
1406
    if (s->current_frame_offset + sizeof(tcg_target_long) > s->frame_end)
1407
        tcg_abort();
1408
    ts->mem_offset = s->current_frame_offset;
1409
    ts->mem_reg = s->frame_reg;
1410
    ts->mem_allocated = 1;
1411
    s->current_frame_offset += sizeof(tcg_target_long);
1412
}
1413

    
1414
/* free register 'reg' by spilling the corresponding temporary if necessary */
1415
static void tcg_reg_free(TCGContext *s, int reg)
1416
{
1417
    TCGTemp *ts;
1418
    int temp;
1419

    
1420
    temp = s->reg_to_temp[reg];
1421
    if (temp != -1) {
1422
        ts = &s->temps[temp];
1423
        assert(ts->val_type == TEMP_VAL_REG);
1424
        if (!ts->mem_coherent) {
1425
            if (!ts->mem_allocated) 
1426
                temp_allocate_frame(s, temp);
1427
            tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1428
        }
1429
        ts->val_type = TEMP_VAL_MEM;
1430
        s->reg_to_temp[reg] = -1;
1431
    }
1432
}
1433

    
1434
/* Allocate a register belonging to reg1 & ~reg2 */
1435
static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2)
1436
{
1437
    int i, reg;
1438
    TCGRegSet reg_ct;
1439

    
1440
    tcg_regset_andnot(reg_ct, reg1, reg2);
1441

    
1442
    /* first try free registers */
1443
    for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) {
1444
        reg = tcg_target_reg_alloc_order[i];
1445
        if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1)
1446
            return reg;
1447
    }
1448

    
1449
    /* XXX: do better spill choice */
1450
    for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) {
1451
        reg = tcg_target_reg_alloc_order[i];
1452
        if (tcg_regset_test_reg(reg_ct, reg)) {
1453
            tcg_reg_free(s, reg);
1454
            return reg;
1455
        }
1456
    }
1457

    
1458
    tcg_abort();
1459
}
1460

    
1461
/* save a temporary to memory. 'allocated_regs' is used in case a
1462
   temporary registers needs to be allocated to store a constant. */
1463
static void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs)
1464
{
1465
    TCGTemp *ts;
1466
    int reg;
1467

    
1468
    ts = &s->temps[temp];
1469
    if (!ts->fixed_reg) {
1470
        switch(ts->val_type) {
1471
        case TEMP_VAL_REG:
1472
            tcg_reg_free(s, ts->reg);
1473
            break;
1474
        case TEMP_VAL_DEAD:
1475
            ts->val_type = TEMP_VAL_MEM;
1476
            break;
1477
        case TEMP_VAL_CONST:
1478
            reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
1479
                                allocated_regs);
1480
            if (!ts->mem_allocated) 
1481
                temp_allocate_frame(s, temp);
1482
            tcg_out_movi(s, ts->type, reg, ts->val);
1483
            tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1484
            ts->val_type = TEMP_VAL_MEM;
1485
            break;
1486
        case TEMP_VAL_MEM:
1487
            break;
1488
        default:
1489
            tcg_abort();
1490
        }
1491
    }
1492
}
1493

    
1494
/* save globals to their cannonical location and assume they can be
1495
   modified be the following code. 'allocated_regs' is used in case a
1496
   temporary registers needs to be allocated to store a constant. */
1497
static void save_globals(TCGContext *s, TCGRegSet allocated_regs)
1498
{
1499
    int i;
1500

    
1501
    for(i = 0; i < s->nb_globals; i++) {
1502
        temp_save(s, i, allocated_regs);
1503
    }
1504
}
1505

    
1506
/* at the end of a basic block, we assume all temporaries are dead and
1507
   all globals are stored at their canonical location. */
1508
static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs)
1509
{
1510
    TCGTemp *ts;
1511
    int i;
1512

    
1513
    for(i = s->nb_globals; i < s->nb_temps; i++) {
1514
        ts = &s->temps[i];
1515
        if (ts->temp_local) {
1516
            temp_save(s, i, allocated_regs);
1517
        } else {
1518
            if (ts->val_type == TEMP_VAL_REG) {
1519
                s->reg_to_temp[ts->reg] = -1;
1520
            }
1521
            ts->val_type = TEMP_VAL_DEAD;
1522
        }
1523
    }
1524

    
1525
    save_globals(s, allocated_regs);
1526
}
1527

    
1528
#define IS_DEAD_IARG(n) ((dead_iargs >> (n)) & 1)
1529

    
1530
static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args)
1531
{
1532
    TCGTemp *ots;
1533
    tcg_target_ulong val;
1534

    
1535
    ots = &s->temps[args[0]];
1536
    val = args[1];
1537

    
1538
    if (ots->fixed_reg) {
1539
        /* for fixed registers, we do not do any constant
1540
           propagation */
1541
        tcg_out_movi(s, ots->type, ots->reg, val);
1542
    } else {
1543
        /* The movi is not explicitly generated here */
1544
        if (ots->val_type == TEMP_VAL_REG)
1545
            s->reg_to_temp[ots->reg] = -1;
1546
        ots->val_type = TEMP_VAL_CONST;
1547
        ots->val = val;
1548
    }
1549
}
1550

    
1551
static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def,
1552
                              const TCGArg *args,
1553
                              unsigned int dead_iargs)
1554
{
1555
    TCGTemp *ts, *ots;
1556
    int reg;
1557
    const TCGArgConstraint *arg_ct;
1558

    
1559
    ots = &s->temps[args[0]];
1560
    ts = &s->temps[args[1]];
1561
    arg_ct = &def->args_ct[0];
1562

    
1563
    /* XXX: always mark arg dead if IS_DEAD_IARG(0) */
1564
    if (ts->val_type == TEMP_VAL_REG) {
1565
        if (IS_DEAD_IARG(0) && !ts->fixed_reg && !ots->fixed_reg) {
1566
            /* the mov can be suppressed */
1567
            if (ots->val_type == TEMP_VAL_REG)
1568
                s->reg_to_temp[ots->reg] = -1;
1569
            reg = ts->reg;
1570
            s->reg_to_temp[reg] = -1;
1571
            ts->val_type = TEMP_VAL_DEAD;
1572
        } else {
1573
            if (ots->val_type == TEMP_VAL_REG) {
1574
                reg = ots->reg;
1575
            } else {
1576
                reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs);
1577
            }
1578
            if (ts->reg != reg) {
1579
                tcg_out_mov(s, ots->type, reg, ts->reg);
1580
            }
1581
        }
1582
    } else if (ts->val_type == TEMP_VAL_MEM) {
1583
        if (ots->val_type == TEMP_VAL_REG) {
1584
            reg = ots->reg;
1585
        } else {
1586
            reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs);
1587
        }
1588
        tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1589
    } else if (ts->val_type == TEMP_VAL_CONST) {
1590
        if (ots->fixed_reg) {
1591
            reg = ots->reg;
1592
            tcg_out_movi(s, ots->type, reg, ts->val);
1593
        } else {
1594
            /* propagate constant */
1595
            if (ots->val_type == TEMP_VAL_REG)
1596
                s->reg_to_temp[ots->reg] = -1;
1597
            ots->val_type = TEMP_VAL_CONST;
1598
            ots->val = ts->val;
1599
            return;
1600
        }
1601
    } else {
1602
        tcg_abort();
1603
    }
1604
    s->reg_to_temp[reg] = args[0];
1605
    ots->reg = reg;
1606
    ots->val_type = TEMP_VAL_REG;
1607
    ots->mem_coherent = 0;
1608
}
1609

    
1610
static void tcg_reg_alloc_op(TCGContext *s, 
1611
                             const TCGOpDef *def, TCGOpcode opc,
1612
                             const TCGArg *args,
1613
                             unsigned int dead_iargs)
1614
{
1615
    TCGRegSet allocated_regs;
1616
    int i, k, nb_iargs, nb_oargs, reg;
1617
    TCGArg arg;
1618
    const TCGArgConstraint *arg_ct;
1619
    TCGTemp *ts;
1620
    TCGArg new_args[TCG_MAX_OP_ARGS];
1621
    int const_args[TCG_MAX_OP_ARGS];
1622

    
1623
    nb_oargs = def->nb_oargs;
1624
    nb_iargs = def->nb_iargs;
1625

    
1626
    /* copy constants */
1627
    memcpy(new_args + nb_oargs + nb_iargs, 
1628
           args + nb_oargs + nb_iargs, 
1629
           sizeof(TCGArg) * def->nb_cargs);
1630

    
1631
    /* satisfy input constraints */ 
1632
    tcg_regset_set(allocated_regs, s->reserved_regs);
1633
    for(k = 0; k < nb_iargs; k++) {
1634
        i = def->sorted_args[nb_oargs + k];
1635
        arg = args[i];
1636
        arg_ct = &def->args_ct[i];
1637
        ts = &s->temps[arg];
1638
        if (ts->val_type == TEMP_VAL_MEM) {
1639
            reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1640
            tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1641
            ts->val_type = TEMP_VAL_REG;
1642
            ts->reg = reg;
1643
            ts->mem_coherent = 1;
1644
            s->reg_to_temp[reg] = arg;
1645
        } else if (ts->val_type == TEMP_VAL_CONST) {
1646
            if (tcg_target_const_match(ts->val, arg_ct)) {
1647
                /* constant is OK for instruction */
1648
                const_args[i] = 1;
1649
                new_args[i] = ts->val;
1650
                goto iarg_end;
1651
            } else {
1652
                /* need to move to a register */
1653
                reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1654
                tcg_out_movi(s, ts->type, reg, ts->val);
1655
                ts->val_type = TEMP_VAL_REG;
1656
                ts->reg = reg;
1657
                ts->mem_coherent = 0;
1658
                s->reg_to_temp[reg] = arg;
1659
            }
1660
        }
1661
        assert(ts->val_type == TEMP_VAL_REG);
1662
        if (arg_ct->ct & TCG_CT_IALIAS) {
1663
            if (ts->fixed_reg) {
1664
                /* if fixed register, we must allocate a new register
1665
                   if the alias is not the same register */
1666
                if (arg != args[arg_ct->alias_index])
1667
                    goto allocate_in_reg;
1668
            } else {
1669
                /* if the input is aliased to an output and if it is
1670
                   not dead after the instruction, we must allocate
1671
                   a new register and move it */
1672
                if (!IS_DEAD_IARG(i - nb_oargs)) 
1673
                    goto allocate_in_reg;
1674
            }
1675
        }
1676
        reg = ts->reg;
1677
        if (tcg_regset_test_reg(arg_ct->u.regs, reg)) {
1678
            /* nothing to do : the constraint is satisfied */
1679
        } else {
1680
        allocate_in_reg:
1681
            /* allocate a new register matching the constraint 
1682
               and move the temporary register into it */
1683
            reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1684
            tcg_out_mov(s, ts->type, reg, ts->reg);
1685
        }
1686
        new_args[i] = reg;
1687
        const_args[i] = 0;
1688
        tcg_regset_set_reg(allocated_regs, reg);
1689
    iarg_end: ;
1690
    }
1691
    
1692
    if (def->flags & TCG_OPF_BB_END) {
1693
        tcg_reg_alloc_bb_end(s, allocated_regs);
1694
    } else {
1695
        /* mark dead temporaries and free the associated registers */
1696
        for(i = 0; i < nb_iargs; i++) {
1697
            arg = args[nb_oargs + i];
1698
            if (IS_DEAD_IARG(i)) {
1699
                ts = &s->temps[arg];
1700
                if (!ts->fixed_reg) {
1701
                    if (ts->val_type == TEMP_VAL_REG)
1702
                        s->reg_to_temp[ts->reg] = -1;
1703
                    ts->val_type = TEMP_VAL_DEAD;
1704
                }
1705
            }
1706
        }
1707
        
1708
        if (def->flags & TCG_OPF_CALL_CLOBBER) {
1709
            /* XXX: permit generic clobber register list ? */ 
1710
            for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
1711
                if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) {
1712
                    tcg_reg_free(s, reg);
1713
                }
1714
            }
1715
            /* XXX: for load/store we could do that only for the slow path
1716
               (i.e. when a memory callback is called) */
1717
            
1718
            /* store globals and free associated registers (we assume the insn
1719
               can modify any global. */
1720
            save_globals(s, allocated_regs);
1721
        }
1722
        
1723
        /* satisfy the output constraints */
1724
        tcg_regset_set(allocated_regs, s->reserved_regs);
1725
        for(k = 0; k < nb_oargs; k++) {
1726
            i = def->sorted_args[k];
1727
            arg = args[i];
1728
            arg_ct = &def->args_ct[i];
1729
            ts = &s->temps[arg];
1730
            if (arg_ct->ct & TCG_CT_ALIAS) {
1731
                reg = new_args[arg_ct->alias_index];
1732
            } else {
1733
                /* if fixed register, we try to use it */
1734
                reg = ts->reg;
1735
                if (ts->fixed_reg &&
1736
                    tcg_regset_test_reg(arg_ct->u.regs, reg)) {
1737
                    goto oarg_end;
1738
                }
1739
                reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1740
            }
1741
            tcg_regset_set_reg(allocated_regs, reg);
1742
            /* if a fixed register is used, then a move will be done afterwards */
1743
            if (!ts->fixed_reg) {
1744
                if (ts->val_type == TEMP_VAL_REG)
1745
                    s->reg_to_temp[ts->reg] = -1;
1746
                ts->val_type = TEMP_VAL_REG;
1747
                ts->reg = reg;
1748
                /* temp value is modified, so the value kept in memory is
1749
                   potentially not the same */
1750
                ts->mem_coherent = 0; 
1751
                s->reg_to_temp[reg] = arg;
1752
            }
1753
        oarg_end:
1754
            new_args[i] = reg;
1755
        }
1756
    }
1757

    
1758
    /* emit instruction */
1759
    tcg_out_op(s, opc, new_args, const_args);
1760
    
1761
    /* move the outputs in the correct register if needed */
1762
    for(i = 0; i < nb_oargs; i++) {
1763
        ts = &s->temps[args[i]];
1764
        reg = new_args[i];
1765
        if (ts->fixed_reg && ts->reg != reg) {
1766
            tcg_out_mov(s, ts->type, ts->reg, reg);
1767
        }
1768
    }
1769
}
1770

    
1771
#ifdef TCG_TARGET_STACK_GROWSUP
1772
#define STACK_DIR(x) (-(x))
1773
#else
1774
#define STACK_DIR(x) (x)
1775
#endif
1776

    
1777
static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
1778
                              TCGOpcode opc, const TCGArg *args,
1779
                              unsigned int dead_iargs)
1780
{
1781
    int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params;
1782
    TCGArg arg, func_arg;
1783
    TCGTemp *ts;
1784
    tcg_target_long stack_offset, call_stack_size, func_addr;
1785
    int const_func_arg, allocate_args;
1786
    TCGRegSet allocated_regs;
1787
    const TCGArgConstraint *arg_ct;
1788

    
1789
    arg = *args++;
1790

    
1791
    nb_oargs = arg >> 16;
1792
    nb_iargs = arg & 0xffff;
1793
    nb_params = nb_iargs - 1;
1794

    
1795
    flags = args[nb_oargs + nb_iargs];
1796

    
1797
    nb_regs = tcg_target_get_call_iarg_regs_count(flags);
1798
    if (nb_regs > nb_params)
1799
        nb_regs = nb_params;
1800

    
1801
    /* assign stack slots first */
1802
    /* XXX: preallocate call stack */
1803
    call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long);
1804
    call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 
1805
        ~(TCG_TARGET_STACK_ALIGN - 1);
1806
    allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE);
1807
    if (allocate_args) {
1808
        tcg_out_addi(s, TCG_REG_CALL_STACK, -STACK_DIR(call_stack_size));
1809
    }
1810

    
1811
    stack_offset = TCG_TARGET_CALL_STACK_OFFSET;
1812
    for(i = nb_regs; i < nb_params; i++) {
1813
        arg = args[nb_oargs + i];
1814
#ifdef TCG_TARGET_STACK_GROWSUP
1815
        stack_offset -= sizeof(tcg_target_long);
1816
#endif
1817
        if (arg != TCG_CALL_DUMMY_ARG) {
1818
            ts = &s->temps[arg];
1819
            if (ts->val_type == TEMP_VAL_REG) {
1820
                tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset);
1821
            } else if (ts->val_type == TEMP_VAL_MEM) {
1822
                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
1823
                                    s->reserved_regs);
1824
                /* XXX: not correct if reading values from the stack */
1825
                tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1826
                tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);
1827
            } else if (ts->val_type == TEMP_VAL_CONST) {
1828
                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
1829
                                    s->reserved_regs);
1830
                /* XXX: sign extend may be needed on some targets */
1831
                tcg_out_movi(s, ts->type, reg, ts->val);
1832
                tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);
1833
            } else {
1834
                tcg_abort();
1835
            }
1836
        }
1837
#ifndef TCG_TARGET_STACK_GROWSUP
1838
        stack_offset += sizeof(tcg_target_long);
1839
#endif
1840
    }
1841
    
1842
    /* assign input registers */
1843
    tcg_regset_set(allocated_regs, s->reserved_regs);
1844
    for(i = 0; i < nb_regs; i++) {
1845
        arg = args[nb_oargs + i];
1846
        if (arg != TCG_CALL_DUMMY_ARG) {
1847
            ts = &s->temps[arg];
1848
            reg = tcg_target_call_iarg_regs[i];
1849
            tcg_reg_free(s, reg);
1850
            if (ts->val_type == TEMP_VAL_REG) {
1851
                if (ts->reg != reg) {
1852
                    tcg_out_mov(s, ts->type, reg, ts->reg);
1853
                }
1854
            } else if (ts->val_type == TEMP_VAL_MEM) {
1855
                tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1856
            } else if (ts->val_type == TEMP_VAL_CONST) {
1857
                /* XXX: sign extend ? */
1858
                tcg_out_movi(s, ts->type, reg, ts->val);
1859
            } else {
1860
                tcg_abort();
1861
            }
1862
            tcg_regset_set_reg(allocated_regs, reg);
1863
        }
1864
    }
1865
    
1866
    /* assign function address */
1867
    func_arg = args[nb_oargs + nb_iargs - 1];
1868
    arg_ct = &def->args_ct[0];
1869
    ts = &s->temps[func_arg];
1870
    func_addr = ts->val;
1871
    const_func_arg = 0;
1872
    if (ts->val_type == TEMP_VAL_MEM) {
1873
        reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1874
        tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
1875
        func_arg = reg;
1876
        tcg_regset_set_reg(allocated_regs, reg);
1877
    } else if (ts->val_type == TEMP_VAL_REG) {
1878
        reg = ts->reg;
1879
        if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) {
1880
            reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1881
            tcg_out_mov(s, ts->type, reg, ts->reg);
1882
        }
1883
        func_arg = reg;
1884
        tcg_regset_set_reg(allocated_regs, reg);
1885
    } else if (ts->val_type == TEMP_VAL_CONST) {
1886
        if (tcg_target_const_match(func_addr, arg_ct)) {
1887
            const_func_arg = 1;
1888
            func_arg = func_addr;
1889
        } else {
1890
            reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
1891
            tcg_out_movi(s, ts->type, reg, func_addr);
1892
            func_arg = reg;
1893
            tcg_regset_set_reg(allocated_regs, reg);
1894
        }
1895
    } else {
1896
        tcg_abort();
1897
    }
1898
        
1899
    
1900
    /* mark dead temporaries and free the associated registers */
1901
    for(i = 0; i < nb_iargs; i++) {
1902
        arg = args[nb_oargs + i];
1903
        if (IS_DEAD_IARG(i)) {
1904
            ts = &s->temps[arg];
1905
            if (!ts->fixed_reg) {
1906
                if (ts->val_type == TEMP_VAL_REG)
1907
                    s->reg_to_temp[ts->reg] = -1;
1908
                ts->val_type = TEMP_VAL_DEAD;
1909
            }
1910
        }
1911
    }
1912
    
1913
    /* clobber call registers */
1914
    for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
1915
        if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) {
1916
            tcg_reg_free(s, reg);
1917
        }
1918
    }
1919
    
1920
    /* store globals and free associated registers (we assume the call
1921
       can modify any global. */
1922
    if (!(flags & TCG_CALL_CONST)) {
1923
        save_globals(s, allocated_regs);
1924
    }
1925

    
1926
    tcg_out_op(s, opc, &func_arg, &const_func_arg);
1927
    
1928
    if (allocate_args) {
1929
        tcg_out_addi(s, TCG_REG_CALL_STACK, STACK_DIR(call_stack_size));
1930
    }
1931

    
1932
    /* assign output registers and emit moves if needed */
1933
    for(i = 0; i < nb_oargs; i++) {
1934
        arg = args[i];
1935
        ts = &s->temps[arg];
1936
        reg = tcg_target_call_oarg_regs[i];
1937
        assert(s->reg_to_temp[reg] == -1);
1938
        if (ts->fixed_reg) {
1939
            if (ts->reg != reg) {
1940
                tcg_out_mov(s, ts->type, ts->reg, reg);
1941
            }
1942
        } else {
1943
            if (ts->val_type == TEMP_VAL_REG)
1944
                s->reg_to_temp[ts->reg] = -1;
1945
            ts->val_type = TEMP_VAL_REG;
1946
            ts->reg = reg;
1947
            ts->mem_coherent = 0; 
1948
            s->reg_to_temp[reg] = arg;
1949
        }
1950
    }
1951
    
1952
    return nb_iargs + nb_oargs + def->nb_cargs + 1;
1953
}
1954

    
1955
#ifdef CONFIG_PROFILER
1956

    
1957
static int64_t tcg_table_op_count[NB_OPS];
1958

    
1959
static void dump_op_count(void)
1960
{
1961
    int i;
1962
    FILE *f;
1963
    f = fopen("/tmp/op.log", "w");
1964
    for(i = INDEX_op_end; i < NB_OPS; i++) {
1965
        fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]);
1966
    }
1967
    fclose(f);
1968
}
1969
#endif
1970

    
1971

    
1972
static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
1973
                                      long search_pc)
1974
{
1975
    TCGOpcode opc;
1976
    int op_index;
1977
    const TCGOpDef *def;
1978
    unsigned int dead_iargs;
1979
    const TCGArg *args;
1980

    
1981
#ifdef DEBUG_DISAS
1982
    if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
1983
        qemu_log("OP:\n");
1984
        tcg_dump_ops(s, logfile);
1985
        qemu_log("\n");
1986
    }
1987
#endif
1988

    
1989
#ifdef CONFIG_PROFILER
1990
    s->la_time -= profile_getclock();
1991
#endif
1992
    tcg_liveness_analysis(s);
1993
#ifdef CONFIG_PROFILER
1994
    s->la_time += profile_getclock();
1995
#endif
1996

    
1997
#ifdef DEBUG_DISAS
1998
    if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) {
1999
        qemu_log("OP after liveness analysis:\n");
2000
        tcg_dump_ops(s, logfile);
2001
        qemu_log("\n");
2002
    }
2003
#endif
2004

    
2005
    tcg_reg_alloc_start(s);
2006

    
2007
    s->code_buf = gen_code_buf;
2008
    s->code_ptr = gen_code_buf;
2009

    
2010
    args = gen_opparam_buf;
2011
    op_index = 0;
2012

    
2013
    for(;;) {
2014
        opc = gen_opc_buf[op_index];
2015
#ifdef CONFIG_PROFILER
2016
        tcg_table_op_count[opc]++;
2017
#endif
2018
        def = &tcg_op_defs[opc];
2019
#if 0
2020
        printf("%s: %d %d %d\n", def->name,
2021
               def->nb_oargs, def->nb_iargs, def->nb_cargs);
2022
        //        dump_regs(s);
2023
#endif
2024
        switch(opc) {
2025
        case INDEX_op_mov_i32:
2026
#if TCG_TARGET_REG_BITS == 64
2027
        case INDEX_op_mov_i64:
2028
#endif
2029
            dead_iargs = s->op_dead_iargs[op_index];
2030
            tcg_reg_alloc_mov(s, def, args, dead_iargs);
2031
            break;
2032
        case INDEX_op_movi_i32:
2033
#if TCG_TARGET_REG_BITS == 64
2034
        case INDEX_op_movi_i64:
2035
#endif
2036
            tcg_reg_alloc_movi(s, args);
2037
            break;
2038
        case INDEX_op_debug_insn_start:
2039
            /* debug instruction */
2040
            break;
2041
        case INDEX_op_nop:
2042
        case INDEX_op_nop1:
2043
        case INDEX_op_nop2:
2044
        case INDEX_op_nop3:
2045
            break;
2046
        case INDEX_op_nopn:
2047
            args += args[0];
2048
            goto next;
2049
        case INDEX_op_discard:
2050
            {
2051
                TCGTemp *ts;
2052
                ts = &s->temps[args[0]];
2053
                /* mark the temporary as dead */
2054
                if (!ts->fixed_reg) {
2055
                    if (ts->val_type == TEMP_VAL_REG)
2056
                        s->reg_to_temp[ts->reg] = -1;
2057
                    ts->val_type = TEMP_VAL_DEAD;
2058
                }
2059
            }
2060
            break;
2061
        case INDEX_op_set_label:
2062
            tcg_reg_alloc_bb_end(s, s->reserved_regs);
2063
            tcg_out_label(s, args[0], (long)s->code_ptr);
2064
            break;
2065
        case INDEX_op_call:
2066
            dead_iargs = s->op_dead_iargs[op_index];
2067
            args += tcg_reg_alloc_call(s, def, opc, args, dead_iargs);
2068
            goto next;
2069
        case INDEX_op_end:
2070
            goto the_end;
2071
        default:
2072
            /* Note: in order to speed up the code, it would be much
2073
               faster to have specialized register allocator functions for
2074
               some common argument patterns */
2075
            dead_iargs = s->op_dead_iargs[op_index];
2076
            tcg_reg_alloc_op(s, def, opc, args, dead_iargs);
2077
            break;
2078
        }
2079
        args += def->nb_args;
2080
    next:
2081
        if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) {
2082
            return op_index;
2083
        }
2084
        op_index++;
2085
#ifndef NDEBUG
2086
        check_regs(s);
2087
#endif
2088
    }
2089
 the_end:
2090
    return -1;
2091
}
2092

    
2093
int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
2094
{
2095
#ifdef CONFIG_PROFILER
2096
    {
2097
        int n;
2098
        n = (gen_opc_ptr - gen_opc_buf);
2099
        s->op_count += n;
2100
        if (n > s->op_count_max)
2101
            s->op_count_max = n;
2102

    
2103
        s->temp_count += s->nb_temps;
2104
        if (s->nb_temps > s->temp_count_max)
2105
            s->temp_count_max = s->nb_temps;
2106
    }
2107
#endif
2108

    
2109
    tcg_gen_code_common(s, gen_code_buf, -1);
2110

    
2111
    /* flush instruction cache */
2112
    flush_icache_range((unsigned long)gen_code_buf, 
2113
                       (unsigned long)s->code_ptr);
2114
    return s->code_ptr -  gen_code_buf;
2115
}
2116

    
2117
/* Return the index of the micro operation such as the pc after is <
2118
   offset bytes from the start of the TB.  The contents of gen_code_buf must
2119
   not be changed, though writing the same values is ok.
2120
   Return -1 if not found. */
2121
int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset)
2122
{
2123
    return tcg_gen_code_common(s, gen_code_buf, offset);
2124
}
2125

    
2126
#ifdef CONFIG_PROFILER
2127
void tcg_dump_info(FILE *f,
2128
                   int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
2129
{
2130
    TCGContext *s = &tcg_ctx;
2131
    int64_t tot;
2132

    
2133
    tot = s->interm_time + s->code_time;
2134
    cpu_fprintf(f, "JIT cycles          %" PRId64 " (%0.3f s at 2.4 GHz)\n",
2135
                tot, tot / 2.4e9);
2136
    cpu_fprintf(f, "translated TBs      %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 
2137
                s->tb_count, 
2138
                s->tb_count1 - s->tb_count,
2139
                s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0);
2140
    cpu_fprintf(f, "avg ops/TB          %0.1f max=%d\n", 
2141
                s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max);
2142
    cpu_fprintf(f, "deleted ops/TB      %0.2f\n",
2143
                s->tb_count ? 
2144
                (double)s->del_op_count / s->tb_count : 0);
2145
    cpu_fprintf(f, "avg temps/TB        %0.2f max=%d\n",
2146
                s->tb_count ? 
2147
                (double)s->temp_count / s->tb_count : 0,
2148
                s->temp_count_max);
2149
    
2150
    cpu_fprintf(f, "cycles/op           %0.1f\n", 
2151
                s->op_count ? (double)tot / s->op_count : 0);
2152
    cpu_fprintf(f, "cycles/in byte      %0.1f\n", 
2153
                s->code_in_len ? (double)tot / s->code_in_len : 0);
2154
    cpu_fprintf(f, "cycles/out byte     %0.1f\n", 
2155
                s->code_out_len ? (double)tot / s->code_out_len : 0);
2156
    if (tot == 0)
2157
        tot = 1;
2158
    cpu_fprintf(f, "  gen_interm time   %0.1f%%\n", 
2159
                (double)s->interm_time / tot * 100.0);
2160
    cpu_fprintf(f, "  gen_code time     %0.1f%%\n", 
2161
                (double)s->code_time / tot * 100.0);
2162
    cpu_fprintf(f, "liveness/code time  %0.1f%%\n", 
2163
                (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0);
2164
    cpu_fprintf(f, "cpu_restore count   %" PRId64 "\n",
2165
                s->restore_count);
2166
    cpu_fprintf(f, "  avg cycles        %0.1f\n",
2167
                s->restore_count ? (double)s->restore_time / s->restore_count : 0);
2168

    
2169
    dump_op_count();
2170
}
2171
#else
2172
void tcg_dump_info(FILE *f,
2173
                   int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
2174
{
2175
    cpu_fprintf(f, "[TCG profiler not compiled]\n");
2176
}
2177
#endif