a few fixes for new register allocator

diff --git a/ChangeLog b/ChangeLog
index eb812dfb54447efb31599bef7747b1046cef6859..8c69e0bd109774b734ae22d2ee35550c02b98fc5 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,7 +1,34 @@
+2006-05-10  Aleksey Demakov  <ademakov@gmail.com>
+
+       * jit/jit-reg-alloc.c (use_cheapest_register): check if the other
+       part of a register pair clobbers global registers.
+
+       * jit/jit-reg-alloc.c (exch_stack_top): run value exchange loop
+       for all values in both registers.
+
+       * jit/jit-reg-alloc.h, jit/jit-reg-alloc.c: delete on_stack field
+       from the _jit_regdesc_t struct.
+
+       * jit/jit-reg-alloc.c (_jit_regs_gen): handle instructions that have
+       both stack and flat registers.
+
+       * jit/jit-reg-alloc.c (spill_value): spilling an input value remember
+       if we do register exchanges for other values.
+
+       * jit/jit-reg-alloc.c: set touched registers more accurately.
+
+2006-05-08  Aleksey Demakov  <ademakov@gmail.com>
+
+       * jit/jit-reg-alloc.c (commit_input_value, commit_output_value):
+       fix extra spills introduced at 2006-05-05.
+
+       * jit/jit-rules-x86.c (_jit_gen_spill_top): add missing
+       jit_cache_end_output().
+
 2006-05-05  Aleksey Demakov  <ademakov@gmail.com>
 
-       * jit/jit-reg-alloc.h, jit/jit-reg-alloc.c: fix spilling and
-       many problems with stack registers.
+       * jit/jit-reg-alloc.h, jit/jit-reg-alloc.c: fix spilling and many
+       problems with stack registers.
 
 2006-05-04  Radek Polak  <psonek2@seznam.cz>
 

