/ - Diff - qemu - Greek Research and Technology Network's projects

Revision 866cb6cb

+        }
+    }
     /* Liveness analysis : update the opc_dead_iargs array to tell if a
     /* Liveness analysis : update the opc_dead_args array to tell if a
        given input arguments is dead. Instructions updating dead
        temporaries are removed. */
     static void tcg_liveness_analysis(TCGContext *s)
-...
         TCGArg *args;
         const TCGOpDef *def;
         uint8_t *dead_temps;
         unsigned int dead_iargs;
         unsigned int dead_args;
         gen_opc_ptr++; /* skip end */
         nb_ops = gen_opc_ptr - gen_opc_buf;
         s->op_dead_iargs = tcg_malloc(nb_ops * sizeof(uint16_t));
         s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
         dead_temps = tcg_malloc(s->nb_temps);
         memset(dead_temps, 1, s->nb_temps);
-...
+                        }
                         /* input args are live */
                         dead_iargs = 0;
                         for(i = 0; i < nb_iargs; i++) {
                             arg = args[i + nb_oargs];
                         dead_args = 0;
                         for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) {
                             arg = args[i];
                             if (arg != TCG_CALL_DUMMY_ARG) {
                                 if (dead_temps[arg]) {
                                     dead_iargs |= (1 << i);
                                     dead_args |= (1 << i);
+                                }
                                 dead_temps[arg] = 0;
+                            }
+                        }
                         s->op_dead_iargs[op_index] = dead_iargs;
                         s->op_dead_args[op_index] = dead_args;
+                    }
                     args--;
+                }
-...
+                    }
                     /* input args are live */
                     dead_iargs = 0;
                     for(i = 0; i < nb_iargs; i++) {
                         arg = args[i + nb_oargs];
                     dead_args = 0;
                     for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) {
                         arg = args[i];
                         if (dead_temps[arg]) {
                             dead_iargs |= (1 << i);
                             dead_args |= (1 << i);
+                        }
                         dead_temps[arg] = 0;
+                    }
                     s->op_dead_iargs[op_index] = dead_iargs;
                     s->op_dead_args[op_index] = dead_args;
+                }
                 break;
+            }
-...
         int nb_ops;
         nb_ops = gen_opc_ptr - gen_opc_buf;
         s->op_dead_iargs = tcg_malloc(nb_ops * sizeof(uint16_t));
         memset(s->op_dead_iargs, 0, nb_ops * sizeof(uint16_t));
         s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
         memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t));
+    }
     #endif
-...
         save_globals(s, allocated_regs);
+    }
     #define IS_DEAD_IARG(n) ((dead_iargs >> (n)) & 1)
     #define IS_DEAD_ARG(n) ((dead_args >> (n)) & 1)
     static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args)
+    {
-...
     static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def,
                                   const TCGArg *args,
                                   unsigned int dead_iargs)
                                   unsigned int dead_args)
+    {
         TCGTemp *ts, *ots;
         int reg;
-...
         ts = &s->temps[args[1]];
         arg_ct = &def->args_ct[0];
         /* XXX: always mark arg dead if IS_DEAD_IARG(0) */
         /* XXX: always mark arg dead if IS_DEAD_ARG(1) */
         if (ts->val_type == TEMP_VAL_REG) {
             if (IS_DEAD_IARG(0) && !ts->fixed_reg && !ots->fixed_reg) {
             if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) {
                 /* the mov can be suppressed */
                 if (ots->val_type == TEMP_VAL_REG)
                     s->reg_to_temp[ots->reg] = -1;
-...
     static void tcg_reg_alloc_op(TCGContext *s,
                                  const TCGOpDef *def, TCGOpcode opc,
                                  const TCGArg *args,
                                  unsigned int dead_iargs)
                                  unsigned int dead_args)
+    {
         TCGRegSet allocated_regs;
         int i, k, nb_iargs, nb_oargs, reg;
-...
                     /* if the input is aliased to an output and if it is
                        not dead after the instruction, we must allocate
                        a new register and move it */
                     if (!IS_DEAD_IARG(i - nb_oargs))
                     if (!IS_DEAD_ARG(i)) {
                         goto allocate_in_reg;
+                    }
+                }
+            }
             reg = ts->reg;
-...
             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)) {
             for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) {
                 arg = args[i];
                 if (IS_DEAD_ARG(i)) {
                     ts = &s->temps[arg];
                     if (!ts->fixed_reg) {
                         if (ts->val_type == TEMP_VAL_REG)
-...
     static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
                                   TCGOpcode opc, const TCGArg *args,
                                   unsigned int dead_iargs)
                                   unsigned int dead_args)
+    {
         int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params;
         TCGArg arg, func_arg;
-...
         /* 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)) {
         for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) {
             arg = args[i];
             if (IS_DEAD_ARG(i)) {
                 ts = &s->temps[arg];
                 if (!ts->fixed_reg) {
                     if (ts->val_type == TEMP_VAL_REG)
-...
         TCGOpcode opc;
         int op_index;
         const TCGOpDef *def;
         unsigned int dead_iargs;
         unsigned int dead_args;
         const TCGArg *args;
     #ifdef DEBUG_DISAS
-...
     #if TCG_TARGET_REG_BITS == 64
             case INDEX_op_mov_i64:
     #endif
                 dead_iargs = s->op_dead_iargs[op_index];
                 tcg_reg_alloc_mov(s, def, args, dead_iargs);
                 dead_args = s->op_dead_args[op_index];
                 tcg_reg_alloc_mov(s, def, args, dead_args);
                 break;
             case INDEX_op_movi_i32:
     #if TCG_TARGET_REG_BITS == 64
-...
                 tcg_out_label(s, args[0], (long)s->code_ptr);
                 break;
             case INDEX_op_call:
                 dead_iargs = s->op_dead_iargs[op_index];
                 args += tcg_reg_alloc_call(s, def, opc, args, dead_iargs);
                 dead_args = s->op_dead_args[op_index];
                 args += tcg_reg_alloc_call(s, def, opc, args, dead_args);
                 goto next;
             case INDEX_op_end:
                 goto the_end;
-...
                 /* Note: in order to speed up the code, it would be much
                    faster to have specialized register allocator functions for
                    some common argument patterns */
                 dead_iargs = s->op_dead_iargs[op_index];
                 tcg_reg_alloc_op(s, def, opc, args, dead_iargs);
                 dead_args = s->op_dead_args[op_index];
                 tcg_reg_alloc_op(s, def, opc, args, dead_args);
                 break;
+            }
             args += def->nb_args;

         uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */
         /* liveness analysis */
         uint16_t *op_dead_iargs; /* for each operation, each bit tells if the
                                     corresponding input argument is dead */
         uint16_t *op_dead_args; /* for each operation, each bit tells if the
                                    corresponding argument is dead */
         /* tells in which temporary a given register is. It does not take
            into account fixed registers */

Also available in: Unified diff

Archipelago » qemu

Revision 866cb6cb