Use the stock 3.2.1-prerelease file.

Approved by:	obrien

contrib/gcc/c-common.c

@@ -2328,10 +2328,6 @@ c_common_get_alias_set (t)
 {
   tree u;
   
-  /* We know nothing about vector types */
-  if (TREE_CODE (t) == VECTOR_TYPE)
-    return 0;          
-  
   /* Permit type-punning when accessing a union, provided the access
      is directly through the union.  For example, this code does not
      permit taking the address of a union member and then storing
@@ -2345,17 +2341,17 @@ c_common_get_alias_set (t)
 	&& TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
       return 0;
 
-  /* If this is a char *, the ANSI C standard says it can alias
-     anything.  Note that all references need do this.  */
-  if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
-      && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
-      && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
-    return 0;
-
   /* That's all the expressions we handle specially.  */
   if (! TYPE_P (t))
     return -1;
 
+  /* The C standard guarantess that any object may be accessed via an
+     lvalue that has character type.  */
+  if (t == char_type_node
+      || t == signed_char_type_node
+      || t == unsigned_char_type_node)
+    return 0;
+  
   /* The C standard specifically allows aliasing between signed and
      unsigned variants of the same type.  We treat the signed
      variant as canonical.  */
@@ -3570,6 +3566,7 @@ c_expand_expr (exp, target, tmode, modifier)
 	tree rtl_expr;
 	rtx result;
 	bool preserve_result = false;
+	bool return_target = false;
 
 	/* Since expand_expr_stmt calls free_temp_slots after every
 	   expression statement, we must call push_temp_slots here.
@@ -3597,8 +3594,20 @@ c_expand_expr (exp, target, tmode, modifier)
 	    if (TREE_CODE (last) == SCOPE_STMT
 		&& TREE_CODE (expr) == EXPR_STMT)
 	      {
-	        TREE_ADDRESSABLE (expr) = 1;
-		preserve_result = true;
+		if (target && TREE_CODE (EXPR_STMT_EXPR (expr)) == VAR_DECL
+		    && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr)) == target)
+		  /* If the last expression is a variable whose RTL is the
+		     same as our target, just return the target; if it
+		     isn't valid expanding the decl would produce different
+		     RTL, and store_expr would try to do a copy.  */
+		  return_target = true;
+		else
+		  {
+		    /* Otherwise, note that we want the value from the last
+		       expression.  */
+		    TREE_ADDRESSABLE (expr) = 1;
+		    preserve_result = true;
+		  }
 	      }
 	  }
 
@@ -3606,7 +3615,9 @@ c_expand_expr (exp, target, tmode, modifier)
 	expand_end_stmt_expr (rtl_expr);
 
 	result = expand_expr (rtl_expr, target, tmode, modifier);
-	if (preserve_result && GET_CODE (result) == MEM)
+	if (return_target)
+	  result = target;
+	else if (preserve_result && GET_CODE (result) == MEM)
 	  {
 	    if (GET_MODE (result) != BLKmode)
 	      result = copy_to_reg (result);
@@ -4163,6 +4174,10 @@ c_common_post_options ()
     warning ("-Wformat-security ignored without -Wformat");
   if (warn_missing_format_attribute && !warn_format)
     warning ("-Wmissing-format-attribute ignored without -Wformat");
+
+  /* If an error has occurred in cpplib, note it so we fail
+     immediately.  */
+  errorcount += cpp_errors (parse_in);
 }
 
 /* Front end initialization common to C, ObjC and C++.  */

contrib/gcc/config/alpha/alpha.c

@@ -1666,7 +1666,11 @@ alpha_encode_section_info (decl)
       XSTR (XEXP (DECL_RTL (decl), 0), 0) = string;
     }
   else if (symbol_str[0] == '@')
