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

[Aleksey Demakov]

CVSROOT:        /sources/dotgnu-pnet
Module name:    libjit
Changes by:     Aleksey Demakov <avd>   07/02/24 19:17:25

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

Log message:
        fix problem with ops that have x87 dest register and no x87 input 
registers

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/libjit/ChangeLog?cvsroot=dotgnu-pnet&r1=1.307&r2=1.308
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-reg-alloc.c?cvsroot=dotgnu-pnet&r1=1.53&r2=1.54

Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/ChangeLog,v
retrieving revision 1.307
retrieving revision 1.308
diff -u -b -r1.307 -r1.308
--- ChangeLog   15 Feb 2007 07:31:05 -0000      1.307
+++ ChangeLog   24 Feb 2007 19:17:25 -0000      1.308
@@ -1,3 +1,11 @@
+2007-02-25  Aleksey Demakov  <address@hidden>
+
+       * jit/jit-reg-alloc.c (adjust_assignment, _jit_regs_gen): the ops
+       that have dest value on x87 stack but have no x87 input values need
+       the dest register to be adjusted after spilling too.
+       (is_register_occupied, clobbers_register): undo is_register_occupied
+       logic introduced 2007-02-12.
+
 2007-02-14  Aleksey Demakov  <address@hidden>
 
        * jit/jit-function.c (compile_block): check if cache is full and

Index: jit/jit-reg-alloc.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-reg-alloc.c,v
retrieving revision 1.53
retrieving revision 1.54
diff -u -b -r1.53 -r1.54
--- jit/jit-reg-alloc.c 11 Feb 2007 23:28:44 -0000      1.53
+++ jit/jit-reg-alloc.c 24 Feb 2007 19:17:25 -0000      1.54
@@ -44,6 +44,11 @@
 #define        JIT_MIN_USED            3
 
 /*
+ * Use is_register_occupied() function.
+ */
+#undef IS_REGISTER_OCCUPIED
+
+/*
  * Check if the register is on the register stack.
  */
 #ifdef JIT_REG_STACK
@@ -371,6 +376,7 @@
        return 0;
 }
 
+#ifdef IS_REGISTER_OCCUPIED
 /*
  * Check if the register contains any values either dead or alive
  * that may need to be evicted from it.
@@ -383,17 +389,9 @@
                return 0;
        }
 
-       /* Assume that a global register is always alive unless it is to be
-          computed right away. */
+       /* Assume that a global register is always occupied. */
        if(jit_reg_is_used(gen->permanent, reg))
        {
-               if(!regs->ternary
-                  && regs->descs[0].value
-                  && regs->descs[0].value->has_global_register
-                  && regs->descs[0].value->global_reg == reg)
-               {
-                       return 0;
-               }
                return 1;
        }
 
@@ -408,6 +406,7 @@
 
        return 0;
 }
+#endif
 
 /*
  * Determine the effect of using a register for a value. This includes the
@@ -482,6 +481,7 @@
                }
 
                flags = CLOBBER_NONE;
+#ifdef IS_REGISTER_OCCUPIED
                if(is_register_occupied(gen, regs, reg))
                {
                        flags |= CLOBBER_REG;
@@ -490,6 +490,16 @@
                {
                        flags |= CLOBBER_OTHER_REG;
                }
+#else
+               if(is_register_alive(gen, regs, reg))
+               {
+                       flags |= CLOBBER_REG;
+               }
+               if(is_register_alive(gen, regs, other_reg))
+               {
+                       flags |= CLOBBER_OTHER_REG;
+               }
+#endif
                return flags;
        }
        else if(regs->copy)
@@ -535,6 +545,7 @@
                }
        }
 
+#ifdef IS_REGISTER_OCCUPIED
        if(is_register_occupied(gen, regs, reg))
        {
                flags |= CLOBBER_REG;
@@ -543,6 +554,16 @@
        {
                flags |= CLOBBER_OTHER_REG;
        }
+#else
+       if(is_register_alive(gen, regs, reg))
+       {
+               flags |= CLOBBER_REG;
+       }
+       if(is_register_alive(gen, regs, other_reg))
+       {
+               flags |= CLOBBER_OTHER_REG;
+       }
+#endif
        return flags;
 }
 
@@ -1657,7 +1678,19 @@
                return;
        }
 
-       if(regs->wanted_stack_count == 1)
+       if(regs->wanted_stack_count == 0)
+       {
+               /* an op with stack dest and non-stack args */
+#ifdef JIT_REG_DEBUG
+               if(index != 0 || regs->ternary)
+               {
+                       printf("*** Wrong stack register count! ***\n");
+                       abort();
+               }
+#endif
+               desc->reg = gen->reg_stack_top;
+       }
+       else if(regs->wanted_stack_count == 1)
        {
                /* either a unary op or a binary op with duplicate value */
                desc->reg = gen->reg_stack_top - regs->loaded_stack_count;
@@ -1717,6 +1750,11 @@
 
 #ifdef JIT_REG_DEBUG
        printf("reg = %d\n", desc->reg);
+       if(desc->reg < JIT_REG_STACK_START || desc->reg > JIT_REG_STACK_END)
+       {
+               printf("*** Invalid stack register! ***\n");
+               abort();
+       }
 #endif
 }
 
@@ -3483,7 +3521,19 @@
                }
                if(jit_reg_is_used(gen->permanent, reg))
                {
-                       /* Oops, global register. */
+#ifdef IS_REGISTER_OCCUPIED
+                       /* If the op computes the value assigned to the global
+                          register then it is not really clobbered. */
+                       if(!regs->ternary
+                          && regs->descs[0].value
+                          && regs->descs[0].value->has_global_register
+                          && regs->descs[0].value->global_reg == reg)
+                       {
+                               continue;
+                       }
+#endif
+                       /* Oops, the global register is going to be clobbered. 
Save
+                          it on the stack in order to restore after the op. */
 #ifdef JIT_REG_DEBUG
                        printf("*** Spill global register: %d ***\n", reg);
 #endif
@@ -3599,6 +3649,12 @@
                {
                        load_input_value(gen, regs, 0);
                }
+#ifdef JIT_REG_STACK
+               else if(regs->descs[0].reg >= 0 && 
IS_STACK_REG(regs->descs[0].reg))
+               {
+                       adjust_assignment(gen, regs, 0);
+               }
+#endif
                load_input_value(gen, regs, 1);
                load_input_value(gen, regs, 2);
        }
@@ -3745,6 +3801,15 @@
        {
                if(jit_reg_is_used(regs->clobber, reg) && 
jit_reg_is_used(gen->permanent, reg))
                {
+#ifdef IS_REGISTER_OCCUPIED
+                       if(!regs->ternary
+                          && regs->descs[0].value
+                          && regs->descs[0].value->has_global_register
+                          && regs->descs[0].value->global_reg == reg)
+                       {
+                               continue;
+                       }
+#endif
                        _jit_gen_load_global(gen, reg, 0);
                }
        }