RFA: patch solving PR/15921

[Vladimir Makarov <vmakarov at redhat dot com>]

 The reload pass can assign the same hard register to uninitialized
pseudo-register and early clobbered pseudo-register in an insn if the
pseudo-register is used first time in given BB and not lived at the BB
start.  It results in compiler crash.  Even usage of uninitialized
variable is wrong, it should not result in compiler crash.  To prevent
the crash we don't change life information for such pseudo-registers.

 The following patch solves the problem.  The patch was tested also
on bootstrap.

 Is it ok to commit to the main line?

Vlad


2004-06-15  Vladimir Makarov  <vmakarov@redhat.com>

	PR rtl-optimization/15921
       * Makefile.in (global.o): Add recog.h.
	
	* global.c (recog.h): Add the include-clause.
	(bb_info): New member earlyclobber.
	(allocate_bb_info, free_bb_info): Initialize/finish the new
	member.
	(earlyclobber_regclass, earlyclobber_regclass_length): The new
	global variables.
	(check_earlyclobber, regclass_intersect,
	mark_reg_use_for_earlyclobber, mark_reg_use_for_earlyclobber_1):
	New functions.
	(calculate_local_reg_bb_info): Calculate value of earlyclobber.
	(make_accurate_live_analysis): Modify pavin.

Index: global.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/global.c,v
retrieving revision 1.102
diff -u -p -r1.102 global.c
--- global.c	30 May 2004 18:32:26 -0000	1.102
+++ global.c	15 Jun 2004 15:46:01 -0000
@@ -34,6 +34,7 @@ Software Foundation, 59 Temple Place - S
 #include "regs.h"
 #include "function.h"
 #include "insn-config.h"
+#include "recog.h"
 #include "reload.h"
 #include "output.h"
 #include "toplev.h"
