qdev/prop: convert sparc32_dma.c to helper macros.

[qemu.git] / tcg / tcg.c

diff --git a/tcg/tcg.c b/tcg/tcg.c
index c5a8dafb12c7b997f2b8237380670186bc7ade32..93066e2495b3c1b39f1d480c78e25c07636ad771 100644 (file)
--- a/tcg/tcg.c
+++ b/tcg/tcg.c
@@ -22,13 +22,16 @@
  * THE SOFTWARE.
  */
 
  * THE SOFTWARE.
  */
 

-/* define it to suppress various consistency checks (faster) */
-#define NDEBUG
-

 /* define it to use liveness analysis (better code) */
 #define USE_LIVENESS_ANALYSIS
 
 /* define it to use liveness analysis (better code) */
 #define USE_LIVENESS_ANALYSIS
 

-#include <assert.h>
+#include "config.h"
+
+#ifndef CONFIG_DEBUG_TCG
+/* define it to suppress various consistency checks (faster) */
+#define NDEBUG
+#endif
+

 #include <stdarg.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <stdio.h>


@@ -37,9 +40,13 @@
 #ifdef _WIN32
 #include <malloc.h>
 #endif
 #ifdef _WIN32
 #include <malloc.h>
 #endif

+#ifdef _AIX
+#include <alloca.h>
+#endif

 
 

-#include "config.h"

 #include "qemu-common.h"
 #include "qemu-common.h"

+#include "cache-utils.h"
+#include "host-utils.h"

 
 /* Note: the long term plan is to reduce the dependancies on the QEMU
    CPU definitions. Currently they are used for qemu_ld/st
 
 /* Note: the long term plan is to reduce the dependancies on the QEMU
    CPU definitions. Currently they are used for qemu_ld/st


@@ -51,11 +58,14 @@
 #include "tcg-op.h"
 #include "elf.h"
 
 #include "tcg-op.h"
 #include "elf.h"
 

+#if defined(CONFIG_USE_GUEST_BASE) && !defined(TCG_TARGET_HAS_GUEST_BASE)
+#error GUEST_BASE not supported on this host.
+#endif

 
 static void patch_reloc(uint8_t *code_ptr, int type, 
                         tcg_target_long value, tcg_target_long addend);
 
 
 static void patch_reloc(uint8_t *code_ptr, int type, 
                         tcg_target_long value, tcg_target_long addend);
 

-TCGOpDef tcg_op_defs[] = {
+static TCGOpDef tcg_op_defs[] = {

 #define DEF(s, n, copy_size) { #s, 0, 0, n, n, 0, copy_size },
 #define DEF2(s, iargs, oargs, cargs, flags) { #s, iargs, oargs, cargs, iargs + oargs + cargs, flags, 0 },
 #include "tcg-opc.h"
 #define DEF(s, n, copy_size) { #s, 0, 0, n, n, 0, copy_size },
 #define DEF2(s, iargs, oargs, cargs, flags) { #s, iargs, oargs, cargs, iargs + oargs + cargs, flags, 0 },
 #include "tcg-opc.h"


@@ -63,8 +73,8 @@ TCGOpDef tcg_op_defs[] = {
 #undef DEF2
 };
 
 #undef DEF2
 };
 

-TCGRegSet tcg_target_available_regs[2];
-TCGRegSet tcg_target_call_clobber_regs;
+static TCGRegSet tcg_target_available_regs[2];
+static TCGRegSet tcg_target_call_clobber_regs;

 
 /* XXX: move that inside the context */
 uint16_t *gen_opc_ptr;
 
 /* XXX: move that inside the context */
 uint16_t *gen_opc_ptr;


@@ -196,19 +206,6 @@ void tcg_pool_reset(TCGContext *s)
     s->pool_current = NULL;
 }
 
     s->pool_current = NULL;
 }
 

-/* free all the pool */
-void tcg_pool_free(TCGContext *s)
-{
-    TCGPool *p, *p1;
-
-    for(p = s->pool_first; p != NULL; p = p1) {
-        p1 = p->next;
-        qemu_free(p);
-    }
-    s->pool_first = NULL;
-    s->pool_cur = s->pool_end = NULL;
-}
-

 void tcg_context_init(TCGContext *s)
 {
     int op, total_args, n;
 void tcg_context_init(TCGContext *s)
 {
     int op, total_args, n;


@@ -259,15 +256,13 @@ void tcg_set_frame(TCGContext *s, int reg,
     s->frame_reg = reg;
 }
 
     s->frame_reg = reg;
 }
 

-void tcg_set_macro_func(TCGContext *s, TCGMacroFunc *func)
-{
-    s->macro_func = func;
-}
-

 void tcg_func_start(TCGContext *s)
 {
 void tcg_func_start(TCGContext *s)
 {

+    int i;

     tcg_pool_reset(s);
     s->nb_temps = s->nb_globals;
     tcg_pool_reset(s);
     s->nb_temps = s->nb_globals;

+    for(i = 0; i < (TCG_TYPE_COUNT * 2); i++)
+        s->first_free_temp[i] = -1;

     s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS);
     s->nb_labels = 0;
     s->current_frame_offset = s->frame_start;
     s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS);
     s->nb_labels = 0;
     s->current_frame_offset = s->frame_start;


@@ -282,7 +277,8 @@ static inline void tcg_temp_alloc(TCGContext *s, int n)
         tcg_abort();
 }
 
         tcg_abort();
 }
 

-TCGv tcg_global_reg_new(TCGType type, int reg, const char *name)
+static inline int tcg_global_reg_new_internal(TCGType type, int reg,
+                                              const char *name)

 {
     TCGContext *s = &tcg_ctx;
     TCGTemp *ts;
 {
     TCGContext *s = &tcg_ctx;
     TCGTemp *ts;


@@ -301,15 +297,31 @@ TCGv tcg_global_reg_new(TCGType type, int reg, const char *name)
     ts->type = type;
     ts->fixed_reg = 1;
     ts->reg = reg;
     ts->type = type;
     ts->fixed_reg = 1;
     ts->reg = reg;

-    ts->val_type = TEMP_VAL_REG;

     ts->name = name;
     s->nb_globals++;
     tcg_regset_set_reg(s->reserved_regs, reg);
     ts->name = name;
     s->nb_globals++;
     tcg_regset_set_reg(s->reserved_regs, reg);

-    return MAKE_TCGV(idx);
+    return idx;
+}
+
+TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name)
+{
+    int idx;
+
+    idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name);
+    return MAKE_TCGV_I32(idx);
+}
+
+TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name)
+{
+    int idx;
+
+    idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name);
+    return MAKE_TCGV_I64(idx);

 }
 
 }
 

-TCGv tcg_global_mem_new(TCGType type, int reg, tcg_target_long offset,
-                        const char *name)
+static inline int tcg_global_mem_new_internal(TCGType type, int reg,
+                                              tcg_target_long offset,
+                                              const char *name)

 {
     TCGContext *s = &tcg_ctx;
     TCGTemp *ts;
 {
     TCGContext *s = &tcg_ctx;
     TCGTemp *ts;


@@ -319,7 +331,7 @@ TCGv tcg_global_mem_new(TCGType type, int reg, tcg_target_long offset,
 #if TCG_TARGET_REG_BITS == 32
     if (type == TCG_TYPE_I64) {
         char buf[64];
 #if TCG_TARGET_REG_BITS == 32
     if (type == TCG_TYPE_I64) {
         char buf[64];

-        tcg_temp_alloc(s, s->nb_globals + 1);
+        tcg_temp_alloc(s, s->nb_globals + 2);

         ts = &s->temps[s->nb_globals];
         ts->base_type = type;
         ts->type = TCG_TYPE_I32;
         ts = &s->temps[s->nb_globals];
         ts->base_type = type;
         ts->type = TCG_TYPE_I32;


@@ -331,7 +343,6 @@ TCGv tcg_global_mem_new(TCGType type, int reg, tcg_target_long offset,
 #else
         ts->mem_offset = offset;
 #endif
 #else
         ts->mem_offset = offset;
 #endif

-        ts->val_type = TEMP_VAL_MEM;

         pstrcpy(buf, sizeof(buf), name);
         pstrcat(buf, sizeof(buf), "_0");
         ts->name = strdup(buf);
         pstrcpy(buf, sizeof(buf), name);
         pstrcat(buf, sizeof(buf), "_0");
         ts->name = strdup(buf);


@@ -347,7 +358,6 @@ TCGv tcg_global_mem_new(TCGType type, int reg, tcg_target_long offset,
 #else
         ts->mem_offset = offset + 4;
 #endif
 #else
         ts->mem_offset = offset + 4;
 #endif

-        ts->val_type = TEMP_VAL_MEM;

         pstrcpy(buf, sizeof(buf), name);
         pstrcat(buf, sizeof(buf), "_1");
         ts->name = strdup(buf);
         pstrcpy(buf, sizeof(buf), name);
         pstrcat(buf, sizeof(buf), "_1");
         ts->name = strdup(buf);


@@ -364,103 +374,154 @@ TCGv tcg_global_mem_new(TCGType type, int reg, tcg_target_long offset,
         ts->mem_allocated = 1;
         ts->mem_reg = reg;
         ts->mem_offset = offset;
         ts->mem_allocated = 1;
         ts->mem_reg = reg;
         ts->mem_offset = offset;

-        ts->val_type = TEMP_VAL_MEM;

         ts->name = name;
         s->nb_globals++;
     }
         ts->name = name;
         s->nb_globals++;
     }

-    return MAKE_TCGV(idx);
+    return idx;

 }
 
 }
 

-TCGv tcg_temp_new(TCGType type)
+TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset,
+                                const char *name)

 {
 {

-    TCGContext *s = &tcg_ctx;
-    TCGTemp *ts;

     int idx;
 
     int idx;
 

-    idx = s->nb_temps;
+    idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name);
+    return MAKE_TCGV_I32(idx);
+}
+
+TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset,
+                                const char *name)
+{
+    int idx;
+
+    idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name);
+    return MAKE_TCGV_I64(idx);
+}
+
+static inline int tcg_temp_new_internal(TCGType type, int temp_local)
+{
+    TCGContext *s = &tcg_ctx;
+    TCGTemp *ts;
+    int idx, k;
+
+    k = type;
+    if (temp_local)
+        k += TCG_TYPE_COUNT;
+    idx = s->first_free_temp[k];
+    if (idx != -1) {
+        /* There is already an available temp with the
+           right type */
+        ts = &s->temps[idx];
+        s->first_free_temp[k] = ts->next_free_temp;
+        ts->temp_allocated = 1;
+        assert(ts->temp_local == temp_local);
+    } else {
+        idx = s->nb_temps;

 #if TCG_TARGET_REG_BITS == 32
 #if TCG_TARGET_REG_BITS == 32

-    if (type == TCG_TYPE_I64) {
-        tcg_temp_alloc(s, s->nb_temps + 1);
-        ts = &s->temps[s->nb_temps];
-        ts->base_type = type;
-        ts->type = TCG_TYPE_I32;
-        ts->fixed_reg = 0;
-        ts->val_type = TEMP_VAL_DEAD;
-        ts->mem_allocated = 0;
-        ts->name = NULL;
-        ts++;
-        ts->base_type = TCG_TYPE_I32;
-        ts->type = TCG_TYPE_I32;
-        ts->val_type = TEMP_VAL_DEAD;
-        ts->fixed_reg = 0;
-        ts->mem_allocated = 0;
-        ts->name = NULL;
-        s->nb_temps += 2;
-    } else
+        if (type == TCG_TYPE_I64) {
+            tcg_temp_alloc(s, s->nb_temps + 2);
+            ts = &s->temps[s->nb_temps];
+            ts->base_type = type;
+            ts->type = TCG_TYPE_I32;
+            ts->temp_allocated = 1;
+            ts->temp_local = temp_local;
+            ts->name = NULL;
+            ts++;
+            ts->base_type = TCG_TYPE_I32;
+            ts->type = TCG_TYPE_I32;
+            ts->temp_allocated = 1;
+            ts->temp_local = temp_local;
+            ts->name = NULL;
+            s->nb_temps += 2;
+        } else

 #endif
 #endif

-    {
-        tcg_temp_alloc(s, s->nb_temps + 1);
-        ts = &s->temps[s->nb_temps];
-        ts->base_type = type;
-        ts->type = type;
-        ts->fixed_reg = 0;
-        ts->val_type = TEMP_VAL_DEAD;
-        ts->mem_allocated = 0;
-        ts->name = NULL;
-        s->nb_temps++;
+        {
+            tcg_temp_alloc(s, s->nb_temps + 1);
+            ts = &s->temps[s->nb_temps];
+            ts->base_type = type;
+            ts->type = type;
+            ts->temp_allocated = 1;
+            ts->temp_local = temp_local;
+            ts->name = NULL;
+            s->nb_temps++;
+        }

     }
     }

-    return MAKE_TCGV(idx);
+    return idx;

 }
 
 }
 

