AIX regression due to DFA scheduler merge

Vladimir Makarov vmakarov@redhat.com
Mon Jun 10 13:08:00 GMT 2002


Vladimir Makarov wrote:
> 
> law@redhat.com wrote:
> >
> > In message <200206041528.LAA27866@makai.watson.ibm.com>, David Edelsohn writes:
> >  >      I successfully bootstrapped the compiler with your patch [minus
> >  > the superfluous INSN_P(end_seq)].  Testsuite results are better.
> > Thanks.  Where there any regressions in the testsuite?  ie, was there anything
> > which would prevent a check-in?
> >
> > My ppc bootstrap finished early this morning, regression testing it will
> > probably take the rest of the day -- however, if your regression testing
> > was OK, then I can go ahead and check in my change.
> 
> 
> As for the patch for local-alloc, I'll make it on this week.
> 

Here is the patch, Jeff.  I've checked it on bootstrap for i686.

I think it is safe in any case.

Is it ok to commit?

Vlad


2002-06-10  Vladimir Makarov  <vmakarov@redhat.com>

        * local-alloc.c (block_alloc): Process nested libcalls too.

Index: local-alloc.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/local-alloc.c,v
retrieving revision 1.109
diff -c -p -r1.109 local-alloc.c
*** local-alloc.c       30 May 2002 20:55:09 -0000      1.109
--- local-alloc.c       10 Jun 2002 19:56:43 -0000
*************** block_alloc (b)
*** 1223,1228 ****
--- 1223,1229 ----
    int i, q;
    rtx insn;
    rtx note, hard_reg;
+   rtx reg_equal_insn;
    int insn_number = 0;
    int insn_count = 0;
    int max_uid = get_max_uid ();
*************** block_alloc (b)
*** 1256,1261 ****
--- 1257,1263 ----
       It computes which registers to tie.  */
  
    insn = BLOCK_HEAD (b);
+   reg_equal_insn = NULL_RTX;
    while (1)
      {
        if (GET_CODE (insn) != NOTE)
*************** block_alloc (b)
*** 1391,1396 ****
--- 1393,1399 ----
             assigned, since that would prevent combining.  */
  
          if (optimize
+             && reg_equal_insn == NULL_RTX
              && GET_CODE (PATTERN (insn)) == CLOBBER
              && (r0 = XEXP (PATTERN (insn), 0),
                  GET_CODE (r0) == REG)
*************** block_alloc (b)
*** 1402,1407 ****
--- 1405,1411 ----
              && (note = find_reg_note (XEXP (link, 0), REG_EQUAL,
                                        NULL_RTX)) != 0)
            {
+             reg_equal_insn = XEXP (link, 0);
              if (r1 = XEXP (note, 0), GET_CODE (r1) == REG
                  /* Check that we have such a sequence.  */
                  && no_conflict_p (insn, r0, r1))
*************** block_alloc (b)
*** 1427,1432 ****
--- 1431,1443 ----
              if (win)
                no_conflict_combined_regno = REGNO (r1);
            }
+         else if (insn == reg_equal_insn)
+           /* Setting up flag that we are not inside a libcall
+                sequence.  There is probability of one nasty case when
+                previous optimizations produce nested libcalls.  It is
+                easier to find such case in this function instead of
+                function `no_conflict_p'.  */
+           reg_equal_insn = NULL_RTX;
  
          /* If registers were just tied, set COMBINED_REGNO
             to the number of the register used in this insn



More information about the Gcc-patches mailing list