re PR tree-optimization/19080 (ICE while compiling linux kernel)

	PR tree-optimization/19080

	Merge from tree-cleanup-branch

	* tree-flow-inline.h (clear_call_clobbered): New function.
	* tree-ssa-alias.c (init_alias_info): Call it.


testsuite/ChangeLog

	PR tree-optimization/19080
	* gcc.c-torture/compile/pr19080.c: New test.

From-SVN: r92423

gcc/ChangeLog

+2004-12-20  Diego Novillo  <dnovillo@redhat.com>
+
+	PR tree-optimization/19080
+
+	Merge from tree-cleanup-branch
+
+	* tree-flow-inline.h (clear_call_clobbered): New function.
+	* tree-ssa-alias.c (init_alias_info): Call it.
+
 2004-12-20  Richard Henderson  <rth@redhat.com>
 
 	* config/i386/i386.md (sse2_movsd): Remove ix86_binary_operator_ok

gcc/testsuite/ChangeLog

+2004-12-20  Diego Novillo  <dnovillo@redhat.com>
+
+	PR tree-optimization/19080
+	* gcc.c-torture/compile/pr19080.c: New test.
+
 2004-12-20  Steven Bosscher  <stevenb@suse.de>
 
 	* gcc.dg/20041219-1.c: New test.

gcc/testsuite/gcc.c-torture/compile/pr19080.c

+typedef union { int ioport; volatile char *maddr; } bus_space_handle_t;
+struct scb { unsigned short *hscb; };
+struct ahd_softc
+{
+  int tags[2];
+  bus_space_handle_t bshs[2];
+  int dst_mode;
+  int src_mode;
+  int flags;
+};
+void outb(int, int);
+
+int foo_inb(struct ahd_softc*);
+int foo_int_int (int, int);
+int ahd_inb(struct ahd_softc*);
+int ahd_scb_active_in_fifo (void);
+
+void ahd_flush_qoutfifo (struct ahd_softc *ahd, struct scb *scb)
+{
+  int src, dst, *a = &src, *b = &dst; *a = 1, *b = 1;
+  int bb, p;
+
+  if (ahd->src_mode == 1)
+    { int src, dst, *a = &src, *b = &dst; *a = 1, *b = 1;}
+  foo_int_int (ahd->src_mode, ahd->dst_mode);
+  p = 1;
+  if (ahd->src_mode == 2 && ahd->dst_mode == p)
+    {
+      if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+        outb (1, ahd->bshs[0].ioport );
+      if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+        outb (1, ahd->bshs[0].ioport );
+    }
+  ahd->src_mode = 1;
+  ahd->dst_mode = 2;
+  while ((ahd_inb (ahd) & 0x01) != 0)
+  {
+    p = 1;
+    if (ahd->src_mode == 2 && ahd->dst_mode == p)
+      {
+        if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+          outb (1, ahd->bshs[0].ioport );
+        if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+          outb (1, ahd->bshs[0].ioport );
+      }
+    ahd->src_mode = 1;
+    ahd->dst_mode = 2;
+    if (ahd_scb_active_in_fifo () == 0)
+      continue;
+    p = 1;
+    if (ahd->src_mode == 2 && ahd->dst_mode == p)
+      {
+        if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+          outb (1, ahd->bshs[0].ioport );
+        if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+          outb (1, ahd->bshs[0].ioport );
+      }
+    ahd->src_mode = 1;
+    ahd->dst_mode = 2;
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+    if ((ahd->flags & 1) != 0)
+      foo_inb (ahd);
+    if ((ahd->flags & 1) != 0)
+      foo_inb (ahd);
+    if ((ahd->flags & 1) != 0)
+      foo_inb (ahd);
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+    if ((ahd->flags & 1) != 0)
+      foo_inb (ahd);
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+    bb = (*(scb->hscb));
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+    bb = (*(scb->hscb));
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+    if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+      outb (1, ahd->bshs[0].ioport );
+  }
+  if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+    outb (1, ahd->bshs[0].ioport );
+  if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+    outb (1, ahd->bshs[0].ioport );
+  p = 1;
+  if (ahd->src_mode == 2 && ahd->dst_mode == p)
+    {
+      if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+        outb (1, ahd->bshs[0].ioport );
+      if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+        outb (1, ahd->bshs[0].ioport );
+    }
+  ahd->src_mode = 1;
+  ahd->dst_mode = 2;
+  if (ahd->src_mode == 2 && ahd->dst_mode == dst)
+    {
+      if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+        outb (1, ahd->bshs[0].ioport );
+      if (ahd->tags[0] == 1) *(ahd->bshs[0].maddr);
+        outb (1, ahd->bshs[0].ioport );
+    }
+  ahd->src_mode = 1;
+  ahd->dst_mode = 2;
+  ahd->flags |= 1;
+}

gcc/tree-flow-inline.h

@@ -625,6 +625,18 @@ mark_call_clobbered (tree var)
   ssa_ro_call_cache_valid = false;
 }
 
+/* Clear the call-clobbered attribute from variable VAR.  */
+static inline void
+clear_call_clobbered (tree var)
+{
+  var_ann_t ann = var_ann (var);
+  if (ann->mem_tag_kind != NOT_A_TAG)
+    DECL_EXTERNAL (var) = 0;
+  bitmap_clear_bit (call_clobbered_vars, ann->uid);
+  ssa_call_clobbered_cache_valid = false;
+  ssa_ro_call_cache_valid = false;
+}
+
 /* Mark variable VAR as being non-addressable.  */
 static inline void
 mark_non_addressable (tree var)

gcc/tree-ssa-alias.c

@@ -437,7 +437,6 @@ init_alias_info (void)
   if (aliases_computed_p)
     {
       unsigned i;
-      bitmap_iterator bi;
       basic_block bb;
   
      /* Make sure that every statement has a valid set of operands.
@@ -453,19 +452,6 @@ init_alias_info (void)
 	    get_stmt_operands (bsi_stmt (si));
 	}
 
-      /* Clear the call-clobbered set.  We are going to re-discover
-	  call-clobbered variables.  */
-      EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i, bi)
-	{
-	  tree var = referenced_var (i);
-
-	  /* Variables that are intrinsically call-clobbered (globals,
-	     local statics, etc) will not be marked by the aliasing
-	     code, so we can't remove them from CALL_CLOBBERED_VARS.  */
-	  if (!is_call_clobbered (var))
-	    bitmap_clear_bit (call_clobbered_vars, var_ann (var)->uid);
-	}
-
       /* Similarly, clear the set of addressable variables.  In this
 	 case, we can just clear the set because addressability is
 	 only computed here.  */
@@ -474,9 +460,19 @@ init_alias_info (void)
       /* Clear flow-insensitive alias information from each symbol.  */
       for (i = 0; i < num_referenced_vars; i++)
 	{
-	  var_ann_t ann = var_ann (referenced_var (i));
+	  tree var = referenced_var (i);
+	  var_ann_t ann = var_ann (var);
+
 	  ann->is_alias_tag = 0;
 	  ann->may_aliases = NULL;
+
+	  /* Since we are about to re-discover call-clobbered
+	     variables, clear the call-clobbered flag.  Variables that
+	     are intrinsically call-clobbered (globals, local statics,
+	     etc) will not be marked by the aliasing code, so we can't
+	     remove them from CALL_CLOBBERED_VARS.  */
+	  if (ann->mem_tag_kind != NOT_A_TAG || !is_global_var (var))
+	    clear_call_clobbered (var);
 	}
 
       /* Clear flow-sensitive points-to information from each SSA name.  */