-TCGv tcg_const_i32(int32_t val)
+TCGv_i32 tcg_temp_new_internal_i32(int temp_local)

 {
 {

-    TCGContext *s = &tcg_ctx;
-    TCGTemp *ts;

     int idx;
 
     int idx;
 

-    idx = s->nb_temps;
-    tcg_temp_alloc(s, idx + 1);
-    ts = &s->temps[idx];
-    ts->base_type = ts->type = TCG_TYPE_I32;
-    ts->val_type = TEMP_VAL_CONST;
-    ts->name = NULL;
-    ts->val = val;
-    s->nb_temps++;
-    return MAKE_TCGV(idx);
+    idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local);
+    return MAKE_TCGV_I32(idx);
+}
+
+TCGv_i64 tcg_temp_new_internal_i64(int temp_local)
+{
+    int idx;
+
+    idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local);
+    return MAKE_TCGV_I64(idx);

 }
 
 }
 

-TCGv tcg_const_i64(int64_t val)
+static inline void tcg_temp_free_internal(int idx)

 {
     TCGContext *s = &tcg_ctx;
     TCGTemp *ts;
 {
     TCGContext *s = &tcg_ctx;
     TCGTemp *ts;

-    int idx;
+    int k;

 
 

-    idx = s->nb_temps;
-#if TCG_TARGET_REG_BITS == 32
-    tcg_temp_alloc(s, idx + 2);
-    ts = &s->temps[idx];
-    ts->base_type = TCG_TYPE_I64;
-    ts->type = TCG_TYPE_I32;
-    ts->val_type = TEMP_VAL_CONST;
-    ts->name = NULL;
-    ts->val = val;
-    ts++;
-    ts->base_type = TCG_TYPE_I32;
-    ts->type = TCG_TYPE_I32;
-    ts->val_type = TEMP_VAL_CONST;
-    ts->name = NULL;
-    ts->val = val >> 32;
-    s->nb_temps += 2;
-#else
-    tcg_temp_alloc(s, idx + 1);
+    assert(idx >= s->nb_globals && idx < s->nb_temps);

     ts = &s->temps[idx];
     ts = &s->temps[idx];

-    ts->base_type = ts->type = TCG_TYPE_I64;
-    ts->val_type = TEMP_VAL_CONST;
-    ts->name = NULL;
-    ts->val = val;
-    s->nb_temps++;
-#endif    
-    return MAKE_TCGV(idx);
+    assert(ts->temp_allocated != 0);
+    ts->temp_allocated = 0;
+    k = ts->base_type;
+    if (ts->temp_local)
+        k += TCG_TYPE_COUNT;
+    ts->next_free_temp = s->first_free_temp[k];
+    s->first_free_temp[k] = idx;
+}
+
+void tcg_temp_free_i32(TCGv_i32 arg)
+{
+    tcg_temp_free_internal(GET_TCGV_I32(arg));
+}
+
+void tcg_temp_free_i64(TCGv_i64 arg)
+{
+    tcg_temp_free_internal(GET_TCGV_I64(arg));
+}
+
+TCGv_i32 tcg_const_i32(int32_t val)
+{
+    TCGv_i32 t0;
+    t0 = tcg_temp_new_i32();
+    tcg_gen_movi_i32(t0, val);
+    return t0;
+}
+
+TCGv_i64 tcg_const_i64(int64_t val)
+{
+    TCGv_i64 t0;
+    t0 = tcg_temp_new_i64();
+    tcg_gen_movi_i64(t0, val);
+    return t0;
+}
+
+TCGv_i32 tcg_const_local_i32(int32_t val)
+{
+    TCGv_i32 t0;
+    t0 = tcg_temp_local_new_i32();
+    tcg_gen_movi_i32(t0, val);
+    return t0;
+}
+
+TCGv_i64 tcg_const_local_i64(int64_t val)
+{
+    TCGv_i64 t0;
+    t0 = tcg_temp_local_new_i64();
+    tcg_gen_movi_i64(t0, val);
+    return t0;

 }
 
 void tcg_register_helper(void *func, const char *name)
 }
 
 void tcg_register_helper(void *func, const char *name)


@@ -477,155 +538,139 @@ void tcg_register_helper(void *func, const char *name)
         s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo));
         s->allocated_helpers = n;
     }
         s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo));
         s->allocated_helpers = n;
     }

-    s->helpers[s->nb_helpers].func = func;
+    s->helpers[s->nb_helpers].func = (tcg_target_ulong)func;

     s->helpers[s->nb_helpers].name = name;
     s->nb_helpers++;
 }
 
     s->helpers[s->nb_helpers].name = name;
     s->nb_helpers++;
 }
 

