dotgnu-pnet-commits
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[dotgnu-pnet-commits] libjit ./ChangeLog jit/jit-reg-alloc.h jit/jit-...


From: Aleksey Demakov
Subject: [dotgnu-pnet-commits] libjit ./ChangeLog jit/jit-reg-alloc.h jit/jit-...
Date: Wed, 10 May 2006 16:39:33 +0000

CVSROOT:        /sources/dotgnu-pnet
Module name:    libjit
Branch:         
Changes by:     Aleksey Demakov <address@hidden>        06/05/10 16:39:33

Modified files:
        .              : ChangeLog 
        jit            : jit-reg-alloc.h jit-reg-alloc.c 

Log message:
        a few fixes for new register allocator

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/libjit/ChangeLog.diff?tr1=1.225&tr2=1.226&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/libjit/jit/jit-reg-alloc.h.diff?tr1=1.10&tr2=1.11&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/libjit/jit/jit-reg-alloc.c.diff?tr1=1.26&tr2=1.27&r1=text&r2=text

Patches:
Index: libjit/ChangeLog
diff -u libjit/ChangeLog:1.225 libjit/ChangeLog:1.226
--- libjit/ChangeLog:1.225      Fri May  5 10:13:07 2006
+++ libjit/ChangeLog    Wed May 10 16:39:33 2006
@@ -1,7 +1,34 @@
+2006-05-10  Aleksey Demakov  <address@hidden>
+
+       * 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  <address@hidden>
+
+       * 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  <address@hidden>
 
-       * 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  <address@hidden>
 
Index: libjit/jit/jit-reg-alloc.c
diff -u libjit/jit/jit-reg-alloc.c:1.26 libjit/jit/jit-reg-alloc.c:1.27
--- libjit/jit/jit-reg-alloc.c:1.26     Mon May  8 10:55:46 2006
+++ libjit/jit/jit-reg-alloc.c  Wed May 10 16:39:33 2006
@@ -1838,7 +1838,7 @@
        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 @@
  * 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 @@
        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 @@
        }
        desc->live = live;
        desc->used = used;
-       if(regs->on_stack)
-       {
-               desc->on_stack = 1;
-       }
 }
 
 /*
@@ -2018,12 +2019,12 @@
                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 @@
                }
        }
 
-       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 @@
                                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 @@
        {
                desc2->reg = desc1->reg;
                desc2->other_reg = desc1->other_reg;
-               desc2->on_stack = desc1->on_stack;
                desc2->duplicate = 1;
        }
 }
@@ -2613,7 +2617,7 @@
        _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 @@
 
        /* 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
@@ -3063,6 +3067,26 @@
 }
 
 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)
 {
        int top;
@@ -3079,6 +3103,7 @@
                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 @@
                        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 @@
        {
                return;
        }
+       if(!IS_STACK_REG(desc->value->reg))
+       {
+               return;
+       }
 
        if(desc->copy)
        {
@@ -3384,12 +3407,6 @@
                        }
                }
        }
-
-       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 @@
 #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 @@
                        {
                                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 @@
                        {
                                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 @@
                        {
                                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 @@
                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 @@
                        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
Index: libjit/jit/jit-reg-alloc.h
diff -u libjit/jit/jit-reg-alloc.h:1.10 libjit/jit/jit-reg-alloc.h:1.11
--- libjit/jit/jit-reg-alloc.h:1.10     Fri May  5 10:13:07 2006
+++ libjit/jit/jit-reg-alloc.h  Wed May 10 16:39:33 2006
@@ -119,7 +119,6 @@
        unsigned        used : 1;
        unsigned        clobber : 1;
        unsigned        early_clobber : 1;
-       unsigned        on_stack : 1;
        unsigned        duplicate : 1;
        unsigned        load : 1;
        unsigned        copy : 1;




reply via email to

[Prev in Thread] Current Thread [Next in Thread]