-    abort ();
+    {
+      /* We're hosed.  This can happen when the user adds a weak
+	 attribute after rtl generation.  They should have gotten
+	 a warning about unspecified behaviour from varasm.c.  */
+    }
 }
 
 /* legitimate_address_p recognizes an RTL expression that is a valid

contrib/gcc/dwarfout.c

@@ -2088,7 +2088,8 @@ output_reg_number (rtl)
 
   if (regno >= DWARF_FRAME_REGISTERS)
     {
-      warning_with_decl (dwarf_last_decl, "internal regno botch: regno = %d\n",
+      warning_with_decl (dwarf_last_decl, 
+			 "internal regno botch: `%s' has regno = %d\n",
 			 regno);
       regno = 0;
     }
@@ -2305,7 +2306,8 @@ output_bound_representation (bound, dim_num, u_or_l)
 		   || TREE_CODE (bound) == CONVERT_EXPR)
 	      bound = TREE_OPERAND (bound, 0);
 
-	    if (TREE_CODE (bound) == SAVE_EXPR)
+	    if (TREE_CODE (bound) == SAVE_EXPR 
+		&& SAVE_EXPR_RTL (bound))
 	      output_loc_descriptor
 		(eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
 	  }

contrib/gcc/final.c

@@ -3023,6 +3023,9 @@ get_mem_expr_from_op (op, paddressp)
 
   *paddressp = 0;
 
+  if (op == NULL)
+    return 0;
+
   if (GET_CODE (op) == REG && ORIGINAL_REGNO (op) >= FIRST_PSEUDO_REGISTER)
     return REGNO_DECL (ORIGINAL_REGNO (op));
   else if (GET_CODE (op) != MEM)

contrib/gcc/libgcc2.c

@@ -1290,9 +1290,6 @@ struct bb
   char *flags;
 };
 
-#ifdef BLOCK_PROFILER_CODE
-BLOCK_PROFILER_CODE
-#else
 #ifndef inhibit_libc
 
 /* Simple minded basic block profiling output dumper for
@@ -1493,7 +1490,6 @@ __bb_fork_func (void)
 }
 
 #endif /* not inhibit_libc */
-#endif /* not BLOCK_PROFILER_CODE */
 #endif /* L_bb */
 
 #ifdef L_clear_cache

contrib/gcc/reload.c

@@ -244,7 +244,8 @@ static int push_secondary_reload PARAMS ((int, rtx, int, int, enum reg_class,
 					enum machine_mode, enum reload_type,
 					enum insn_code *));
 #endif
-static enum reg_class find_valid_class PARAMS ((enum machine_mode, int));
+static enum reg_class find_valid_class PARAMS ((enum machine_mode, int,
+						unsigned int));
 static int reload_inner_reg_of_subreg PARAMS ((rtx, enum machine_mode));
 static void push_replacement	PARAMS ((rtx *, int, enum machine_mode));
 static void combine_reloads	PARAMS ((void));
@@ -665,17 +666,22 @@ clear_secondary_mem ()
 #endif /* SECONDARY_MEMORY_NEEDED */
 
 /* Find the largest class for which every register number plus N is valid in
-   M1 (if in range).  Abort if no such class exists.  */
+   M1 (if in range) and is cheap to move into REGNO.
+   Abort if no such class exists.  */
 
 static enum reg_class
-find_valid_class (m1, n)
+find_valid_class (m1, n, dest_regno)
      enum machine_mode m1 ATTRIBUTE_UNUSED;
      int n;
+     unsigned int dest_regno;
 {
+  int best_cost = -1;
   int class;
   int regno;
   enum reg_class best_class = NO_REGS;
+  enum reg_class dest_class = REGNO_REG_CLASS (dest_regno);
   unsigned int best_size = 0;
+  int cost;
 
   for (class = 1; class < N_REG_CLASSES; class++)
     {
@@ -686,8 +692,18 @@ find_valid_class (m1, n)
 	    && ! HARD_REGNO_MODE_OK (regno + n, m1))
 	  bad = 1;
 
-      if (! bad && reg_class_size[class] > best_size)
-	best_class = class, best_size = reg_class_size[class];
+      if (bad)
+	continue;
+      cost = REGISTER_MOVE_COST (m1, class, dest_class);
+
+      if ((reg_class_size[class] > best_size
+	   && (best_cost < 0 || best_cost >= cost))
+	  || best_cost > cost)
+	{
+	  best_class = class;
+	  best_size = reg_class_size[class];
+	  best_cost = REGISTER_MOVE_COST (m1, class, dest_class);
+	}
     }
 
   if (best_size == 0)
@@ -1045,7 +1061,8 @@ push_reload (in, out, inloc, outloc, class,
 			      subreg_regno_offset (REGNO (SUBREG_REG (in)),
 						   GET_MODE (SUBREG_REG (in)),
 						   SUBREG_BYTE (in),
-						   GET_MODE (in)));
+						   GET_MODE (in)),
+			      REGNO (SUBREG_REG (in)));
 
       /* This relies on the fact that emit_reload_insns outputs the
 	 instructions for input reloads of type RELOAD_OTHER in the same
@@ -1145,7 +1162,8 @@ push_reload (in, out, inloc, outloc, class,
 				     subreg_regno_offset (REGNO (SUBREG_REG (out)),
 							  GET_MODE (SUBREG_REG (out)),
 							  SUBREG_BYTE (out),
-							  GET_MODE (out))),
+							  GET_MODE (out)),
+				     REGNO (SUBREG_REG (out))),
 		   VOIDmode, VOIDmode, 0, 0,
 		   opnum, RELOAD_OTHER);
     }