-const char *tcg_helper_get_name(TCGContext *s, void *func)
-{
-    int i;
-
-    for(i = 0; i < s->nb_helpers; i++) {
-        if (s->helpers[i].func == func)
-            return s->helpers[i].name;
-    }
-    return NULL;
-}
-
-static inline TCGType tcg_get_base_type(TCGContext *s, TCGv arg)
-{
-    return s->temps[GET_TCGV(arg)].base_type;
-}
-
-static void tcg_gen_call_internal(TCGContext *s, TCGv func, 
-                                  unsigned int flags,
-                                  unsigned int nb_rets, const TCGv *rets,
-                                  unsigned int nb_params, const TCGv *params)
+/* Note: we convert the 64 bit args to 32 bit and do some alignment
+   and endian swap. Maybe it would be better to do the alignment
+   and endian swap in tcg_reg_alloc_call(). */
+void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags,
+                   int sizemask, TCGArg ret, int nargs, TCGArg *args)

 {
 {

+    int call_type;

     int i;
     int i;

+    int real_args;
+    int nb_rets;
+    TCGArg *nparam;

     *gen_opc_ptr++ = INDEX_op_call;
     *gen_opc_ptr++ = INDEX_op_call;

-    *gen_opparam_ptr++ = (nb_rets << 16) | (nb_params + 1);
-    for(i = 0; i < nb_rets; i++) {
-        *gen_opparam_ptr++ = GET_TCGV(rets[i]);
-    }
-    for(i = 0; i < nb_params; i++) {
-        *gen_opparam_ptr++ = GET_TCGV(params[i]);
-    }
-    *gen_opparam_ptr++ = GET_TCGV(func);
-
-    *gen_opparam_ptr++ = flags;
-    /* total parameters, needed to go backward in the instruction stream */
-    *gen_opparam_ptr++ = 1 + nb_rets + nb_params + 3;
-}
-
-
+    nparam = gen_opparam_ptr++;
+    call_type = (flags & TCG_CALL_TYPE_MASK);
+    if (ret != TCG_CALL_DUMMY_ARG) {

 #if TCG_TARGET_REG_BITS < 64
 #if TCG_TARGET_REG_BITS < 64

-/* Note: we convert the 64 bit args to 32 bit */
-void tcg_gen_call(TCGContext *s, TCGv func, unsigned int flags,
-                  unsigned int nb_rets, const TCGv *rets,
-                  unsigned int nb_params, const TCGv *args1)
-{
-    TCGv ret, *args2, rets_2[2], arg;
-    int j, i, call_type;
-
-    if (nb_rets == 1) {
-        ret = rets[0];
-        if (tcg_get_base_type(s, ret) == TCG_TYPE_I64) {
+        if (sizemask & 1) {
+#ifdef TCG_TARGET_WORDS_BIGENDIAN
+            *gen_opparam_ptr++ = ret + 1;
+            *gen_opparam_ptr++ = ret;
+#else
+            *gen_opparam_ptr++ = ret;
+            *gen_opparam_ptr++ = ret + 1;
+#endif

             nb_rets = 2;
             nb_rets = 2;

-            rets_2[0] = ret;
-            rets_2[1] = TCGV_HIGH(ret);
-            rets = rets_2;
+        } else
+#endif
+        {
+            *gen_opparam_ptr++ = ret;
+            nb_rets = 1;

         }
         }

+    } else {
+        nb_rets = 0;

     }
     }

-    args2 = alloca((nb_params * 2) * sizeof(TCGv));
-    j = 0;
-    call_type = (flags & TCG_CALL_TYPE_MASK);
-    for(i = 0; i < nb_params; i++) {
-        arg = args1[i];
-        if (tcg_get_base_type(s, arg) == TCG_TYPE_I64) {
+    real_args = 0;
+    for (i = 0; i < nargs; i++) {
+#if TCG_TARGET_REG_BITS < 64
+        if (sizemask & (2 << i)) {

 #ifdef TCG_TARGET_I386
             /* REGPARM case: if the third parameter is 64 bit, it is
                allocated on the stack */
 #ifdef TCG_TARGET_I386
             /* REGPARM case: if the third parameter is 64 bit, it is
                allocated on the stack */

-            if (j == 2 && call_type == TCG_CALL_TYPE_REGPARM) {
+            if (i == 2 && call_type == TCG_CALL_TYPE_REGPARM) {

                 call_type = TCG_CALL_TYPE_REGPARM_2;
                 flags = (flags & ~TCG_CALL_TYPE_MASK) | call_type;
             }
                 call_type = TCG_CALL_TYPE_REGPARM_2;
                 flags = (flags & ~TCG_CALL_TYPE_MASK) | call_type;
             }

-            args2[j++] = arg;
-            args2[j++] = TCGV_HIGH(arg);
-#else
+#endif
+#ifdef TCG_TARGET_CALL_ALIGN_ARGS
+            /* some targets want aligned 64 bit args */
+            if (real_args & 1) {
+                *gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG;
+                real_args++;
+            }
+#endif

 #ifdef TCG_TARGET_WORDS_BIGENDIAN
 #ifdef TCG_TARGET_WORDS_BIGENDIAN

-            args2[j++] = TCGV_HIGH(arg);
-            args2[j++] = arg;
+            *gen_opparam_ptr++ = args[i] + 1;
+            *gen_opparam_ptr++ = args[i];

 #else
 #else

-            args2[j++] = arg;
-            args2[j++] = TCGV_HIGH(arg);
+            *gen_opparam_ptr++ = args[i];
+            *gen_opparam_ptr++ = args[i] + 1;

 #endif
 #endif

+            real_args += 2;
+        } else

 #endif
 #endif

-        } else {
-            args2[j++] = arg;
+        {
+            *gen_opparam_ptr++ = args[i];
+            real_args++;

         }
     }
         }
     }

-    tcg_gen_call_internal(s, func, flags, 
-                          nb_rets, rets, j, args2);
-}
-#else
-void tcg_gen_call(TCGContext *s, TCGv func, unsigned int flags,
-                  unsigned int nb_rets, const TCGv *rets,
-                  unsigned int nb_params, const TCGv *args1)
-{
-    tcg_gen_call_internal(s, func, flags, 
-                          nb_rets, rets, nb_params, args1);
+    *gen_opparam_ptr++ = GET_TCGV_PTR(func);
+
+    *gen_opparam_ptr++ = flags;
+
+    *nparam = (nb_rets << 16) | (real_args + 1);
+
+    /* total parameters, needed to go backward in the instruction stream */
+    *gen_opparam_ptr++ = 1 + nb_rets + real_args + 3;

 }
 }

-#endif

 
 #if TCG_TARGET_REG_BITS == 32
 
 #if TCG_TARGET_REG_BITS == 32

-void tcg_gen_shifti_i64(TCGv ret, TCGv arg1, 
+void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,

                         int c, int right, int arith)
 {
                         int c, int right, int arith)
 {

-    if (c == 0)
-        return;
-    if (c >= 32) {
+    if (c == 0) {
+        tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1));
+        tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1));
+    } else if (c >= 32) {

         c -= 32;
         if (right) {
             if (arith) {
         c -= 32;
         if (right) {
             if (arith) {

-                tcg_gen_sari_i32(ret, TCGV_HIGH(arg1), c);
+                tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c);

                 tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31);
             } else {
                 tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31);
             } else {

-                tcg_gen_shri_i32(ret, TCGV_HIGH(arg1), c);
+                tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c);

                 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
             }
         } else {
                 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
             }
         } else {

-            tcg_gen_shli_i32(TCGV_HIGH(ret), arg1, c);
-            tcg_gen_movi_i32(ret, 0);
+            tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c);
+            tcg_gen_movi_i32(TCGV_LOW(ret), 0);

         }
     } else {
         }
     } else {

-        TCGv t0, t1;
+        TCGv_i32 t0, t1;

 
 

-        t0 = tcg_temp_new(TCG_TYPE_I32);
-        t1 = tcg_temp_new(TCG_TYPE_I32);
+        t0 = tcg_temp_new_i32();
+        t1 = tcg_temp_new_i32();

         if (right) {
             tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c);
             if (arith)
                 tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c);
         if (right) {
             tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c);
             if (arith)
                 tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c);

-            else 
+            else

                 tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c);
                 tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c);

-            tcg_gen_shri_i32(ret, arg1, c); 
-            tcg_gen_or_i32(ret, ret, t0);
+            tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c);
+            tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0);

             tcg_gen_mov_i32(TCGV_HIGH(ret), t1);
         } else {
             tcg_gen_mov_i32(TCGV_HIGH(ret), t1);
         } else {

-            tcg_gen_shri_i32(t0, arg1, 32 - c);
+            tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c);

             /* Note: ret can be the same as arg1, so we use t1 */
             /* Note: ret can be the same as arg1, so we use t1 */

-            tcg_gen_shli_i32(t1, arg1, c); 
+            tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c);

             tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c);
             tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0);
             tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c);
             tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0);

-            tcg_gen_mov_i32(ret, t1);
+            tcg_gen_mov_i32(TCGV_LOW(ret), t1);

         }
         }

+        tcg_temp_free_i32(t0);
+        tcg_temp_free_i32(t1);

     }
 }
 #endif
 
     }
 }
 #endif
 

-void tcg_reg_alloc_start(TCGContext *s)
+static void tcg_reg_alloc_start(TCGContext *s)

 {
     int i;
     TCGTemp *ts;
 {
     int i;
     TCGTemp *ts;


@@ -637,6 +682,12 @@ void tcg_reg_alloc_start(TCGContext *s)
             ts->val_type = TEMP_VAL_MEM;
         }
     }
             ts->val_type = TEMP_VAL_MEM;
         }
     }

+    for(i = s->nb_globals; i < s->nb_temps; i++) {
+        ts = &s->temps[i];
+        ts->val_type = TEMP_VAL_DEAD;
+        ts->mem_allocated = 0;
+        ts->fixed_reg = 0;
+    }

     for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
         s->reg_to_temp[i] = -1;
     }
     for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
         s->reg_to_temp[i] = -1;
     }


@@ -651,45 +702,122 @@ static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size,
     if (idx < s->nb_globals) {
         pstrcpy(buf, buf_size, ts->name);
     } else {
     if (idx < s->nb_globals) {
         pstrcpy(buf, buf_size, ts->name);
     } else {

-        if (ts->val_type == TEMP_VAL_CONST) {
-            snprintf(buf, buf_size, "$0x%" TCG_PRIlx , ts->val);
-        } else {
+        if (ts->temp_local) 
+            snprintf(buf, buf_size, "loc%d", idx - s->nb_globals);
+        else

             snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals);
             snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals);

-        }

     }
     return buf;
 }
 
     }
     return buf;
 }
 

-char *tcg_get_arg_str(TCGContext *s, char *buf, int buf_size, TCGv arg)
+char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg)
+{
+    return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg));
+}
+
+char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg)

 {
 {

-    return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV(arg));
+    return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg));

 }
 
 }
 