diff --git a/jit/jit-reg-alloc.c b/jit/jit-reg-alloc.c
index c2aed7293ea528412ff584d99257c172e3acf164..732382d34ba096c9677c369a970cf1582023e061 100644 (file)
--- a/jit/jit-reg-alloc.c
+++ b/jit/jit-reg-alloc.c
@@ -1838,7 +1838,7 @@ clobbers_register(jit_gencode_t gen, _jit_regs_t *regs, int index, int reg, int
        if(regs->ternary || !regs->descs[0].value)
        {
                /* this is either a ternary op or a binary/unary note */
-               if(regs->on_stack)
+               if(IS_STACK_REG(reg))
                {
                        /* all input values are popped */
                        clobber = 1;
@@ -1937,10 +1937,16 @@ clobbers_register(jit_gencode_t gen, _jit_regs_t *regs, int index, int reg, int
  * Set assigned and clobber flags for a register.
  */
 static void
-set_register_flags(_jit_regs_t *regs, int reg, int clobber_reg, int clobber_input)
+set_register_flags(
+       jit_gencode_t gen,
+       _jit_regs_t *regs,
+       int reg,
+       int clobber_reg,
+       int clobber_input)
 {
        if(reg >= 0)
        {
+               jit_reg_set_used(gen->touched, reg);
                jit_reg_set_used(regs->assigned, reg);
                if(clobber_reg)
                {
@@ -1968,7 +1974,6 @@ init_regdesc(_jit_regs_t *regs, int index)
        desc->used = 0;
        desc->clobber = 0;
        desc->early_clobber = 0;
-       desc->on_stack = 0;
        desc->duplicate = 0;
        desc->load = 0;
        desc->copy = 0;
@@ -1998,10 +2003,6 @@ set_regdesc_value(_jit_regs_t *regs, int index, jit_value_t value, int flags, in
        }
        desc->live = live;
        desc->used = used;
-       if(regs->on_stack)
-       {
-               desc->on_stack = 1;
-       }
 }
 
 /*
@@ -2018,12 +2019,12 @@ set_regdesc_register(jit_gencode_t gen, _jit_regs_t *regs, int index, int reg, i
                regs->descs[index].other_reg = other_reg;
 
                clobber = clobbers_register(gen, regs, index, reg, other_reg);
-               set_register_flags(regs, reg,
+               set_register_flags(gen, regs, reg,
                                   (clobber & CLOBBER_REG),
                                   (clobber & CLOBBER_INPUT_VALUE));
                if(other_reg >= 0)
                {
-                       set_register_flags(regs, other_reg,
+                       set_register_flags(gen, regs, other_reg,
                                           (clobber & CLOBBER_OTHER_REG),
                                           (clobber & CLOBBER_INPUT_VALUE));
                }
@@ -2066,7 +2067,7 @@ collect_register_info(_jit_regs_t *regs, int index)
                }
        }
 
-       if(desc->on_stack)
+       if(IS_STACK_REG(desc->reg))
        {
                stack_start = get_stack_start(desc->reg);
                if(regs->stack_start < 0)
@@ -2370,6 +2371,10 @@ use_cheapest_register(jit_gencode_t gen, _jit_regs_t *regs, int index, jit_regus
                                cost = COST_TOO_MUCH;
                        }
                }
+               else if(other_reg >= 0 && jit_reg_is_used(gen->permanent, other_reg))
+               {
+                       cost = COST_TOO_MUCH;
+               }
                else if(thrashes_register(gen, regs, desc, reg, other_reg))
                {
                        cost = COST_TOO_MUCH;
@@ -2444,7 +2449,6 @@ check_duplicate_value(_jit_regs_t *regs, _jit_regdesc_t *desc1, _jit_regdesc_t *
        {
                desc2->reg = desc1->reg;
                desc2->other_reg = desc1->other_reg;
-               desc2->on_stack = desc1->on_stack;
                desc2->duplicate = 1;
        }
 }
@@ -2613,7 +2617,7 @@ adjust_assignment(jit_gencode_t gen, _jit_regs_t *regs, int index)
        _jit_regdesc_t *desc;
 
        desc = &regs->descs[index];
-       if(!desc->value || !desc->on_stack)
+       if(!desc->value || !IS_STACK_REG(desc->reg))
        {
                return;
        }
@@ -2884,7 +2888,7 @@ exch_stack_top(jit_gencode_t gen, int reg, int pop)
 
        /* Update information about the contents of the registers.  */
        for(index = 0;
-           index < gen->contents[reg].num_values && index < gen->contents[top].num_values;
+           index < gen->contents[reg].num_values || index < gen->contents[top].num_values;
            index++)
        {
                value1 = (index < gen->contents[reg].num_values
@@ -3062,6 +3066,26 @@ spill_reg(jit_gencode_t gen, _jit_regs_t *regs, int reg)
        }
 }
 
+static void
+adjust_top_value(jit_gencode_t gen, _jit_regs_t *regs, int index, int top, int reg)
+{
+       if(regs->descs[index].stack_reg == top)
+       {
+               regs->descs[index].stack_reg = reg;
+       }
+}
+
+static void
+adjust_top_values(jit_gencode_t gen, _jit_regs_t *regs, int top, int reg)
+{
+       if(regs->ternary)
+       {
+               adjust_top_value(gen, regs, 0, top, reg);
+       }
+       adjust_top_value(gen, regs, 1, top, reg);
+       adjust_top_value(gen, regs, 2, top, reg);
+}
+
 static void
 spill_value(jit_gencode_t gen, _jit_regs_t *regs, jit_value_t value, int reg, int other_reg)
 {
@@ -3079,6 +3103,7 @@ spill_value(jit_gencode_t gen, _jit_regs_t *regs, jit_value_t value, int reg, in
                if(top != reg)
                {
                        exch_stack_top(gen, reg, 0);
+                       adjust_top_values(gen, regs, top, reg);
                }
 
                if(!(value->is_constant || value->in_frame))
@@ -3215,12 +3240,6 @@ load_input_value(jit_gencode_t gen, _jit_regs_t *regs, int index)
                        bind_value(gen, desc->value, desc->reg, desc->other_reg, 1);
                }
        }
-
-       jit_reg_set_used(gen->touched, desc->reg);
-       if(desc->other_reg >= 0)
-       {
-               jit_reg_set_used(gen->touched, desc->reg);
-       }
 }
 
 static void
@@ -3234,6 +3253,10 @@ move_input_value(jit_gencode_t gen, _jit_regs_t *regs, int index)
        {
                return;
        }
+       if(!IS_STACK_REG(desc->value->reg))
+       {
+               return;
+       }
 
        if(desc->copy)
        {
@@ -3384,12 +3407,6 @@ commit_output_value(jit_gencode_t gen, _jit_regs_t *regs)
                        }
                }
        }
-
-       jit_reg_set_used(gen->touched, desc->reg);
-       if(desc->other_reg >= 0)
-       {
-               jit_reg_set_used(gen->touched, desc->other_reg);
-       }
 }
 
 void
@@ -3585,17 +3602,21 @@ _jit_regs_assign(jit_gencode_t gen, _jit_regs_t *regs)
 #endif
 
        /* Set clobber flags. */
-       if(regs->clobber_all)
+       for(index = 0; index < JIT_NUM_REGS; index++)
        {
-               for(index = 0; index < JIT_NUM_REGS; index++)
+               if((_jit_reg_info[index].flags & JIT_REG_FIXED)
+                  || jit_reg_is_used(gen->permanent, index))
+               {
+                       continue;
+               }
+               if(regs->clobber_all)
                {
-                       if((_jit_reg_info[index].flags & JIT_REG_FIXED)
-                          || jit_reg_is_used(gen->permanent, index))
-                       {
-                               continue;
-                       }
                        jit_reg_set_used(regs->clobber, index);
                }
+               if(jit_reg_is_used(regs->clobber, index))
+               {
+                       jit_reg_set_used(gen->touched, index);
+               }
        }
 
        /* Spill all clobbered registers. */
@@ -3642,7 +3663,7 @@ _jit_regs_assign(jit_gencode_t gen, _jit_regs_t *regs)
                        {
                                return 0;
                        }
-                       set_register_flags(regs, regs->scratch[index].reg, 1, 0);
+                       set_register_flags(gen, regs, regs->scratch[index].reg, 1, 0);
                }
        }
        for(index = 0; index < regs->num_scratch; index++)