@@ -309,6 +310,10 @@ static void reg_dies (int, enum machine_
 
 static void allocate_bb_info (void);
 static void free_bb_info (void);
+static void check_earlyclobber (rtx);
+static bool regclass_intersect (enum reg_class, enum reg_class);
+static void mark_reg_use_for_earlyclobber_1 (rtx *, void *);
+static int mark_reg_use_for_earlyclobber (rtx *, void *);
 static void calculate_local_reg_bb_info (void);
 static void set_up_bb_rts_numbers (void);
 static int rpost_cmp (const void *, const void *);
@@ -2000,6 +2005,9 @@ struct bb_info
 {
   /* The basic block reverse post-order number.  */
   int rts_number;
+  /* Registers used uninitialized in an insn in which there is an
+     early clobbered register might get the same hard register.  */
+  bitmap earlyclobber;
   /* Registers correspondingly killed (clobbered) and defined but not
      killed afterward in the basic block.  */
   bitmap killed, avloc;
@@ -2032,6 +2040,7 @@ allocate_bb_info (void)
   FOR_EACH_BB (bb)
     {
       bb_info = bb->aux;
+      bb_info->earlyclobber = BITMAP_XMALLOC ();
       bb_info->avloc = BITMAP_XMALLOC ();
       bb_info->killed = BITMAP_XMALLOC ();
       bb_info->pavin = BITMAP_XMALLOC ();
@@ -2057,6 +2066,7 @@ free_bb_info (void)
       BITMAP_XFREE (bb_info->pavin);
       BITMAP_XFREE (bb_info->killed);
       BITMAP_XFREE (bb_info->avloc);
+      BITMAP_XFREE (bb_info->earlyclobber);
     }
   free_aux_for_blocks ();
 }
@@ -2086,6 +2096,144 @@ mark_reg_change (rtx reg, rtx setter, vo
     bitmap_clear_bit (bb_info->avloc, regno);
 }
 
+/* Classes of registers which could be early clobbered in the current
+   insn.  */
+
+static varray_type earlyclobber_regclass;
+
+/* The function stores classes of registers which could be early
+   clobbered in INSN.  */
+
+static void
+check_earlyclobber (rtx insn)
+{
+  int opno;
+
+  extract_insn (insn);
+
+  VARRAY_POP_ALL (earlyclobber_regclass);
+  for (opno = 0; opno < recog_data.n_operands; opno++)
+    {
+      char c;
+      bool amp_p;
+      int i;
+      enum reg_class class;
+      const char *p = recog_data.constraints[opno];
+
+      class = NO_REGS;
+      amp_p = false;
+      for (;;)
+	{
+	  c = *p;
+	  switch (c)
+	    {
+	    case '=':  case '+':  case '?':
+	    case '#':  case '!':
+	    case '*':  case '%':
+	    case 'm':  case '<':  case '>':  case 'V':  case 'o':
+	    case 'E':  case 'F':  case 'G':  case 'H':
+	    case 's':  case 'i':  case 'n':
+	    case 'I':  case 'J':  case 'K':  case 'L':
+	    case 'M':  case 'N':  case 'O':  case 'P':
+	    case 'X':
+	    case '0': case '1':  case '2':  case '3':  case '4':
+	    case '5': case '6':  case '7':  case '8':  case '9':
+	      /* These don't say anything we care about.  */
+	      break;
+
+	    case '&':
+	      amp_p = true;
+	      break;
+	    case '\0':
+	    case ',':
+	      if (amp_p && class != NO_REGS)
+		{
+		  for (i = VARRAY_ACTIVE_SIZE (earlyclobber_regclass) - 1;
+		       i >= 0; i--)
+		    if (VARRAY_INT (earlyclobber_regclass, i) == (int) class)
+		      break;
+		  if (i < 0)
+		    VARRAY_PUSH_INT (earlyclobber_regclass, (int) class);
+		}
+	      
+	      amp_p = false;
+	      class = NO_REGS;
+	      break;
+
+	    case 'r':
+	      class = GENERAL_REGS;
+	      break;
+
+	    default:
+	      class = REG_CLASS_FROM_CONSTRAINT (c, p);
+	      break;
+	    }
+	  if (c == '\0')
+	    break;
+	  p += CONSTRAINT_LEN (c, p);
+	}
+    }
+}
+
+/* The function returns true if register classes C1 and C2 inetrsect.  */
+
+static bool
+regclass_intersect (enum reg_class c1, enum reg_class c2)
+{
+  HARD_REG_SET rs, zero;
+
+  CLEAR_HARD_REG_SET (zero);
+  COPY_HARD_REG_SET(rs, reg_class_contents [c1]);
+  AND_HARD_REG_SET (rs, reg_class_contents [c2]);
+  GO_IF_HARD_REG_EQUAL (zero, rs, yes);
+  return true;
+ yes:
+  return false;
+}
+
+/* The function checks that pseudo-register *X has a class
+   intersecting with the class of pseudo-register could be early
+   clobbered in the same insn.  */
+
+static int
+mark_reg_use_for_earlyclobber (rtx *x, void *data ATTRIBUTE_UNUSED)
+{
+  enum reg_class pref_class, alt_class;
+  int i, regno;
+  basic_block bb = data;
+  struct bb_info *bb_info = BB_INFO (bb);
+
+  if (GET_CODE (*x) == REG && REGNO (*x) >= FIRST_PSEUDO_REGISTER)
+    {
+      regno = REGNO (*x);
+      if (bitmap_bit_p (bb_info->killed, regno)
+	  || bitmap_bit_p (bb_info->avloc, regno))
+	return 0;
+      pref_class = reg_preferred_class (regno);
+      alt_class = reg_alternate_class (regno);
+      for (i = VARRAY_ACTIVE_SIZE (earlyclobber_regclass) - 1; i >= 0; i--)
+	if (regclass_intersect (VARRAY_INT (earlyclobber_regclass, i),
+				pref_class)
+	    || (VARRAY_INT (earlyclobber_regclass, i) != NO_REGS
+		&& regclass_intersect (VARRAY_INT (earlyclobber_regclass, i),
+				       alt_class)))
+	  {
+	    bitmap_set_bit (bb_info->earlyclobber, regno);
+	    break;
+	  }
+    }
+  return 0;
+}
+
+/* The function processes all pseudo-registers in *X with the aid of
+   previous function.  */
+
+static void
+mark_reg_use_for_earlyclobber_1 (rtx *x, void *data)
+{
+  for_each_rtx (x, mark_reg_use_for_earlyclobber, data);
+}
+
 /* The function calculates local info for each basic block.  */
 
 static void
@@ -2094,12 +2242,18 @@ calculate_local_reg_bb_info (void)
   basic_block bb;
   rtx insn, bound;
 
+  VARRAY_INT_INIT (earlyclobber_regclass, 20,
+		   "classes of registers early clobbered in an insn");
   FOR_EACH_BB (bb)
     {
       bound = NEXT_INSN (BB_END (bb));
       for (insn = BB_HEAD (bb); insn != bound; insn = NEXT_INSN (insn))
 	if (INSN_P (insn))
-	  note_stores (PATTERN (insn), mark_reg_change, bb);
+	  {
+	    note_stores (PATTERN (insn), mark_reg_change, bb);
+	    check_earlyclobber (insn);
+	    note_uses (&PATTERN (insn), mark_reg_use_for_earlyclobber_1, bb);
+	  }
     }
 }
 
@@ -2229,6 +2383,12 @@ make_accurate_live_analysis (void)
     {
       bb_info = BB_INFO (bb);
       
+      /* Reload can assign the same hard register to uninitialized
+	 pseudo-register and early clobbered pseudo-register in an
+	 insn if the pseudo-register is used first time in given BB
+	 and not lived at the BB start.  To prevent this we don't
+	 change life information for such pseudo-registers.  */
+      bitmap_a_or_b (bb_info->pavin, bb_info->pavin, bb_info->earlyclobber);
       bitmap_a_and_b (bb->global_live_at_start, bb->global_live_at_start,
 		      bb_info->pavin);
       bitmap_a_and_b (bb->global_live_at_end, bb->global_live_at_end,