+static int helper_cmp(const void *p1, const void *p2)
+{
+    const TCGHelperInfo *th1 = p1;
+    const TCGHelperInfo *th2 = p2;
+    if (th1->func < th2->func)
+        return -1;
+    else if (th1->func == th2->func)
+        return 0;
+    else
+        return 1;
+}
+
+/* find helper definition (Note: A hash table would be better) */
+static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val)
+{
+    int m, m_min, m_max;
+    TCGHelperInfo *th;
+    tcg_target_ulong v;
+
+    if (unlikely(!s->helpers_sorted)) {
+        qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 
+              helper_cmp);
+        s->helpers_sorted = 1;
+    }
+
+    /* binary search */
+    m_min = 0;
+    m_max = s->nb_helpers - 1;
+    while (m_min <= m_max) {
+        m = (m_min + m_max) >> 1;
+        th = &s->helpers[m];
+        v = th->func;
+        if (v == val)
+            return th;
+        else if (val < v) {
+            m_max = m - 1;
+        } else {
+            m_min = m + 1;
+        }
+    }
+    return NULL;
+}
+
+static const char * const cond_name[] =
+{
+    [TCG_COND_EQ] = "eq",
+    [TCG_COND_NE] = "ne",
+    [TCG_COND_LT] = "lt",
+    [TCG_COND_GE] = "ge",
+    [TCG_COND_LE] = "le",
+    [TCG_COND_GT] = "gt",
+    [TCG_COND_LTU] = "ltu",
+    [TCG_COND_GEU] = "geu",
+    [TCG_COND_LEU] = "leu",
+    [TCG_COND_GTU] = "gtu"
+};
+

 void tcg_dump_ops(TCGContext *s, FILE *outfile)
 {
     const uint16_t *opc_ptr;
     const TCGArg *args;
     TCGArg arg;
 void tcg_dump_ops(TCGContext *s, FILE *outfile)
 {
     const uint16_t *opc_ptr;
     const TCGArg *args;
     TCGArg arg;

-    int c, i, k, nb_oargs, nb_iargs, nb_cargs;
+    int c, i, k, nb_oargs, nb_iargs, nb_cargs, first_insn;

     const TCGOpDef *def;
     char buf[128];
 
     const TCGOpDef *def;
     char buf[128];
 

+    first_insn = 1;

     opc_ptr = gen_opc_buf;
     args = gen_opparam_buf;
     while (opc_ptr < gen_opc_ptr) {
         c = *opc_ptr++;
         def = &tcg_op_defs[c];
     opc_ptr = gen_opc_buf;
     args = gen_opparam_buf;
     while (opc_ptr < gen_opc_ptr) {
         c = *opc_ptr++;
         def = &tcg_op_defs[c];

-        fprintf(outfile, " %s ", def->name);
-        if (c == INDEX_op_call) {
+        if (c == INDEX_op_debug_insn_start) {
+            uint64_t pc;
+#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
+            pc = ((uint64_t)args[1] << 32) | args[0];
+#else
+            pc = args[0];
+#endif
+            if (!first_insn) 
+                fprintf(outfile, "\n");
+            fprintf(outfile, " ---- 0x%" PRIx64, pc);
+            first_insn = 0;
+            nb_oargs = def->nb_oargs;
+            nb_iargs = def->nb_iargs;
+            nb_cargs = def->nb_cargs;
+        } else if (c == INDEX_op_call) {

             TCGArg arg;
             TCGArg arg;

+

             /* variable number of arguments */
             arg = *args++;
             nb_oargs = arg >> 16;
             nb_iargs = arg & 0xffff;
             nb_cargs = def->nb_cargs;
 
             /* variable number of arguments */
             arg = *args++;
             nb_oargs = arg >> 16;
             nb_iargs = arg & 0xffff;
             nb_cargs = def->nb_cargs;
 

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

             /* function name */
             /* function name */

-            /* XXX: dump helper name for call */

             fprintf(outfile, "%s",
                     tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + nb_iargs - 1]));
             /* flags */
             fprintf(outfile, "%s",
                     tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + nb_iargs - 1]));
             /* flags */


@@ -704,10 +832,38 @@ void tcg_dump_ops(TCGContext *s, FILE *outfile)
             }
             for(i = 0; i < (nb_iargs - 1); i++) {
                 fprintf(outfile, ",");
             }
             for(i = 0; i < (nb_iargs - 1); i++) {
                 fprintf(outfile, ",");

-                fprintf(outfile, "%s",
-                        tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + i]));
+                if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) {
+                    fprintf(outfile, "<dummy>");
+                } else {
+                    fprintf(outfile, "%s",
+                            tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + i]));
+                }
+            }
+        } else if (c == INDEX_op_movi_i32 
+#if TCG_TARGET_REG_BITS == 64
+                   || c == INDEX_op_movi_i64
+#endif
+                   ) {
+            tcg_target_ulong val;
+            TCGHelperInfo *th;
+
+            nb_oargs = def->nb_oargs;
+            nb_iargs = def->nb_iargs;
+            nb_cargs = def->nb_cargs;
+            fprintf(outfile, " %s %s,$", def->name, 
+                    tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0]));
+            val = args[1];
+            th = tcg_find_helper(s, val);
+            if (th) {
+                fprintf(outfile, "%s", th->name);
+            } else {
+                if (c == INDEX_op_movi_i32)
+                    fprintf(outfile, "0x%x", (uint32_t)val);
+                else
+                    fprintf(outfile, "0x%" PRIx64 , (uint64_t)val);

             }
         } else {
             }
         } else {

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

             if (c == INDEX_op_nopn) {
                 /* variable number of arguments */
                 nb_cargs = *args;
             if (c == INDEX_op_nopn) {
                 /* variable number of arguments */
                 nb_cargs = *args;


@@ -732,7 +888,22 @@ void tcg_dump_ops(TCGContext *s, FILE *outfile)
                 fprintf(outfile, "%s",
                         tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++]));
             }
                 fprintf(outfile, "%s",
                         tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++]));
             }

-            for(i = 0; i < nb_cargs; i++) {
+            if (c == INDEX_op_brcond_i32
+#if TCG_TARGET_REG_BITS == 32
+                || c == INDEX_op_brcond2_i32
+#elif TCG_TARGET_REG_BITS == 64
+                || c == INDEX_op_brcond_i64
+#endif
+                ) {
+                if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]])
+                    fprintf(outfile, ",%s", cond_name[args[k++]]);
+                else
+                    fprintf(outfile, ",$0x%" TCG_PRIlx, args[k++]);
+                i = 1;
+            }
+            else
+                i = 0;
+            for(; i < nb_cargs; i++) {

                 if (k != 0)
                     fprintf(outfile, ",");
                 arg = args[k++];
                 if (k != 0)
                     fprintf(outfile, ",");
                 arg = args[k++];


@@ -872,17 +1043,38 @@ static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr,
     }
 }
 
     }
 }
 

-/* liveness analysis: end of basic block: globals are live, temps are dead */
-static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps)
+/* liveness analysis: end of function: globals are live, temps are
+   dead. */
+/* XXX: at this stage, not used as there would be little gains because
+   most TBs end with a conditional jump. */
+static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps)

 {
     memset(dead_temps, 0, s->nb_globals);
     memset(dead_temps + s->nb_globals, 1, s->nb_temps - s->nb_globals);
 }
 
 {
     memset(dead_temps, 0, s->nb_globals);
     memset(dead_temps + s->nb_globals, 1, s->nb_temps - s->nb_globals);
 }
 

+/* liveness analysis: end of basic block: globals are live, temps are
+   dead, local temps are live. */
+static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps)
+{
+    int i;
+    TCGTemp *ts;
+
+    memset(dead_temps, 0, s->nb_globals);
+    ts = &s->temps[s->nb_globals];
+    for(i = s->nb_globals; i < s->nb_temps; i++) {
+        if (ts->temp_local)
+            dead_temps[i] = 0;
+        else
+            dead_temps[i] = 1;
+        ts++;
+    }
+}
+

 /* Liveness analysis : update the opc_dead_iargs array to tell if a
    given input arguments is dead. Instructions updating dead
    temporaries are removed. */
 /* Liveness analysis : update the opc_dead_iargs array to tell if a
    given input arguments is dead. Instructions updating dead
    temporaries are removed. */