@@ -3656,7 +3677,7 @@ _jit_regs_assign(jit_gencode_t gen, _jit_regs_t *regs)
                        {
                                return 0;
                        }
-                       set_register_flags(regs, regs->scratch[index].reg, 1, 0);
+                       set_register_flags(gen, regs, regs->scratch[index].reg, 1, 0);
                }
        }
 
@@ -3758,7 +3779,7 @@ _jit_regs_assign(jit_gencode_t gen, _jit_regs_t *regs)
                        {
                                return 0;
                        }
-                       set_register_flags(regs, regs->scratch[index].reg, 1, 0);
+                       set_register_flags(gen, regs, regs->scratch[index].reg, 1, 0);
                }
        }
 
@@ -3888,10 +3909,9 @@ _jit_regs_gen(jit_gencode_t gen, _jit_regs_t *regs)
                select_stack_order(gen, regs);
        }
 
-       /* Load values. */
-       if(regs->on_stack)
+       /* Shuffle the values that are already on the register stack. */
+       if(regs->loaded_stack_count > 0)
        {
-               /* shuffle the values that are already on the stack */
                if(regs->ternary)
                {
                        if(regs->descs[0].value && regs->descs[0].value->in_register)
@@ -3911,36 +3931,27 @@ _jit_regs_gen(jit_gencode_t gen, _jit_regs_t *regs)
                        move_input_value(gen, regs, 1);
                        move_input_value(gen, regs, 2);
                }
+       }
 
-               /* load and shuffle the remaining values */
-               if(regs->x87_arith && regs->reverse_args)
-               {
-                       load_input_value(gen, regs, 2);
-                       move_input_value(gen, regs, 2);
-                       load_input_value(gen, regs, 1);
-                       move_input_value(gen, regs, 1);
-               }
-               else
-               {
-                       if(regs->ternary)
-                       {
-                               load_input_value(gen, regs, 0);
-                               move_input_value(gen, regs, 0);
-                       }
-                       load_input_value(gen, regs, 1);
-                       move_input_value(gen, regs, 1);
-                       load_input_value(gen, regs, 2);
-                       move_input_value(gen, regs, 2);
-               }
+       /* Load and shuffle the remaining values. */
+       if(regs->x87_arith && regs->reverse_args)
+       {
+               load_input_value(gen, regs, 2);
+               move_input_value(gen, regs, 2);
+               load_input_value(gen, regs, 1);
+               move_input_value(gen, regs, 1);
        }
        else
        {
                if(regs->ternary)
                {
                        load_input_value(gen, regs, 0);
+                       move_input_value(gen, regs, 0);
                }
                load_input_value(gen, regs, 1);
+               move_input_value(gen, regs, 1);
                load_input_value(gen, regs, 2);
+               move_input_value(gen, regs, 2);
        }
 
 #ifdef JIT_REG_DEBUG

diff --git a/jit/jit-reg-alloc.h b/jit/jit-reg-alloc.h
index 014a5dbfebd0d25164331ab17bb2cc18d5abd136..9bd2cfa0eeefcf0177f2dda861fba595e880dab7 100644 (file)
--- a/jit/jit-reg-alloc.h
+++ b/jit/jit-reg-alloc.h
@@ -119,7 +119,6 @@ typedef struct
        unsigned        used : 1;
        unsigned        clobber : 1;
        unsigned        early_clobber : 1;
-       unsigned        on_stack : 1;
        unsigned        duplicate : 1;
        unsigned        load : 1;
        unsigned        copy : 1;