-void tcg_liveness_analysis(TCGContext *s)
+static void tcg_liveness_analysis(TCGContext *s)

 {
     int i, op_index, op, nb_args, nb_iargs, nb_oargs, arg, nb_ops;
     TCGArg *args;
 {
     int i, op_index, op, nb_args, nb_iargs, nb_oargs, arg, nb_ops;
     TCGArg *args;


@@ -907,38 +1099,64 @@ void tcg_liveness_analysis(TCGContext *s)
         def = &tcg_op_defs[op];
         switch(op) {
         case INDEX_op_call:
         def = &tcg_op_defs[op];
         switch(op) {
         case INDEX_op_call:

-            nb_args = args[-1];
-            args -= nb_args;
-            nb_iargs = args[0] & 0xffff;
-            nb_oargs = args[0] >> 16;
-            args++;
+            {
+                int call_flags;

 
 

-            /* output args are dead */
-            for(i = 0; i < nb_oargs; i++) {
-                arg = args[i];
-                dead_temps[arg] = 1;
-            }
-            
-            /* globals are live (they may be used by the call) */
-            memset(dead_temps, 0, s->nb_globals);
+                nb_args = args[-1];
+                args -= nb_args;
+                nb_iargs = args[0] & 0xffff;
+                nb_oargs = args[0] >> 16;
+                args++;
+                call_flags = args[nb_oargs + nb_iargs];
+
+                /* pure functions can be removed if their result is not
+                   used */
+                if (call_flags & TCG_CALL_PURE) {
+                    for(i = 0; i < nb_oargs; i++) {
+                        arg = args[i];
+                        if (!dead_temps[arg])
+                            goto do_not_remove_call;
+                    }
+                    tcg_set_nop(s, gen_opc_buf + op_index, 
+                                args - 1, nb_args);
+                } else {
+                do_not_remove_call:

 
 

-            /* input args are live */
-            dead_iargs = 0;
-            for(i = 0; i < nb_iargs; i++) {
-                arg = args[i + nb_oargs];
-                if (dead_temps[arg]) {
-                    dead_iargs |= (1 << i);
+                    /* output args are dead */
+                    for(i = 0; i < nb_oargs; i++) {
+                        arg = args[i];
+                        dead_temps[arg] = 1;
+                    }
+                    
+                    if (!(call_flags & TCG_CALL_CONST)) {
+                        /* globals are live (they may be used by the call) */
+                        memset(dead_temps, 0, s->nb_globals);
+                    }
+
+                    /* input args are live */
+                    dead_iargs = 0;
+                    for(i = 0; i < nb_iargs; i++) {
+                        arg = args[i + nb_oargs];
+                        if (arg != TCG_CALL_DUMMY_ARG) {
+                            if (dead_temps[arg]) {
+                                dead_iargs |= (1 << i);
+                            }
+                            dead_temps[arg] = 0;
+                        }
+                    }
+                    s->op_dead_iargs[op_index] = dead_iargs;

                 }
                 }

-                dead_temps[arg] = 0;
+                args--;

             }
             }

-            s->op_dead_iargs[op_index] = dead_iargs;
-            args--;

             break;
         case INDEX_op_set_label:
             args--;
             /* mark end of basic block */
             tcg_la_bb_end(s, dead_temps);
             break;
             break;
         case INDEX_op_set_label:
             args--;
             /* mark end of basic block */
             tcg_la_bb_end(s, dead_temps);
             break;

+        case INDEX_op_debug_insn_start:
+            args -= def->nb_args;
+            break;

         case INDEX_op_nopn:
             nb_args = args[-1];
             args -= nb_args;
         case INDEX_op_nopn:
             nb_args = args[-1];
             args -= nb_args;


@@ -948,134 +1166,54 @@ void tcg_liveness_analysis(TCGContext *s)
             /* mark the temporary as dead */
             dead_temps[args[0]] = 1;
             break;
             /* mark the temporary as dead */
             dead_temps[args[0]] = 1;
             break;

-        case INDEX_op_macro_2:
-            {
-                int dead_args[2], macro_id;
-                int saved_op_index, saved_arg_index;
-                int macro_op_index, macro_arg_index;
-                int macro_end_op_index, macro_end_arg_index;
-                int last_nb_temps;
-                
-                nb_args = 3;
-                args -= nb_args;
-                dead_args[0] = dead_temps[args[0]];
-                dead_args[1] = dead_temps[args[1]];
-                macro_id = args[2];
-
-                /* call the macro function which generate code
-                   depending on the live outputs */
-                saved_op_index = op_index;
-                saved_arg_index = args - gen_opparam_buf;
-
-                /* add a macro start instruction */
-                *gen_opc_ptr++ = INDEX_op_macro_start;
-                *gen_opparam_ptr++ = saved_op_index;
-                *gen_opparam_ptr++ = saved_arg_index;
-
-                macro_op_index = gen_opc_ptr - gen_opc_buf;
-                macro_arg_index = gen_opparam_ptr -  gen_opparam_buf;
-
-                last_nb_temps = s->nb_temps;
-
-                s->macro_func(s, macro_id, dead_args);
-
-                /* realloc temp info (XXX: make it faster) */
-                if (s->nb_temps > last_nb_temps) {
-                    uint8_t *new_dead_temps;
-
-                    new_dead_temps = tcg_malloc(s->nb_temps);
-                    memcpy(new_dead_temps, dead_temps, last_nb_temps);
-                    memset(new_dead_temps + last_nb_temps, 1, 
-                           s->nb_temps - last_nb_temps);
-                    dead_temps = new_dead_temps;
-                }
-
-                macro_end_op_index = gen_opc_ptr - gen_opc_buf;
-                macro_end_arg_index = gen_opparam_ptr - gen_opparam_buf;
-
-                /* end of macro: add a goto to the next instruction */
-                *gen_opc_ptr++ = INDEX_op_macro_end;
-                *gen_opparam_ptr++ = op_index + 1;
-                *gen_opparam_ptr++ = saved_arg_index + nb_args;
-
-                /* modify the macro operation to be a macro_goto */
-                gen_opc_buf[op_index] = INDEX_op_macro_goto;
-                args[0] = macro_op_index;
-                args[1] = macro_arg_index;
-                args[2] = 0; /* dummy third arg to match the 
-                                macro parameters */
-
-                /* set the next instruction to the end of the macro */
-                op_index = macro_end_op_index;
-                args = macro_end_arg_index + gen_opparam_buf;
-            }
-            break;
-        case INDEX_op_macro_start:
-            args -= 2;
-            op_index = args[0];
-            args = gen_opparam_buf + args[1];
-            break;
-        case INDEX_op_macro_goto:
-        case INDEX_op_macro_end:
-            tcg_abort(); /* should never happen in liveness analysis */

         case INDEX_op_end:
             break;
             /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */
         default:
         case INDEX_op_end:
             break;
             /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */
         default:

-            if (op > INDEX_op_end) {
-                args -= def->nb_args;
-                nb_iargs = def->nb_iargs;
-                nb_oargs = def->nb_oargs;
-
-                /* Test if the operation can be removed because all
-                   its outputs are dead. We assume that nb_oargs == 0
-                   implies side effects */
-                if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) {
-                    for(i = 0; i < nb_oargs; i++) {
-                        arg = args[i];
-                        if (!dead_temps[arg])
-                            goto do_not_remove;
-                    }
-                    tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args);
+            args -= def->nb_args;
+            nb_iargs = def->nb_iargs;
+            nb_oargs = def->nb_oargs;
+
+            /* Test if the operation can be removed because all
+               its outputs are dead. We assume that nb_oargs == 0
+               implies side effects */
+            if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) {
+                for(i = 0; i < nb_oargs; i++) {
+                    arg = args[i];
+                    if (!dead_temps[arg])
+                        goto do_not_remove;
+                }
+                tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args);

 #ifdef CONFIG_PROFILER
 #ifdef CONFIG_PROFILER

-                    {
-                        extern int64_t dyngen_tcg_del_op_count;
-                        dyngen_tcg_del_op_count++;
-                    }
+                s->del_op_count++;

 #endif
 #endif

-                } else {
-                do_not_remove:
+            } else {
+            do_not_remove:

 
 

-                    /* output args are dead */
-                    for(i = 0; i < nb_oargs; i++) {
-                        arg = args[i];
-                        dead_temps[arg] = 1;
-                    }
-                    
-                    /* if end of basic block, update */
-                    if (def->flags & TCG_OPF_BB_END) {
-                        tcg_la_bb_end(s, dead_temps);
-                    } else if (def->flags & TCG_OPF_CALL_CLOBBER) {
-                        /* globals are live */
-                        memset(dead_temps, 0, s->nb_globals);
-                    }
-                    
-                    /* input args are live */
-                    dead_iargs = 0;
-                    for(i = 0; i < nb_iargs; i++) {
-                        arg = args[i + nb_oargs];
-                        if (dead_temps[arg]) {
-                            dead_iargs |= (1 << i);
-                        }
-                        dead_temps[arg] = 0;
+                /* output args are dead */
+                for(i = 0; i < nb_oargs; i++) {
+                    arg = args[i];
+                    dead_temps[arg] = 1;
+                }
+
+                /* if end of basic block, update */
+                if (def->flags & TCG_OPF_BB_END) {
+                    tcg_la_bb_end(s, dead_temps);
+                } else if (def->flags & TCG_OPF_CALL_CLOBBER) {
+                    /* globals are live */
+                    memset(dead_temps, 0, s->nb_globals);
+                }
+
+                /* input args are live */
+                dead_iargs = 0;
+                for(i = 0; i < nb_iargs; i++) {
+                    arg = args[i + nb_oargs];
+                    if (dead_temps[arg]) {
+                        dead_iargs |= (1 << i);

                     }
                     }

-                    s->op_dead_iargs[op_index] = dead_iargs;
+                    dead_temps[arg] = 0;

                 }
                 }

-            } else {
-                /* legacy dyngen operations */
-                args -= def->nb_args;
-                /* mark end of basic block */
-                tcg_la_bb_end(s, dead_temps);
+                s->op_dead_iargs[op_index] = dead_iargs;

             }
             break;
         }
             }
             break;
         }


@@ -1166,11 +1304,6 @@ static void check_regs(TCGContext *s)
                 dump_regs(s);
                 tcg_abort();
         }
                 dump_regs(s);
                 tcg_abort();
         }

-        if (ts->val_type == TEMP_VAL_CONST && k < s->nb_globals) {
-            printf("constant forbidden in global %s\n",
-                   tcg_get_arg_str_idx(s, buf, sizeof(buf), k));
-            goto fail;
-        }

     }
 }
 #endif
     }
 }
 #endif


@@ -1235,36 +1368,96 @@ static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2)
     tcg_abort();
 }
 
     tcg_abort();
 }
 

-/* at the end of a basic block, we assume all temporaries are dead and
-   all globals are stored at their canonical location */
-/* XXX: optimize by handling constants in another array ? */
-void tcg_reg_alloc_bb_end(TCGContext *s)
+/* save a temporary to memory. 'allocated_regs' is used in case a
+   temporary registers needs to be allocated to store a constant. */
+static void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs)

 {
     TCGTemp *ts;
 {
     TCGTemp *ts;

+    int reg;
+
+    ts = &s->temps[temp];
+    if (!ts->fixed_reg) {
+        switch(ts->val_type) {
+        case TEMP_VAL_REG:
+            tcg_reg_free(s, ts->reg);
+            break;
+        case TEMP_VAL_DEAD:
+            ts->val_type = TEMP_VAL_MEM;
+            break;
+        case TEMP_VAL_CONST:
+            reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
+                                allocated_regs);
+            if (!ts->mem_allocated) 
+                temp_allocate_frame(s, temp);
+            tcg_out_movi(s, ts->type, reg, ts->val);
+            tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
+            ts->val_type = TEMP_VAL_MEM;
+            break;
+        case TEMP_VAL_MEM:
+            break;
+        default:
+            tcg_abort();
+        }
+    }
+}
+
+/* save globals to their cannonical location and assume they can be
+   modified be the following code. 'allocated_regs' is used in case a
+   temporary registers needs to be allocated to store a constant. */
+static void save_globals(TCGContext *s, TCGRegSet allocated_regs)
+{

     int i;
 
     for(i = 0; i < s->nb_globals; i++) {
     int i;
 
     for(i = 0; i < s->nb_globals; i++) {

-        ts = &s->temps[i];
-        if (!ts->fixed_reg) {
-            if (ts->val_type == TEMP_VAL_REG) {
-                tcg_reg_free(s, ts->reg);
-            }
-        }
+        temp_save(s, i, allocated_regs);

     }
     }

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

 
     for(i = s->nb_globals; i < s->nb_temps; i++) {
         ts = &s->temps[i];
 
     for(i = s->nb_globals; i < s->nb_temps; i++) {
         ts = &s->temps[i];

-        if (ts->val_type != TEMP_VAL_CONST) {
+        if (ts->temp_local) {
+            temp_save(s, i, allocated_regs);
+        } else {

             if (ts->val_type == TEMP_VAL_REG) {
                 s->reg_to_temp[ts->reg] = -1;
             }
             ts->val_type = TEMP_VAL_DEAD;
         }
     }
             if (ts->val_type == TEMP_VAL_REG) {
                 s->reg_to_temp[ts->reg] = -1;
             }
             ts->val_type = TEMP_VAL_DEAD;
         }
     }

+
+    save_globals(s, allocated_regs);

 }
 
 #define IS_DEAD_IARG(n) ((dead_iargs >> (n)) & 1)
 
 }
 
 #define IS_DEAD_IARG(n) ((dead_iargs >> (n)) & 1)
 

+static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args)
+{
+    TCGTemp *ots;
+    tcg_target_ulong val;
+
+    ots = &s->temps[args[0]];
+    val = args[1];
+
+    if (ots->fixed_reg) {
+        /* for fixed registers, we do not do any constant
+           propagation */
+        tcg_out_movi(s, ots->type, ots->reg, val);
+    } else {
+        /* The movi is not explicitly generated here */
+        if (ots->val_type == TEMP_VAL_REG)
+            s->reg_to_temp[ots->reg] = -1;
+        ots->val_type = TEMP_VAL_CONST;
+        ots->val = val;
+    }
+}
+

 static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def,
                               const TCGArg *args,
                               unsigned int dead_iargs)
 static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def,
                               const TCGArg *args,
                               unsigned int dead_iargs)


@@ -1277,6 +1470,7 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def,
     ts = &s->temps[args[1]];
     arg_ct = &def->args_ct[0];
 
     ts = &s->temps[args[1]];
     arg_ct = &def->args_ct[0];
 

+    /* XXX: always mark arg dead if IS_DEAD_IARG(0) */

     if (ts->val_type == TEMP_VAL_REG) {
         if (IS_DEAD_IARG(0) && !ts->fixed_reg && !ots->fixed_reg) {
             /* the mov can be suppressed */
     if (ts->val_type == TEMP_VAL_REG) {
         if (IS_DEAD_IARG(0) && !ts->fixed_reg && !ots->fixed_reg) {
             /* the mov can be suppressed */


@@ -1303,12 +1497,17 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def,
         }
         tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
     } else if (ts->val_type == TEMP_VAL_CONST) {
         }
         tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
     } else if (ts->val_type == TEMP_VAL_CONST) {

-        if (ots->val_type == TEMP_VAL_REG) {
+        if (ots->fixed_reg) {

             reg = ots->reg;
             reg = ots->reg;

+            tcg_out_movi(s, ots->type, reg, ts->val);

         } else {
         } else {

-            reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs);
+            /* propagate constant */
+            if (ots->val_type == TEMP_VAL_REG)
+                s->reg_to_temp[ots->reg] = -1;
+            ots->val_type = TEMP_VAL_CONST;
+            ots->val = ts->val;
+            return;

         }
         }

-        tcg_out_movi(s, ots->type, reg, ts->val);

     } else {
         tcg_abort();
     }
     } else {
         tcg_abort();
     }


@@ -1360,10 +1559,13 @@ static void tcg_reg_alloc_op(TCGContext *s,
                 new_args[i] = ts->val;
                 goto iarg_end;
             } else {
                 new_args[i] = ts->val;
                 goto iarg_end;
             } else {

-                /* need to move to a register*/
+                /* need to move to a register */

                 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
                 tcg_out_movi(s, ts->type, reg, ts->val);
                 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
                 tcg_out_movi(s, ts->type, reg, ts->val);

-                goto iarg_end1;
+                ts->val_type = TEMP_VAL_REG;
+                ts->reg = reg;
+                ts->mem_coherent = 0;
+                s->reg_to_temp[reg] = arg;

             }
         }
         assert(ts->val_type == TEMP_VAL_REG);
             }
         }
         assert(ts->val_type == TEMP_VAL_REG);


@@ -1391,85 +1593,78 @@ static void tcg_reg_alloc_op(TCGContext *s,
             reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
             tcg_out_mov(s, reg, ts->reg);
         }
             reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
             tcg_out_mov(s, reg, ts->reg);
         }

-    iarg_end1:

         new_args[i] = reg;
         const_args[i] = 0;
         tcg_regset_set_reg(allocated_regs, reg);
     iarg_end: ;
     }
     
         new_args[i] = reg;
         const_args[i] = 0;
         tcg_regset_set_reg(allocated_regs, reg);
     iarg_end: ;
     }
     

-    /* mark dead temporaries and free the associated registers */
-    for(i = 0; i < nb_iargs; i++) {
-        arg = args[nb_oargs + i];
-        if (IS_DEAD_IARG(i)) {
-            ts = &s->temps[arg];
-            if (ts->val_type != TEMP_VAL_CONST && !ts->fixed_reg) {
-                if (ts->val_type == TEMP_VAL_REG)
-                    s->reg_to_temp[ts->reg] = -1;
-                ts->val_type = TEMP_VAL_DEAD;
+    if (def->flags & TCG_OPF_BB_END) {
+        tcg_reg_alloc_bb_end(s, allocated_regs);
+    } else {
+        /* mark dead temporaries and free the associated registers */
+        for(i = 0; i < nb_iargs; i++) {
+            arg = args[nb_oargs + i];
+            if (IS_DEAD_IARG(i)) {
+                ts = &s->temps[arg];
+                if (!ts->fixed_reg) {
+                    if (ts->val_type == TEMP_VAL_REG)
+                        s->reg_to_temp[ts->reg] = -1;
+                    ts->val_type = TEMP_VAL_DEAD;
+                }

             }
         }
             }
         }

-    }
-
-    if (def->flags & TCG_OPF_CALL_CLOBBER) {
-        /* XXX: permit generic clobber register list ? */ 
-        for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
-            if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) {
-                tcg_reg_free(s, reg);
+        
+        if (def->flags & TCG_OPF_CALL_CLOBBER) {
+            /* XXX: permit generic clobber register list ? */ 
+            for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
+                if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) {
+                    tcg_reg_free(s, reg);
+                }

             }
             }

+            /* XXX: for load/store we could do that only for the slow path
+               (i.e. when a memory callback is called) */
+            
+            /* store globals and free associated registers (we assume the insn
+               can modify any global. */
+            save_globals(s, allocated_regs);

         }
         }

-        /* XXX: for load/store we could do that only for the slow path
-           (i.e. when a memory callback is called) */
-
-        /* store globals and free associated registers (we assume the insn
-           can modify any global. */
-        for(i = 0; i < s->nb_globals; i++) {
-            ts = &s->temps[i];
-            if (!ts->fixed_reg) {
-                if (ts->val_type == TEMP_VAL_REG) {
-                    tcg_reg_free(s, ts->reg);
+        
+        /* satisfy the output constraints */
+        tcg_regset_set(allocated_regs, s->reserved_regs);
+        for(k = 0; k < nb_oargs; k++) {
+            i = def->sorted_args[k];
+            arg = args[i];
+            arg_ct = &def->args_ct[i];
+            ts = &s->temps[arg];
+            if (arg_ct->ct & TCG_CT_ALIAS) {
+                reg = new_args[arg_ct->alias_index];
+            } else {
+                /* if fixed register, we try to use it */
+                reg = ts->reg;
+                if (ts->fixed_reg &&
+                    tcg_regset_test_reg(arg_ct->u.regs, reg)) {
+                    goto oarg_end;

                 }
                 }

+                reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);

             }
             }

-        }
-    }
-
-    /* satisfy the output constraints */
-    tcg_regset_set(allocated_regs, s->reserved_regs);
-    for(k = 0; k < nb_oargs; k++) {
-        i = def->sorted_args[k];
-        arg = args[i];
-        arg_ct = &def->args_ct[i];
-        ts = &s->temps[arg];
-        if (arg_ct->ct & TCG_CT_ALIAS) {
-            reg = new_args[arg_ct->alias_index];
-        } else {
-            /* if fixed register, we try to use it */
-            reg = ts->reg;
-            if (ts->fixed_reg &&
-                tcg_regset_test_reg(arg_ct->u.regs, reg)) {
-                goto oarg_end;
+            tcg_regset_set_reg(allocated_regs, reg);
+            /* if a fixed register is used, then a move will be done afterwards */
+            if (!ts->fixed_reg) {
+                if (ts->val_type == TEMP_VAL_REG)
+                    s->reg_to_temp[ts->reg] = -1;
+                ts->val_type = TEMP_VAL_REG;
+                ts->reg = reg;
+                /* temp value is modified, so the value kept in memory is
+                   potentially not the same */
+                ts->mem_coherent = 0; 
+                s->reg_to_temp[reg] = arg;

             }
             }

-            reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
-        }
-        tcg_regset_set_reg(allocated_regs, reg);
-        /* if a fixed register is used, then a move will be done afterwards */
-        if (!ts->fixed_reg) {
-            if (ts->val_type == TEMP_VAL_REG)
-                s->reg_to_temp[ts->reg] = -1;
-            ts->val_type = TEMP_VAL_REG;
-            ts->reg = reg;
-            /* temp value is modified, so the value kept in memory is
-               potentially not the same */
-            ts->mem_coherent = 0; 
-            s->reg_to_temp[reg] = arg;
+        oarg_end:
+            new_args[i] = reg;

         }
         }

-    oarg_end:
-        new_args[i] = reg;

     }
 
     }
 

-    if (def->flags & TCG_OPF_BB_END)
-        tcg_reg_alloc_bb_end(s);
-

     /* emit instruction */
     tcg_out_op(s, opc, new_args, const_args);
     
     /* emit instruction */
     tcg_out_op(s, opc, new_args, const_args);
     


@@ -1522,52 +1717,60 @@ static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
     if (allocate_args) {
         tcg_out_addi(s, TCG_REG_CALL_STACK, -STACK_DIR(call_stack_size));
     }
     if (allocate_args) {
         tcg_out_addi(s, TCG_REG_CALL_STACK, -STACK_DIR(call_stack_size));
     }

-    /* XXX: on some architectures it does not start at zero */
-    stack_offset = 0;
+
+    stack_offset = TCG_TARGET_CALL_STACK_OFFSET;

     for(i = nb_regs; i < nb_params; i++) {
         arg = args[nb_oargs + i];
     for(i = nb_regs; i < nb_params; i++) {
         arg = args[nb_oargs + i];

-        ts = &s->temps[arg];
-        if (ts->val_type == TEMP_VAL_REG) {
-            tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset);
-        } else if (ts->val_type == TEMP_VAL_MEM) {
-            reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
-                                s->reserved_regs);
-            /* XXX: not correct if reading values from the stack */
-            tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
-            tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);
-        } else if (ts->val_type == TEMP_VAL_CONST) {
-            reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
-                                s->reserved_regs);
-            /* XXX: sign extend may be needed on some targets */
-            tcg_out_movi(s, ts->type, reg, ts->val);
-            tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);
-        } else {
-            tcg_abort();
+#ifdef TCG_TARGET_STACK_GROWSUP
+        stack_offset -= sizeof(tcg_target_long);
+#endif
+        if (arg != TCG_CALL_DUMMY_ARG) {
+            ts = &s->temps[arg];
+            if (ts->val_type == TEMP_VAL_REG) {
+                tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset);
+            } else if (ts->val_type == TEMP_VAL_MEM) {
+                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
+                                    s->reserved_regs);
+                /* XXX: not correct if reading values from the stack */
+                tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
+                tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);
+            } else if (ts->val_type == TEMP_VAL_CONST) {
+                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
+                                    s->reserved_regs);
+                /* XXX: sign extend may be needed on some targets */
+                tcg_out_movi(s, ts->type, reg, ts->val);
+                tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);
+            } else {
+                tcg_abort();
+            }

         }
         }

-        /* XXX: not necessarily in the same order */
-        stack_offset += STACK_DIR(sizeof(tcg_target_long));
+#ifndef TCG_TARGET_STACK_GROWSUP
+        stack_offset += sizeof(tcg_target_long);
+#endif

     }
     
     /* assign input registers */
     tcg_regset_set(allocated_regs, s->reserved_regs);
     for(i = 0; i < nb_regs; i++) {
         arg = args[nb_oargs + i];
     }
     
     /* assign input registers */
     tcg_regset_set(allocated_regs, s->reserved_regs);
     for(i = 0; i < nb_regs; i++) {
         arg = args[nb_oargs + i];

-        ts = &s->temps[arg];
-        reg = tcg_target_call_iarg_regs[i];
-        tcg_reg_free(s, reg);
-        if (ts->val_type == TEMP_VAL_REG) {
-            if (ts->reg != reg) {
-                tcg_out_mov(s, reg, ts->reg);
+        if (arg != TCG_CALL_DUMMY_ARG) {
+            ts = &s->temps[arg];
+            reg = tcg_target_call_iarg_regs[i];
+            tcg_reg_free(s, reg);
+            if (ts->val_type == TEMP_VAL_REG) {
+                if (ts->reg != reg) {
+                    tcg_out_mov(s, reg, ts->reg);
+                }
+            } else if (ts->val_type == TEMP_VAL_MEM) {
+                tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
+            } else if (ts->val_type == TEMP_VAL_CONST) {
+                /* XXX: sign extend ? */
+                tcg_out_movi(s, ts->type, reg, ts->val);
+            } else {
+                tcg_abort();

             }
             }

-        } else if (ts->val_type == TEMP_VAL_MEM) {
-            tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
-        } else if (ts->val_type == TEMP_VAL_CONST) {
-            /* XXX: sign extend ? */
-            tcg_out_movi(s, ts->type, reg, ts->val);
-        } else {
-            tcg_abort();
+            tcg_regset_set_reg(allocated_regs, reg);

         }
         }

-        tcg_regset_set_reg(allocated_regs, reg);

     }
     
     /* assign function address */
     }
     
     /* assign function address */


@@ -1580,6 +1783,7 @@ static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
         reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
         tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
         func_arg = reg;
         reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
         tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
         func_arg = reg;

+        tcg_regset_set_reg(allocated_regs, reg);

     } else if (ts->val_type == TEMP_VAL_REG) {
         reg = ts->reg;
         if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) {
     } else if (ts->val_type == TEMP_VAL_REG) {
         reg = ts->reg;
         if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) {


@@ -1587,6 +1791,7 @@ static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
             tcg_out_mov(s, reg, ts->reg);
         }
         func_arg = reg;
             tcg_out_mov(s, reg, ts->reg);
         }
         func_arg = reg;

+        tcg_regset_set_reg(allocated_regs, reg);

     } else if (ts->val_type == TEMP_VAL_CONST) {
         if (tcg_target_const_match(func_addr, arg_ct)) {
             const_func_arg = 1;
     } else if (ts->val_type == TEMP_VAL_CONST) {
         if (tcg_target_const_match(func_addr, arg_ct)) {
             const_func_arg = 1;


@@ -1595,17 +1800,19 @@ static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
             reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
             tcg_out_movi(s, ts->type, reg, func_addr);
             func_arg = reg;
             reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
             tcg_out_movi(s, ts->type, reg, func_addr);
             func_arg = reg;

+            tcg_regset_set_reg(allocated_regs, reg);

         }
     } else {
         tcg_abort();
     }
         }
     } else {
         tcg_abort();
     }

+        

     
     /* mark dead temporaries and free the associated registers */
     
     /* mark dead temporaries and free the associated registers */

-    for(i = 0; i < nb_params; i++) {
+    for(i = 0; i < nb_iargs; i++) {

         arg = args[nb_oargs + i];
         if (IS_DEAD_IARG(i)) {
             ts = &s->temps[arg];
         arg = args[nb_oargs + i];
         if (IS_DEAD_IARG(i)) {
             ts = &s->temps[arg];

-            if (ts->val_type != TEMP_VAL_CONST && !ts->fixed_reg) {
+            if (!ts->fixed_reg) {

                 if (ts->val_type == TEMP_VAL_REG)
                     s->reg_to_temp[ts->reg] = -1;
                 ts->val_type = TEMP_VAL_DEAD;
                 if (ts->val_type == TEMP_VAL_REG)
                     s->reg_to_temp[ts->reg] = -1;
                 ts->val_type = TEMP_VAL_DEAD;


@@ -1622,13 +1829,8 @@ static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
     
     /* store globals and free associated registers (we assume the call
        can modify any global. */
     
     /* store globals and free associated registers (we assume the call
        can modify any global. */

-    for(i = 0; i < s->nb_globals; i++) {
-        ts = &s->temps[i];
-        if (!ts->fixed_reg) {
-            if (ts->val_type == TEMP_VAL_REG) {
-                tcg_reg_free(s, ts->reg);
-            }
-        }
+    if (!(flags & TCG_CALL_CONST)) {
+        save_globals(s, allocated_regs);

     }
 
     tcg_out_op(s, opc, &func_arg, &const_func_arg);
     }
 
     tcg_out_op(s, opc, &func_arg, &const_func_arg);


@@ -1642,7 +1844,7 @@ static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
         arg = args[i];
         ts = &s->temps[arg];
         reg = tcg_target_call_oarg_regs[i];
         arg = args[i];
         ts = &s->temps[arg];
         reg = tcg_target_call_oarg_regs[i];

-        tcg_reg_free(s, reg);
+        assert(s->reg_to_temp[reg] == -1);

         if (ts->fixed_reg) {
             if (ts->reg != reg) {
                 tcg_out_mov(s, ts->reg, reg);
         if (ts->fixed_reg) {
             if (ts->reg != reg) {
                 tcg_out_mov(s, ts->reg, reg);


@@ -1662,20 +1864,15 @@ static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
 
 #ifdef CONFIG_PROFILER
 
 
 #ifdef CONFIG_PROFILER
 

-static int64_t dyngen_table_op_count[NB_OPS];
+static int64_t tcg_table_op_count[NB_OPS];

 
 

-void dump_op_count(void)
+static void dump_op_count(void)

 {
     int i;
     FILE *f;
 {
     int i;
     FILE *f;

-    f = fopen("/tmp/op1.log", "w");
-    for(i = 0; i < INDEX_op_end; i++) {
-        fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, dyngen_table_op_count[i]);
-    }
-    fclose(f);
-    f = fopen("/tmp/op2.log", "w");
+    f = fopen("/tmp/op.log", "w");

     for(i = INDEX_op_end; i < NB_OPS; i++) {
     for(i = INDEX_op_end; i < NB_OPS; i++) {

-        fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, dyngen_table_op_count[i]);
+        fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]);

     }
     fclose(f);
 }
     }
     fclose(f);
 }


@@ -1685,26 +1882,32 @@ void dump_op_count(void)
 static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
                                       long search_pc)
 {
 static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
                                       long search_pc)
 {

-    int opc, op_index, macro_op_index;
+    int opc, op_index;

     const TCGOpDef *def;
     unsigned int dead_iargs;
     const TCGArg *args;
 
 #ifdef DEBUG_DISAS
     const TCGOpDef *def;
     unsigned int dead_iargs;
     const TCGArg *args;
 
 #ifdef DEBUG_DISAS

-    if (unlikely(loglevel & CPU_LOG_TB_OP)) {
-        fprintf(logfile, "OP:\n");
+    if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
+        qemu_log("OP:\n");

         tcg_dump_ops(s, logfile);
         tcg_dump_ops(s, logfile);

-        fprintf(logfile, "\n");
+        qemu_log("\n");

     }
 #endif
 
     }
 #endif
 

+#ifdef CONFIG_PROFILER
+    s->la_time -= profile_getclock();
+#endif

     tcg_liveness_analysis(s);
     tcg_liveness_analysis(s);

+#ifdef CONFIG_PROFILER
+    s->la_time += profile_getclock();
+#endif

 
 #ifdef DEBUG_DISAS
 
 #ifdef DEBUG_DISAS

-    if (unlikely(loglevel & CPU_LOG_TB_OP_OPT)) {
-        fprintf(logfile, "OP after la:\n");
+    if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) {
+        qemu_log("OP after la:\n");

         tcg_dump_ops(s, logfile);
         tcg_dump_ops(s, logfile);

-        fprintf(logfile, "\n");
+        qemu_log("\n");

     }
 #endif
 
     }
 #endif
 


@@ -1713,14 +1916,13 @@ static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
     s->code_buf = gen_code_buf;
     s->code_ptr = gen_code_buf;
 
     s->code_buf = gen_code_buf;
     s->code_ptr = gen_code_buf;
 

-    macro_op_index = -1;

     args = gen_opparam_buf;
     op_index = 0;
 
     for(;;) {
         opc = gen_opc_buf[op_index];
 #ifdef CONFIG_PROFILER
     args = gen_opparam_buf;
     op_index = 0;
 
     for(;;) {
         opc = gen_opc_buf[op_index];
 #ifdef CONFIG_PROFILER

-        dyngen_table_op_count[opc]++;
+        tcg_table_op_count[opc]++;

 #endif
         def = &tcg_op_defs[opc];
 #if 0
 #endif
         def = &tcg_op_defs[opc];
 #if 0


@@ -1736,6 +1938,15 @@ static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
             dead_iargs = s->op_dead_iargs[op_index];
             tcg_reg_alloc_mov(s, def, args, dead_iargs);
             break;
             dead_iargs = s->op_dead_iargs[op_index];
             tcg_reg_alloc_mov(s, def, args, dead_iargs);
             break;

+        case INDEX_op_movi_i32:
+#if TCG_TARGET_REG_BITS == 64
+        case INDEX_op_movi_i64:
+#endif
+            tcg_reg_alloc_movi(s, args);
+            break;
+        case INDEX_op_debug_insn_start:
+            /* debug instruction */
+            break;

         case INDEX_op_nop:
         case INDEX_op_nop1:
         case INDEX_op_nop2:
         case INDEX_op_nop:
         case INDEX_op_nop1:
         case INDEX_op_nop2:


@@ -1749,28 +1960,15 @@ static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
                 TCGTemp *ts;
                 ts = &s->temps[args[0]];
                 /* mark the temporary as dead */
                 TCGTemp *ts;
                 ts = &s->temps[args[0]];
                 /* mark the temporary as dead */

-                if (ts->val_type != TEMP_VAL_CONST && !ts->fixed_reg) {
+                if (!ts->fixed_reg) {

                     if (ts->val_type == TEMP_VAL_REG)
                         s->reg_to_temp[ts->reg] = -1;
                     ts->val_type = TEMP_VAL_DEAD;
                 }
             }
             break;
                     if (ts->val_type == TEMP_VAL_REG)
                         s->reg_to_temp[ts->reg] = -1;
                     ts->val_type = TEMP_VAL_DEAD;
                 }
             }
             break;

-        case INDEX_op_macro_goto:
-            macro_op_index = op_index; /* only used for exceptions */
-            op_index = args[0] - 1;
-            args = gen_opparam_buf + args[1];
-            goto next;
-        case INDEX_op_macro_end:
-            macro_op_index = -1; /* only used for exceptions */
-            op_index = args[0] - 1;
-            args = gen_opparam_buf + args[1];
-            goto next;
-        case INDEX_op_macro_start:
-            /* must never happen here */
-            tcg_abort();

         case INDEX_op_set_label:
         case INDEX_op_set_label:

-            tcg_reg_alloc_bb_end(s);
+            tcg_reg_alloc_bb_end(s, s->reserved_regs);

             tcg_out_label(s, args[0], (long)s->code_ptr);
             break;
         case INDEX_op_call:
             tcg_out_label(s, args[0], (long)s->code_ptr);
             break;
         case INDEX_op_call:


@@ -1779,25 +1977,6 @@ static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
             goto next;
         case INDEX_op_end:
             goto the_end;
             goto next;
         case INDEX_op_end:
             goto the_end;

-
-#ifdef CONFIG_DYNGEN_OP
-        case 0 ... INDEX_op_end - 1:
-            /* legacy dyngen ops */
-#ifdef CONFIG_PROFILER
-            {
-                extern int64_t dyngen_old_op_count;
-                dyngen_old_op_count++;
-            }
-#endif
-            tcg_reg_alloc_bb_end(s);
-            if (search_pc >= 0) {
-                s->code_ptr += def->copy_size;
-                args += def->nb_args;
-            } else {
-                args = dyngen_op(s, opc, args);
-            }
-            goto next;
-#endif

         default:
             /* Note: in order to speed up the code, it would be much
                faster to have specialized register allocator functions for
         default:
             /* Note: in order to speed up the code, it would be much
                faster to have specialized register allocator functions for


@@ -1807,12 +1986,9 @@ static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
             break;
         }
         args += def->nb_args;
             break;
         }
         args += def->nb_args;

-    next: ;
+    next:

         if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) {
         if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) {

-            if (macro_op_index >= 0)
-                return macro_op_index;
-            else
-                return op_index;
+            return op_index;

         }
         op_index++;
 #ifndef NDEBUG
         }
         op_index++;
 #ifndef NDEBUG


@@ -1823,17 +1999,19 @@ static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
     return -1;
 }
 
     return -1;
 }
 

-int dyngen_code(TCGContext *s, uint8_t *gen_code_buf)
+int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)

 {
 #ifdef CONFIG_PROFILER
     {
 {
 #ifdef CONFIG_PROFILER
     {

-        extern int64_t dyngen_op_count;
-        extern int dyngen_op_count_max;

         int n;
         n = (gen_opc_ptr - gen_opc_buf);
         int n;
         n = (gen_opc_ptr - gen_opc_buf);

-        dyngen_op_count += n;
-        if (n > dyngen_op_count_max)
-            dyngen_op_count_max = n;
+        s->op_count += n;
+        if (n > s->op_count_max)
+            s->op_count_max = n;
+
+        s->temp_count += s->nb_temps;
+        if (s->nb_temps > s->temp_count_max)
+            s->temp_count_max = s->nb_temps;

     }
 #endif
 
     }
 #endif
 


@@ -1849,7 +2027,60 @@ int dyngen_code(TCGContext *s, uint8_t *gen_code_buf)
    offset bytes from the start of the TB.  The contents of gen_code_buf must
    not be changed, though writing the same values is ok.
    Return -1 if not found. */
    offset bytes from the start of the TB.  The contents of gen_code_buf must
    not be changed, though writing the same values is ok.
    Return -1 if not found. */

-int dyngen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset)
+int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset)

 {
     return tcg_gen_code_common(s, gen_code_buf, offset);
 }
 {
     return tcg_gen_code_common(s, gen_code_buf, offset);
 }

+
+#ifdef CONFIG_PROFILER
+void tcg_dump_info(FILE *f,
+                   int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
+{
+    TCGContext *s = &tcg_ctx;
+    int64_t tot;
+
+    tot = s->interm_time + s->code_time;
+    cpu_fprintf(f, "JIT cycles          %" PRId64 " (%0.3f s at 2.4 GHz)\n",
+                tot, tot / 2.4e9);
+    cpu_fprintf(f, "translated TBs      %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 
+                s->tb_count, 
+                s->tb_count1 - s->tb_count,
+                s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0);
+    cpu_fprintf(f, "avg ops/TB          %0.1f max=%d\n", 
+                s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max);
+    cpu_fprintf(f, "deleted ops/TB      %0.2f\n",
+                s->tb_count ? 
+                (double)s->del_op_count / s->tb_count : 0);
+    cpu_fprintf(f, "avg temps/TB        %0.2f max=%d\n",
+                s->tb_count ? 
+                (double)s->temp_count / s->tb_count : 0,
+                s->temp_count_max);
+    
+    cpu_fprintf(f, "cycles/op           %0.1f\n", 
+                s->op_count ? (double)tot / s->op_count : 0);
+    cpu_fprintf(f, "cycles/in byte      %0.1f\n", 
+                s->code_in_len ? (double)tot / s->code_in_len : 0);
+    cpu_fprintf(f, "cycles/out byte     %0.1f\n", 
+                s->code_out_len ? (double)tot / s->code_out_len : 0);
+    if (tot == 0)
+        tot = 1;
+    cpu_fprintf(f, "  gen_interm time   %0.1f%%\n", 
+                (double)s->interm_time / tot * 100.0);
+    cpu_fprintf(f, "  gen_code time     %0.1f%%\n", 
+                (double)s->code_time / tot * 100.0);
+    cpu_fprintf(f, "liveness/code time  %0.1f%%\n", 
+                (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0);
+    cpu_fprintf(f, "cpu_restore count   %" PRId64 "\n",
+                s->restore_count);
+    cpu_fprintf(f, "  avg cycles        %0.1f\n",
+                s->restore_count ? (double)s->restore_time / s->restore_count : 0);
+
+    dump_op_count();
+}
+#else
+void tcg_dump_info(FILE *f,
+                   int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
+{
+    cpu_fprintf(f, "[TCG profiler not compiled]\n");
+}
+#endif