- rel 6; branch diff update; gcc-multilib R: libgcc-multilib added

[packages/gcc.git] / gcc-branch.diff

Index: configure
===================================================================
--- configure	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ configure	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -7337,6 +7337,12 @@
 #line 7338 "configure"
 #include "confdefs.h"
 
+#if (__GNUC__ < 3) \
+    || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
+			  || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
+#error http://gcc.gnu.org/PR29382
+#endif
+    
 int main() {
 
 ; return 0; }
Index: gcc/tree-vrp.c
===================================================================
--- gcc/tree-vrp.c	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ gcc/tree-vrp.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -195,7 +195,28 @@
 	      || operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0)));
 }
 
+/* If VAL is now an overflow infinity, return VAL.  Otherwise, return
+   the same value with TREE_OVERFLOW clear.  This can be used to avoid
+   confusing a regular value with an overflow value.  */
 
+static inline tree
+avoid_overflow_infinity (tree val)
+{
+  if (!is_overflow_infinity (val))
+    return val;
+
+  if (operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0))
+    return TYPE_MAX_VALUE (TREE_TYPE (val));
+  else
+    {
+#ifdef ENABLE_CHECKING
+      gcc_assert (operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0));
+#endif
+      return TYPE_MIN_VALUE (TREE_TYPE (val));
+    }
+}
+
+
 /* Return whether VAL is equal to the maximum value of its type.  This
    will be true for a positive overflow infinity.  We can't do a
    simple equality comparison with TYPE_MAX_VALUE because C typedefs
@@ -351,23 +372,11 @@
    infinity when we shouldn't.  */
 
 static inline void
-set_value_range_to_value (value_range_t *vr, tree val)
+set_value_range_to_value (value_range_t *vr, tree val, bitmap equiv)
 {
   gcc_assert (is_gimple_min_invariant (val));
-  if (is_overflow_infinity (val))
-    {
-      if (operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0))
-	val = TYPE_MAX_VALUE (TREE_TYPE (val));
-      else
-	{
-#ifdef ENABLE_CHECKING
-	  gcc_assert (operand_equal_p (val,
-				       TYPE_MIN_VALUE (TREE_TYPE (val)), 0));
-#endif
-	  val = TYPE_MIN_VALUE (TREE_TYPE (val));
-	}
-    }
-  set_value_range (vr, VR_RANGE, val, val, NULL);
+  val = avoid_overflow_infinity (val);
+  set_value_range (vr, VR_RANGE, val, val, equiv);
 }
 
 /* Set value range VR to a non-negative range of type TYPE.
@@ -411,8 +420,7 @@
 static inline void
 set_value_range_to_null (value_range_t *vr, tree type)
 {
-  tree zero = build_int_cst (type, 0);
-  set_value_range (vr, VR_RANGE, zero, zero, vr->equiv);
+  set_value_range_to_value (vr, build_int_cst (type, 0), vr->equiv);
 }
 
 
@@ -763,7 +771,9 @@
       if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (val1)))
 	return -2;
 
-      if (strict_overflow_p != NULL)
+      if (strict_overflow_p != NULL
+	  && (code1 == SSA_NAME || !TREE_NO_WARNING (val1))
+	  && (code2 == SSA_NAME || !TREE_NO_WARNING (val2)))
 	*strict_overflow_p = true;
 
       if (code1 == SSA_NAME)
@@ -1028,6 +1038,8 @@
       cond_code = swap_tree_comparison (TREE_CODE (cond));
     }
 
+  limit = avoid_overflow_infinity (limit);
+
   type = TREE_TYPE (limit);
   gcc_assert (limit != var);
 
@@ -1167,6 +1179,8 @@
 	    {
 	      tree one = build_int_cst (type, 1);
 	      max = fold_build2 (MINUS_EXPR, type, max, one);
+	      if (EXPR_P (max))
+		TREE_NO_WARNING (max) = 1;
 	    }
 
 	  set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
@@ -1200,6 +1214,8 @@
 	    {
 	      tree one = build_int_cst (type, 1);
 	      min = fold_build2 (PLUS_EXPR, type, min, one);
+	      if (EXPR_P (min))
+		TREE_NO_WARNING (min) = 1;
 	    }
 
 	  set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
@@ -1619,7 +1635,7 @@
   if (TREE_CODE (op0) == SSA_NAME)
     vr0 = *(get_value_range (op0));
   else if (is_gimple_min_invariant (op0))
-    set_value_range_to_value (&vr0, op0);
+    set_value_range_to_value (&vr0, op0, NULL);
   else
     set_value_range_to_varying (&vr0);
 
@@ -1627,7 +1643,7 @@
   if (TREE_CODE (op1) == SSA_NAME)
     vr1 = *(get_value_range (op1));
   else if (is_gimple_min_invariant (op1))
-    set_value_range_to_value (&vr1, op1);
+    set_value_range_to_value (&vr1, op1, NULL);
   else
     set_value_range_to_varying (&vr1);
 
@@ -2006,7 +2022,7 @@
   if (TREE_CODE (op0) == SSA_NAME)
     vr0 = *(get_value_range (op0));
   else if (is_gimple_min_invariant (op0))
-    set_value_range_to_value (&vr0, op0);
+    set_value_range_to_value (&vr0, op0, NULL);
   else
     set_value_range_to_varying (&vr0);
 
@@ -2393,7 +2409,10 @@
 	 its type may be different from _Bool.  Convert VAL to EXPR's
 	 type.  */
       val = fold_convert (TREE_TYPE (expr), val);
-      set_value_range (vr, VR_RANGE, val, val, vr->equiv);
+      if (is_gimple_min_invariant (val))
+	set_value_range_to_value (vr, val, vr->equiv);
+      else
+	set_value_range (vr, VR_RANGE, val, val, vr->equiv);
     }
   else
     set_value_range_to_varying (vr);
@@ -2424,7 +2443,7 @@
   else if (TREE_CODE_CLASS (code) == tcc_comparison)
     extract_range_from_comparison (vr, expr);
   else if (is_gimple_min_invariant (expr))
-    set_value_range_to_value (vr, expr);
+    set_value_range_to_value (vr, expr, NULL);
   else
     set_value_range_to_varying (vr);
 
@@ -2545,6 +2564,13 @@
 	      if (compare_values (min, max) == 1)
 		return;
 	    }
+
+	  /* According to the loop information, the variable does not
+	     overflow.  If we think it does, probably because of an
+	     overflow due to arithmetic on a different INF value,
+	     reset now.  */
+	  if (is_negative_overflow_infinity (min))
+	    min = tmin;
 	}
       else
 	{
@@ -2557,13 +2583,62 @@
 	      if (compare_values (min, max) == 1)
 		return;
 	    }
+
+	  if (is_positive_overflow_infinity (max))
+	    max = tmax;
 	}
 
       set_value_range (vr, VR_RANGE, min, max, vr->equiv);
     }
 }
 
+/* Return true if VAR may overflow at STMT.  This checks any available
+   loop information to see if we can determine that VAR does not
+   overflow.  */
 
+static bool
+vrp_var_may_overflow (tree var, tree stmt)
+{
+  struct loop *l;
+  tree chrec, init, step;
+
+  if (current_loops == NULL)
+    return true;
+
+  l = loop_containing_stmt (stmt);
+  if (l == NULL)
+    return true;
+
+  chrec = instantiate_parameters (l, analyze_scalar_evolution (l, var));
+  if (TREE_CODE (chrec) != POLYNOMIAL_CHREC)
+    return true;
+
+  init = initial_condition_in_loop_num (chrec, l->num);
+  step = evolution_part_in_loop_num (chrec, l->num);
+
+  if (step == NULL_TREE
+      || !is_gimple_min_invariant (step)
+      || !valid_value_p (init))
+    return true;
+
+  /* If we get here, we know something useful about VAR based on the
+     loop information.  If it wraps, it may overflow.  */
+
+  if (scev_probably_wraps_p (init, step, stmt,
+			     current_loops->parray[CHREC_VARIABLE (chrec)],
+			     true))
+    return true;
+
+  if (dump_file && (dump_flags & TDF_DETAILS) != 0)
+    {
+      print_generic_expr (dump_file, var, 0);
+      fprintf (dump_file, ": loop information indicates does not overflow\n");
+    }
+
+  return false;
+}
+
+
 /* Given two numeric value ranges VR0, VR1 and a comparison code COMP:
    
    - Return BOOLEAN_TRUE_NODE if VR0 COMP VR1 always returns true for
@@ -4156,7 +4231,7 @@
       t = retval = NULL_TREE;
       EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2)
 	{
-	  bool sop;
+	  bool sop = false;
 
 	  value_range_t vr2 = *(vr_value[i2]);
 
@@ -4773,7 +4848,8 @@
 	      if (vrp_val_is_max (vr_result.max))
 		goto varying;
 
-	      if (!needs_overflow_infinity (TREE_TYPE (vr_result.min)))
+	      if (!needs_overflow_infinity (TREE_TYPE (vr_result.min))
+		  || !vrp_var_may_overflow (lhs, phi))
 		vr_result.min = TYPE_MIN_VALUE (TREE_TYPE (vr_result.min));
 	      else if (supports_overflow_infinity (TREE_TYPE (vr_result.min)))
 		vr_result.min =
@@ -4791,7 +4867,8 @@
 	      if (vrp_val_is_min (vr_result.min))
 		goto varying;
 
-	      if (!needs_overflow_infinity (TREE_TYPE (vr_result.max)))
+	      if (!needs_overflow_infinity (TREE_TYPE (vr_result.max))
+		  || !vrp_var_may_overflow (lhs, phi))
 		vr_result.max = TYPE_MAX_VALUE (TREE_TYPE (vr_result.max));
 	      else if (supports_overflow_infinity (TREE_TYPE (vr_result.max)))
 		vr_result.max =
@@ -4971,6 +5048,8 @@
 	{
 	  tree one = build_int_cst (TREE_TYPE (op0), 1);
 	  max = fold_build2 (MINUS_EXPR, TREE_TYPE (op0), max, one);
+	  if (EXPR_P (max))
+	    TREE_NO_WARNING (max) = 1;
 	}
     }
   else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
@@ -4984,6 +5063,8 @@
 	{
 	  tree one = build_int_cst (TREE_TYPE (op0), 1);
 	  min = fold_build2 (PLUS_EXPR, TREE_TYPE (op0), min, one);
+	  if (EXPR_P (min))
+	    TREE_NO_WARNING (min) = 1;
 	}
     }
 
Index: gcc/DATESTAMP
===================================================================
--- gcc/DATESTAMP	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ gcc/DATESTAMP	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -1 +1 @@
-20070514
+20070609
Index: gcc/pointer-set.c
===================================================================
--- gcc/pointer-set.c	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ gcc/pointer-set.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -22,13 +22,12 @@
 #include "system.h"
 #include "pointer-set.h"
 
-/* A pointer sets is represented as a simple open-addressing hash
+/* A pointer set is represented as a simple open-addressing hash
    table.  Simplifications: The hash code is based on the value of the
    pointer, not what it points to.  The number of buckets is always a
    power of 2.  Null pointers are a reserved value.  Deletion is not
-   supported.  There is no mechanism for user control of hash
-   function, equality comparison, initial size, or resizing policy.
-*/
+   supported (yet).  There is no mechanism for user control of hash
+   function, equality comparison, initial size, or resizing policy.  */
 
 struct pointer_set_t
 {
@@ -114,22 +113,16 @@
     }
 }
 
-/* Subroutine of pointer_set_insert.  Inserts P into an empty
-   element of SLOTS, an array of length N_SLOTS.  Returns nonzero
-   if P was already present in N_SLOTS.  */
-static int
+/* Subroutine of pointer_set_insert.  Return the insertion slot for P into
+   an empty element of SLOTS, an array of length N_SLOTS.  */
+static inline size_t
 insert_aux (void *p, void **slots, size_t n_slots, size_t log_slots)
 {
   size_t n = hash1 (p, n_slots, log_slots);
   while (true)
     {
-      if (slots[n] == p)
-	return 1;
-      else if (slots[n] == 0)
-	{
-	  slots[n] = p;
-	  return 0;
-	}
+      if (slots[n] == p || slots[n] == 0)
+	return n;
       else
 	{
 	  ++n;
@@ -144,12 +137,10 @@
 int
 pointer_set_insert (struct pointer_set_t *pset, void *p)
 {
-  if (insert_aux (p, pset->slots, pset->n_slots, pset->log_slots))
-    return 1;
-      
-  /* We've inserted a new element.  Expand the table if necessary to keep
-     the load factor small.  */
-  ++pset->n_elements;
+  size_t n;
+
+  /* For simplicity, expand the set even if P is already there.  This can be
+     superfluous but can happen at most once.  */
   if (pset->n_elements > pset->n_slots / 4)
     {
       size_t new_log_slots = pset->log_slots + 1;
@@ -158,9 +149,10 @@
       size_t i;
 
       for (i = 0; i < pset->n_slots; ++i)
-	{
-	  if (pset->slots[i])
-	    insert_aux (pset->slots[i], new_slots, new_n_slots, new_log_slots);
+        {
+	  void *value = pset->slots[i];
+	  n = insert_aux (value, new_slots, new_n_slots, new_log_slots);
+	  new_slots[n] = value;
 	}
 
       XDELETEVEC (pset->slots);
@@ -169,5 +161,144 @@
       pset->slots = new_slots;
     }
 
+  n = insert_aux (p, pset->slots, pset->n_slots, pset->log_slots);
+  if (pset->slots[n])
+    return 1;
+
+  pset->slots[n] = p;
+  ++pset->n_elements;
   return 0;
 }
+
+/* Pass each pointer in PSET to the function in FN, together with the fixed
+   parameter DATA.  If FN returns false, the iteration stops.  */
+
+void pointer_set_traverse (struct pointer_set_t *pset,
+			   bool (*fn) (void *, void *), void *data)
+{
+  size_t i;
+  for (i = 0; i < pset->n_slots; ++i)
+    if (pset->slots[i] && !fn (pset->slots[i], data))
+      break;
+}
+
+\f
+/* A pointer map is represented the same way as a pointer_set, so
+   the hash code is based on the address of the key, rather than
+   its contents.  Null keys are a reserved value.  Deletion is not
+   supported (yet).  There is no mechanism for user control of hash
+   function, equality comparison, initial size, or resizing policy.  */
+
+struct pointer_map_t
+{
+  size_t log_slots;
+  size_t n_slots;		/* n_slots = 2^log_slots */
+  size_t n_elements;
+
+  void **keys;
+  void **values;
+};
+
+/* Allocate an empty pointer map.  */
+struct pointer_map_t *
+pointer_map_create (void)
+{
+  struct pointer_map_t *result = XNEW (struct pointer_map_t);
+
+  result->n_elements = 0;
+  result->log_slots = 8;
+  result->n_slots = (size_t) 1 << result->log_slots;
+
+  result->keys = XCNEWVEC (void *, result->n_slots);
+  result->values = XCNEWVEC (void *, result->n_slots);
+  return result;
+}
+
+/* Reclaims all memory associated with PMAP.  */
+void pointer_map_destroy (struct pointer_map_t *pmap)
+{
+  XDELETEVEC (pmap->keys);
+  XDELETEVEC (pmap->values);
+  XDELETE (pmap);
+}
+
+/* Returns a pointer to the value to which P maps, if PMAP contains P.  P
+   must be nonnull.  Return NULL if PMAP does not contain P.
+
+   Collisions are resolved by linear probing.  */
+void **
+pointer_map_contains (struct pointer_map_t *pmap, void *p)
+{
+  size_t n = hash1 (p, pmap->n_slots, pmap->log_slots);
+
+  while (true)
+    {
+      if (pmap->keys[n] == p)
+	return &pmap->values[n];
+      else if (pmap->keys[n] == 0)
+	return NULL;
+      else
+       {
+         ++n;
+         if (n == pmap->n_slots)
+           n = 0;
+       }
+    }
+}
+
+/* Inserts P into PMAP if it wasn't already there.  Returns a pointer
+   to the value.  P must be nonnull.  */
+void **
+pointer_map_insert (struct pointer_map_t *pmap, void *p)
+{
+  size_t n;
+
+  /* For simplicity, expand the map even if P is already there.  This can be
+     superfluous but can happen at most once.  */
+  if (pmap->n_elements > pmap->n_slots / 4)
+    {
+      size_t new_log_slots = pmap->log_slots + 1;
+      size_t new_n_slots = pmap->n_slots * 2;
+      void **new_keys = XCNEWVEC (void *, new_n_slots);
+      void **new_values = XCNEWVEC (void *, new_n_slots);
+      size_t i;
+
+      for (i = 0; i < pmap->n_slots; ++i)
+	if (pmap->keys[i])
+	  {
+	    void *key = pmap->keys[i];
+	    n = insert_aux (key, new_keys, new_n_slots, new_log_slots);
+	    new_keys[n] = key;
+	    new_values[n] = pmap->values[i];
+	  }
+
+      XDELETEVEC (pmap->keys);
+      XDELETEVEC (pmap->values);
+      pmap->n_slots = new_n_slots;
+      pmap->log_slots = new_log_slots;
+      pmap->keys = new_keys;
+      pmap->values = new_values;
+    }
+
+  n = insert_aux (p, pmap->keys, pmap->n_slots, pmap->log_slots);
+  if (!pmap->keys[n])
+    {
+      ++pmap->n_elements;
+      pmap->keys[n] = p;
+    }
+
+  return &pmap->values[n];
+}
+
+/* Pass each pointer in PMAP to the function in FN, together with the pointer
+   to the value and the fixed parameter DATA.  If FN returns false, the
+   iteration stops.  */
+
+void pointer_map_traverse (struct pointer_map_t *pmap,
+			   bool (*fn) (void *, void **, void *), void *data)
+{
+  size_t i;
+  for (i = 0; i < pmap->n_slots; ++i)
+    if (pmap->keys[i] && !fn (pmap->keys[i], &pmap->values[i], data))
+      break;
+}
Index: gcc/pointer-set.h
===================================================================
--- gcc/pointer-set.h	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ gcc/pointer-set.h	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -22,11 +22,21 @@
 #define POINTER_SET_H
 
 struct pointer_set_t;
-
 struct pointer_set_t *pointer_set_create (void);
 void pointer_set_destroy (struct pointer_set_t *pset);
 
 int pointer_set_contains (struct pointer_set_t *pset, void *p);
 int pointer_set_insert (struct pointer_set_t *pset, void *p);
+void pointer_set_traverse (struct pointer_set_t *, bool (*) (void *, void *),
+			   void *);
 
+struct pointer_map_t;
+struct pointer_map_t *pointer_map_create (void);
+void pointer_map_destroy (struct pointer_map_t *pmap);
+
+void **pointer_map_contains (struct pointer_map_t *pmap, void *p);
+void **pointer_map_insert (struct pointer_map_t *pmap, void *p);
+void pointer_map_traverse (struct pointer_map_t *,
+			   bool (*) (void *, void **, void *), void *);
+
 #endif  /* POINTER_SET_H  */
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ gcc/fold-const.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -4450,13 +4450,24 @@
 	{
 	  low = range_successor (high1);
 	  high = high0;
-	  in_p = (low != 0);
+	  in_p = 1;
+	  if (low == 0)
+	    {
+	      /* We are in the weird situation where high0 > high1 but
+		 high1 has no successor.  Punt.  */
+	      return 0;
+	    }
 	}
       else if (! subset || highequal)
 	{
 	  low = low0;
 	  high = range_predecessor (low1);
-	  in_p = (high != 0);
+	  in_p = 1;
+	  if (high == 0)
+	    {
+	      /* low0 < low1 but low1 has no predecessor.  Punt.  */
+	      return 0;
+	    }
 	}
       else
 	return 0;
@@ -4476,7 +4487,12 @@
 	{
 	  low = range_successor (high0);
 	  high = high1;
-	  in_p = (low != 0);
+	  in_p = 1;
+	  if (low == 0)
+	    {
+	      /* high1 > high0 but high0 has no successor.  Punt.  */
+	      return 0;
+	    }
 	}
     }
 
@@ -12634,9 +12650,14 @@
       /* ... fall through ...  */
 
     default:
-      if (truth_value_p (TREE_CODE (t)))
-	/* Truth values evaluate to 0 or 1, which is nonnegative.  */
-	return 1;
+      {
+	tree type = TREE_TYPE (t);
+	if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
+	    && truth_value_p (TREE_CODE (t)))
+	  /* Truth values evaluate to 0 or 1, which is nonnegative unless we
+             have a signed:1 type (where the value is -1 and 0).  */
+	  return true;
+      }
     }
 
   /* We don't know sign of `t', so be conservative and return false.  */
Index: gcc/DEV-PHASE
===================================================================
--- gcc/DEV-PHASE	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ gcc/DEV-PHASE	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1 @@
+prerelease
Index: gcc/ChangeLog
===================================================================
--- gcc/ChangeLog	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ gcc/ChangeLog	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -1,3 +1,201 @@
+2007-06-08  Kaz Kojima  <kkojima@gcc.gnu.org>
+
+	PR target/32163
+	Backport from mainline.
+	* config/sh/sh.md (symGOT_load): Don't schedule insns when
+	the symbol is generated with the stack protector.
+
+2007-06-06  Ian Lance Taylor  <iant@google.com>
+
+	* fold-const.c (merge_ranges): If range_successor or
+	range_predecessor fail, just return 0.
+
+2007-06-05  Ian Lance Taylor  <iant@google.com>
+
+	* tree-vrp.c (compare_values_warnv): Check TREE_NO_WARNING on a
+	PLUS_EXPR or MINUS_EXPR node before setting *strict_overflow_p.
+	(extract_range_from_assert): Set TREE_NO_WARNING when creating an
+	expression.
+	(test_for_singularity): Likewise.
+
+2007-06-04  Ian Lance Taylor  <iant@google.com>
+
+	* tree-vrp.c (adjust_range_with_scev): When loop is not expected
+	to overflow, reduce overflow infinity to regular infinity.
+	(vrp_var_may_overflow): New static function.
+	(vrp_visit_phi_node): Check vrp_var_may_overflow.
+
+2007-05-31  H.J. Lu  <hongjiu.lu@intel.com>
+
+	Backport from mainline:
+	2007-05-25  H.J. Lu  <hongjiu.lu@intel.com>
+
+	* config/i386/i386.c (__builtin_ia32_vec_ext_v2df): Mark it
+	with MASK_SSE2.
+	(__builtin_ia32_vec_ext_v2di): Likewise.
+	(__builtin_ia32_vec_ext_v4si): Likewise.
+	(__builtin_ia32_vec_ext_v8hi): Likewise.
+	(__builtin_ia32_vec_set_v8hi): Likewise.
+
+2007-05-31  John David Anglin  <dave.anglin@nrc-cnrc.gc.ca>
+
+	Backport from mainline:
+	2007-05-05  Aurelien Jarno  <aurelien@aurel32.net>
+
+	* config/pa/pa.md: Split tgd_load, tld_load and tie_load
+	into pic and non-pic versions. Mark r19 as used for 
+	tgd_load_pic, tld_load_pic and tie_load_pic. Mark r27 as used 
+	for tgd_load, tld_load and tie_load .
+	* config/pa/pa.c (legitimize_tls_address): Emit pic or non-pic
+	version of tgd_load, tld_load and tie_load depending on the 
+	value of flag_pic.
+
+2007-05-27  Daniel Berlin <dberlin@dberlin.org>
+
+	Fix PR/30052
+	Backport PTA solver from mainline
+
+	* pointer-set.c: Copy from mainline
+	* pointer-set.h: Ditto.
+	* tree-ssa-structalias.c: Copy solver portions from mainline.
+	* Makefile.in (tree-ssa-structalias.o): Update dependencies
+
+2007-05-30  Ralf Wildenhues  <Ralf.Wildenhues@gmx.de>
+
+	* tree-vrp.c (compare_names): Initialize sop.
+
+2007-05-30  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/31769
+	* except.c (duplicate_eh_regions): Clear prev_try if
+	ERT_MUST_NOT_THROW region is inside of ERT_TRY region.
+
+2007-05-28  Andrew Pinski  <andrew_pinski@playstation.sony.com>
+
+	PR tree-opt/32100
+	* fold-const.c (tree_expr_nonnegative_warnv_p): Don't
+	return true when truth_value_p is true and the type
+	is of signed:1.
+
+2007-05-27  H.J. Lu  <hongjiu.lu@intel.com>
+
+	Backport from mainline:
+	2007-05-25  Uros Bizjak  <ubizjak@gmail.com>
+
+	* config/i386/sse.md (*vec_extractv2di_1_sse2): Do not calculate
+	"memory" attribute for "sseishft" type insn without operands[2].
+
+	2007-05-25  H.J. Lu  <hongjiu.lu@intel.com>
+
+	* config/i386/sse.md (*vec_extractv2di_1_sse2): Correct shift.
+
+2007-05-22  Ian Lance Taylor  <iant@google.com>
+
+	* tree-vrp.c (avoid_overflow_infinity): New static function,
+	broken out of set_value_range_to_value.
+	(set_value_range_to_value): Call avoid_overflow_infinity.
+	(extract_range_from_assert): Likewise.
+
+2007-05-23  Chen Liqin  <liqin@sunnorth.com.cn>
+
+	PR target/30987
+	* config/score/misc.md (bitclr_c, bitset_c, bittgl_c): remove.
+	* config/score/predicate.md (const_pow2, const_npow2): remove.
+	* config/score/score.h (ASM_OUTPUT_EXTERNAL): add ASM_OUTPUT_EXTERNAL undef.
+	PR target/30474
+	* config/score/score.c (score_print_operand): makes sure that only lower 
+	bits are used.
+	
+2007-05-21  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/31167
+	Backport from mainline.
+	* config/i386/i386.md (*addti3_1, *addti3_1 splitter): Use
+	x86_64_general_operand as operand[2] predicate.  Remove "iF"
+	from operand constraints and use "e" constraint instead.
+	(*subti3_1, *subti3_1 splitter): Ditto.
+	(*negti2_1, *negti2_1 splitter): Use nonimmediate_operand as
+	operand[1] predicate.
+
+2007-05-21  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/30041
+	Backport from mainline.
+	* config/i386/sse.md ("*sse3_movddup"): Use operands[0] and
+	operands[1] in insn constraint.  Correct type attribute to sselog1.
+
+2007-05-20  Kaz Kojima  <kkojima@gcc.gnu.org>
+
+	PR target/31701
+	Backport from mainline.
+	* config/sh/sh.c (output_stack_adjust): Avoid using the frame
+	register itself to hold the offset constant.  Tell flow the use
+	of r4 and r5 when they are used.
+
+2007-05-20  Kaz Kojima  <kkojima@gcc.gnu.org>
+
+	PR target/31480
+	Backport from mainline.
+	* config/sh/sh.md (length): Check if prev_nonnote_insn (insn)
+	is null.
+
+2007-05-20  Kaz Kojima  <kkojima@gcc.gnu.org>
+
+	PR target/31022
+	Backport from mainline.
+	* config/sh/sh.c (sh_adjust_cost): Use the result of single_set
+	instead of PATTERN.
+
+2007-05-20  Kaz Kojima  <kkojima@gcc.gnu.org>
+
+	PR target/27405
+	Backport from mainline.
+	* config/sh/sh.md (cmp{eq,gt,gtu}{si,di}_media): Remove.
+	(cmpsi{eq,gt,gtu}{si,di}_media): Rename to
+	cmp{eq,gt,gtu}{si,di}_media.
+	(*cmpne0si_media): Remove.
+	(*movsicc_umin): Adjust gen_cmp*_media call.
+	(unordered): Change the mode of unordered and operands[1] to
+	SImode.
+	(seq): Adjust gen_cmp*_media calls.  Make the mode of
+	a temporary result of compare SImode if needed.  If the mode
+	of operands[0] is DImode, extend the temporary result to DImode.
+	(slt, sle, sgt, sge, sgtu, sltu, sleu, sgue, sne): Likewise.
+	(sunorderd): Change the mode of match_operand and unorderd to
+	SImode.
+	(cmpeq{sf,df}_media): Remove.
+	(cmpsieq{sf,df}_media): Rename to cmpeq{sf,df}_media.
+	(cmp{gt,ge,un}{sf,df}_media): Change the mode of match_operand
+	and compare operation to SImode.
+
+2007-05-18  Joseph Myers  <joseph@codesourcery.com>
+
+	* config/soft-fp/double.h, config/soft-fp/extended.h,
+	config/soft-fp/floatundidf.c, config/soft-fp/floatundisf.c,
+	config/soft-fp/floatunsidf.c, config/soft-fp/floatunsisf.c,
+	config/soft-fp/op-2.h, config/soft-fp/op-4.h,
+	config/soft-fp/op-common.h, config/soft-fp/quad.h: Update from
+	glibc CVS.
+
+2007-05-17  Ian Lance Taylor  <iant@google.com>
+
+	PR tree-optimization/31953
+	* tree-vrp.c (set_value_range_to_value): Add equiv parameter.
+	Change all callers.
+	(set_value_range_to_null): Call set_value_range_to_value.
+	(extract_range_from_comparison): Likewise.
+
+2007-05-17  Eric Botcazou  <ebotcazou@libertysurf.fr>
+
+	PR rtl-optimization/31691
+	* combine.c (simplify_set): Build a new src pattern instead of
+	substituting its operands in the COMPARE case.
+
+2007-05-14  Mark Mitchell  <mark@codesourcery.com>
+
+	* BASE-VER: Set to 4.2.1.
+	* DEV-PHASE: Set to prerelease.
+
 2007-05-13  Release Manager
 
 	* GCC 4.2.0 released.
@@ -307,7 +505,8 @@
 2007-04-03  Stuart Hastings  <stuart@apple.com>
 
 	PR 31281
-	* objc/objc-act.c (next_sjlj_build_catch_list): Delete volatile from rethrow decl.
+	* objc/objc-act.c (next_sjlj_build_catch_list): Delete volatile
+	from rethrow decl.
 	* cse.c (record_jump_equiv): Bail out on CCmode comparisons.
 
 2007-04-03  Jakub Jelinek  <jakub@redhat.com>
Index: gcc/testsuite/gcc.c-torture/execute/vrp-7.c
===================================================================
--- gcc/testsuite/gcc.c-torture/execute/vrp-7.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.c-torture/execute/vrp-7.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,20 @@
+
+void abort (void);
+
+struct T
+{
+  int b : 1;
+} t;
+
+void __attribute__((noinline)) foo (int f)
+{
+  t.b = (f & 0x10) ? 1 : 0;
+}
+
+int main (void)
+{
+  foo (0x10);
+  if (!t.b)
+    abort ();
+  return 0;
+}
Index: gcc/testsuite/gcc.c-torture/execute/20070517-1.c
===================================================================
--- gcc/testsuite/gcc.c-torture/execute/20070517-1.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.c-torture/execute/20070517-1.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,41 @@
+/* PR rtl-optimization/31691 */
+/* Origin: Chi-Hua Chen <stephaniechc-gccbug@yahoo.com> */
+
+extern void abort (void);
+
+static int get_kind(int) __attribute__ ((noinline));
+
+static int get_kind(int v)
+{
+  volatile int k = v;
+  return k;
+}
+
+static int some_call(void) __attribute__ ((noinline));
+
+static int some_call(void)
+{
+  return 0;
+}
+
+static void example (int arg)
+{
+  int tmp, kind = get_kind (arg);
+
+  if (kind == 9 || kind == 10 || kind == 5)
+    {
+      if (some_call() == 0)
+        {
+          if (kind == 9 || kind == 10)
+            tmp = arg;
+          else
+            abort();
+        }
+    }
+} 
+
+int main(void)
+{
+  example(10);
+  return 0;
+}
Index: gcc/testsuite/gcc.c-torture/compile/pr31953.c
===================================================================
--- gcc/testsuite/gcc.c-torture/compile/pr31953.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.c-torture/compile/pr31953.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,14 @@
+struct WView
+{
+  int hexedit_mode:1;
+};
+toggle_hexedit_mode (struct WView *view)
+{
+  if (view->hexedit_mode)
+    {
+    }
+  else
+    {
+      view->hexedit_mode = !view->hexedit_mode;
+    }
+}
Index: gcc/testsuite/gcc.target/i386/sse2-vec-3.c
===================================================================
--- gcc/testsuite/gcc.target/i386/sse2-vec-3.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.target/i386/sse2-vec-3.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,37 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-O2 -msse2" } */
+
+#include "sse2-check.h"
+
+#include <emmintrin.h>
+
+static void
+sse2_test (void)
+{
+  union
+    {
+      __m128i x;
+      char c[16];
+      short s[8];
+      int i[4];
+      long long ll[2];
+    } val1;
+  int res[4];
+  int masks[4];
+  int i;
+
+  for (i = 0; i < 16; i++)
+    val1.c[i] = i;
+
+  res[0] = __builtin_ia32_vec_ext_v4si ((__v4si)val1.x, 0);
+  res[1] = __builtin_ia32_vec_ext_v4si ((__v4si)val1.x, 1);
+  res[2] = __builtin_ia32_vec_ext_v4si ((__v4si)val1.x, 2);
+  res[3] = __builtin_ia32_vec_ext_v4si ((__v4si)val1.x, 3);
+
+  for (i = 0; i < 4; i++)
+    masks[i] = i;
+
+  for (i = 0; i < 4; i++)
+    if (res[i] != val1.i [masks[i]])
+      abort ();
+}
Index: gcc/testsuite/gcc.target/i386/pr31167.c
===================================================================
--- gcc/testsuite/gcc.target/i386/pr31167.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.target/i386/pr31167.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,20 @@
+/* { dg-do compile { target x86_64-*-* } } */
+/* { dg-options "-O" } */
+
+typedef int int32_t;
+
+int32_t round32hi (const __int128_t arg)
+{
+  const int SHIFT = 96;
+  const int mshift = 96;
+  const __int128_t M = (~(__int128_t) 0) << mshift;
+  const __int128_t L = (~M) + 1;
+  const __int128_t L1 = ((__int128_t) L) >> 1;
+  const __int128_t Mlo = ((__int128_t) (~M)) >> 1;
+  __int128_t vv = arg & M;
+
+  if ((arg & (L1)) && ((arg & Mlo) || (arg & L)))
+    vv += L;
+
+  return (int32_t) (vv >> SHIFT);
+}
Index: gcc/testsuite/gcc.target/i386/sse2-vec-4.c
===================================================================
--- gcc/testsuite/gcc.target/i386/sse2-vec-4.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.target/i386/sse2-vec-4.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,41 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-O2 -msse2" } */
+
+#include "sse2-check.h"
+
+#include <emmintrin.h>
+
+static void
+sse2_test (void)
+{
+  union
+    {
+      __m128i x;
+      char c[16];
+      short s[8];
+      int i[4];
+      long long ll[2];
+    } val1;
+  short res[8];
+  int masks[8];
+  int i;
+
+  for (i = 0; i < 16; i++)
+    val1.c[i] = i;
+
+  res[0] = __builtin_ia32_vec_ext_v8hi ((__v8hi)val1.x, 0);
+  res[1] = __builtin_ia32_vec_ext_v8hi ((__v8hi)val1.x, 1);
+  res[2] = __builtin_ia32_vec_ext_v8hi ((__v8hi)val1.x, 2);
+  res[3] = __builtin_ia32_vec_ext_v8hi ((__v8hi)val1.x, 3);
+  res[4] = __builtin_ia32_vec_ext_v8hi ((__v8hi)val1.x, 4);
+  res[5] = __builtin_ia32_vec_ext_v8hi ((__v8hi)val1.x, 5);
+  res[6] = __builtin_ia32_vec_ext_v8hi ((__v8hi)val1.x, 6);
+  res[7] = __builtin_ia32_vec_ext_v8hi ((__v8hi)val1.x, 7);
+
+  for (i = 0; i < 8; i++)
+    masks[i] = i;
+
+  for (i = 0; i < 8; i++)
+    if (res[i] != val1.s [masks[i]])
+      abort ();
+}
Index: gcc/testsuite/gcc.target/i386/sse2-check.h
===================================================================
--- gcc/testsuite/gcc.target/i386/sse2-check.h	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.target/i386/sse2-check.h	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "../../gcc.dg/i386-cpuid.h"
+
+static void sse2_test (void);
+
+int
+main ()
+{
+  unsigned long cpu_facilities;
+ 
+  cpu_facilities = i386_cpuid_edx ();
+
+  /* Run SSE2 test only if host has SSE2 support.  */
+  if ((cpu_facilities & bit_SSE2))
+    sse2_test ();
+
+  exit (0);
+}
Index: gcc/testsuite/gcc.target/i386/sse2-vec-1.c
===================================================================
--- gcc/testsuite/gcc.target/i386/sse2-vec-1.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.target/i386/sse2-vec-1.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,35 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-O2 -msse2" } */
+
+#include "sse2-check.h"
+
+#include <emmintrin.h>
+
+#define msk0   0
+#define msk1   1
+
+static void
+sse2_test (void)
+{
+  union
+    {
+      __m128d x;
+      double d[2];
+    } val1;
+  double res[2];
+  int masks[2];
+  int i;
+
+  val1.d[0] = 23.;
+  val1.d[1] = 45;
+
+  res[0] = __builtin_ia32_vec_ext_v2df ((__v2df)val1.x, msk0);
+  res[1] = __builtin_ia32_vec_ext_v2df ((__v2df)val1.x, msk1);
+
+  masks[0] = msk0;
+  masks[1] = msk1;
+
+  for (i = 0; i < 2; i++)
+    if (res[i] != val1.d [masks[i]])
+      abort ();
+}
Index: gcc/testsuite/gcc.target/i386/sse2-vec-5.c
===================================================================
--- gcc/testsuite/gcc.target/i386/sse2-vec-5.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.target/i386/sse2-vec-5.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,49 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-O2 -msse2" } */
+
+#include "sse2-check.h"
+
+#include <emmintrin.h>
+
+static void
+sse2_test (void)
+{
+  union
+    {
+      __m128i x;
+      char c[16];
+      short s[8];
+      int i[4];
+      long long ll[2];
+    } val1;
+  char res[16];
+  int masks[16];
+  int i;
+
+  for (i = 0; i < 16; i++)
+    val1.c[i] = i;
+
+  res[0] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 0);
+  res[1] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 1);
+  res[2] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 2);
+  res[3] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 3);
+  res[4] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 4);
+  res[5] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 5);
+  res[6] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 6);
+  res[7] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 7);
+  res[8] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 8);
+  res[9] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 9);
+  res[10] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 10);
+  res[11] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 11);
+  res[12] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 12);
+  res[13] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 13);
+  res[14] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 14);
+  res[15] = __builtin_ia32_vec_ext_v16qi ((__v16qi)val1.x, 15);
+
+  for (i = 0; i < 16; i++)
+    masks[i] = i;
+
+  for (i = 0; i < 16; i++)
+    if (res[i] != val1.c [masks[i]])
+      abort ();
+}
Index: gcc/testsuite/gcc.target/i386/sse2-vec-2.c
===================================================================
--- gcc/testsuite/gcc.target/i386/sse2-vec-2.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.target/i386/sse2-vec-2.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,35 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-O2 -msse2" } */
+
+#include "sse2-check.h"
+
+#include <emmintrin.h>
+
+static void
+sse2_test (void)
+{
+  union
+    {
+      __m128i x;
+      char c[16];
+      short s[8];
+      int i[4];
+      long long ll[2];
+    } val1;
+  long long res[2];
+  int masks[2];
+  int i;
+
+  for (i = 0; i < 16; i++)
+    val1.c[i] = i;
+
+  res[0] = __builtin_ia32_vec_ext_v2di ((__v2di)val1.x, 0);
+  res[1] = __builtin_ia32_vec_ext_v2di ((__v2di)val1.x, 1);
+
+  for (i = 0; i < 2; i++)
+    masks[i] = i;
+
+  for (i = 0; i < 2; i++)
+    if (res[i] != val1.ll [masks[i]])
+      abort ();
+}
Index: gcc/testsuite/gcc.target/i386/sse2-vec-6.c
===================================================================
--- gcc/testsuite/gcc.target/i386/sse2-vec-6.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.target/i386/sse2-vec-6.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,69 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-O2 -msse2" } */
+
+#include "sse2-check.h"
+
+#include <emmintrin.h>
+#include <string.h>
+
+static void
+sse2_test (void)
+{
+  union
+    {
+      __m128i x;
+      char c[16];
+      short s[8];
+      int i[4];
+      long long ll[2];
+    } val1, res[16], tmp;
+  short ins[8] = { 8, 5, 9, 4, 2, 6, 1, 20 };
+  int masks[8];
+  int i;
+
+  for (i = 0; i < 16; i++)
+    val1.c[i] = i;
+
+  res[0].x = (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)val1.x,
+						    ins[0], 0);
+  res[1].x = (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)val1.x,
+						    ins[0], 1);
+  res[2].x = (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)val1.x,
+						    ins[0], 2);
+  res[3].x = (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)val1.x,
+						    ins[0], 3);
+  res[4].x = (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)val1.x,
+						    ins[0], 4);
+  res[5].x = (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)val1.x,
+						    ins[0], 5);
+  res[6].x = (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)val1.x,
+						    ins[0], 6);
+  res[7].x = (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)val1.x,
+						    ins[0], 7);
+
+  for (i = 0; i < 8; i++)
+    masks[i] = i;
+
+  for (i = 0; i < 8; i++)
+    {
+      tmp.x = val1.x;
+      tmp.s[masks[i]] = ins[0];
+      if (memcmp (&tmp, &res[i], sizeof (tmp)))
+	abort ();
+    }
+
+  for (i = 0; i < 8; i++)
+    {
+      res[i].x = (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)val1.x,
+							ins[i], 0);
+      masks[i] = 0;
+    }
+
+  for (i = 0; i < 8; i++)
+    {
+      tmp.x = val1.x;
+      tmp.s[masks[i]] = ins[i];
+      if (memcmp (&tmp, &res[i], sizeof (tmp)))
+	abort ();
+    }
+}
Index: gcc/testsuite/gcc.dg/Wstrict-overflow-18.c
===================================================================
--- gcc/testsuite/gcc.dg/Wstrict-overflow-18.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.dg/Wstrict-overflow-18.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow" } */
+
+/* Don't warn about an overflow when folding i > 0.  The loop analysis
+   should determine that i does not wrap.  */
+
+struct c { unsigned int a; unsigned int b; };
+extern void bar (struct c *);
+int
+foo (struct c *p)
+{
+  int i;
+  int sum = 0;
+
+  for (i = 0; i < p->a - p->b; ++i)
+    {
+      if (i > 0)
+	sum += 2;
+      bar (p);
+    }
+  return sum;
+}
Index: gcc/testsuite/gcc.dg/Wstrict-overflow-19.c
===================================================================
--- gcc/testsuite/gcc.dg/Wstrict-overflow-19.c	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gcc.dg/Wstrict-overflow-19.c	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow" } */
+
+/* Don't warn about an overflow when threading jumps.  We used to get
+   a warning from comparing bounds generated by VRP.  */
+
+int
+bar(int a, int b, int n)
+{
+  if (b > a)
+    n = a - b;
+  if (a >= b)
+    n = 1;
+  return n;
+}
Index: gcc/testsuite/ChangeLog
===================================================================
--- gcc/testsuite/ChangeLog	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ gcc/testsuite/ChangeLog	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -1,3 +1,124 @@
+2007-06-08  Dirk Mueller  <dmueller@suse.de>
+
+	PR c++/31809
+	Backport from mainline:
+	2007-05-30  Jakub Jelinek  <jakub@redhat.com>
+
+	* g++.dg/opt/static5.C: New test.
+
+2007-06-06  Ian Lance Taylor  <iant@google.com>
+
+	* g++.dg/conversion/enum1.C: New test.
+
+2007-06-05  Ian Lance Taylor  <iant@google.com>
+
+	* gcc.dg/Wstrict-overflow-19.c: New test.
+
+2007-06-04  Ian Lance Taylor  <iant@google.com>
+
+	* gcc.dg/Wstrict-overflow-18.c: New test.
+
+2007-05-31  H.J. Lu  <hongjiu.lu@intel.com>
+
+	Backport from mainline:
+	2007-05-25  H.J. Lu  <hongjiu.lu@intel.com>
+
+	* gcc.target/i386/sse2-check.h: New.
+	* gcc.target/i386/sse2-vec-1.c: Likewise.
+	* gcc.target/i386/sse2-vec-2.c: Likewise.
+	* gcc.target/i386/sse2-vec-3.c: Likewise.
+	* gcc.target/i386/sse2-vec-4.c: Likewise.
+	* gcc.target/i386/sse2-vec-5.c: Likewise.
+	* gcc.target/i386/sse2-vec-6.c: Likewise.
+
+2007-05-31  Paul Thomas  <pault@gcc.gnu.org>
+
+	PR fortran/31483
+	* gfortran.dg/altreturn_5.f90: New test.
+
+	PR fortran/31540
+	* gfortran.dg/char_result_5.f90: New test.
+
+	PR fortran/31867
+	* gfortran.dg/char_length_5.f90: New test.
+
+	PR fortran/31994
+	* gfortran.dg/array_reference_1.f90: New test.
+
+2007-05-22  Tobias Burnus  <burnus@net-b.de>
+
+	PR fortran/31559
+	Backport from mainline.
+	* primary.c (match_variable): External functions
+	are no variables.
+
+2007-05-30  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/31769
+	* g++.dg/gomp/pr31769.C: New test.
+
+2007-05-28  Andrew Pinski  <andrew_pinski@playstation.sony.com>
+
+	PR tree-opt/32100
+	* gcc.c-torture/execute/vrp-7.c: New test.
+	 
+2007-05-23  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR libfortran/31964
+	* gfortran.fortran-torture/execute/intrinsic_bitops.f90: Update.
+
+2007-05-22  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR libgfortran/31051
+	* gfortran.dg/fmt_t_3.f90: New.
+
+2007-05-22  Dominique d'Humieres  <dominiq@lps.ens.fr>
+
+	* gfortran.dg/unf_io_convert_3.f90: Fix dg directive.
+
+2007-05-22  Tobias Burnus  <burnus@net-b.de>
+
+	PR fortran/31559
+	Backport from mainline.
+	* func_assign.f90: New test.
+
+2007-05-21  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/31167
+	Backport from mainline.
+	* gcc.target/i386/pr31167.c: New test.
+
+2007-05-20  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR libgfortran/31395
+	* gfortran.dg/fmt_colon.f90: New test.
+
+2007-05-20  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/31618
+	Backport from trunk.
+	* gfortran.dg/backspace_8.f:  New test case.
+
+2007-05-20  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR libfortran/31196
+	Backport from trunk.
+	* gfortran.dg/reshape_transpose_1.f90:  New test.
+
+2007-05-17  Ian Lance Taylor  <iant@google.com>
+
+	PR tree-optimization/31953
+	* gcc.c-torture/compile/pr31953.c: New test.
+
+2007-05-17  Eric Botcazou  <ebotcazou@libertysurf.fr>
+
+	* gcc.c-torture/execute/20070517-1.c: New test.
+
+2007-05-16  Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>
+
+	PR fortran/31725
+	* gfortran.dg/substr_4.f: New test.
+
 2007-05-13  Release Manager
 
 	* GCC 4.2.0 released.
Index: gcc/testsuite/gfortran.fortran-torture/execute/intrinsic_bitops.f90
===================================================================
--- gcc/testsuite/gfortran.fortran-torture/execute/intrinsic_bitops.f90	(.../tags/gcc_4_2_0_release)	(wersja 125589)
+++ gcc/testsuite/gfortran.fortran-torture/execute/intrinsic_bitops.f90	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -8,7 +8,8 @@
    i = 2
    j = 3
    k = 12
-
+   a = 5
+   
    if (.not. btest (i, o+1)) call abort
    if (btest (i, o+2)) call abort
    if (iand (i, j) .ne. 2) call abort
@@ -26,4 +27,6 @@
    if (ishftc (k, o-30) .ne. 48) call abort
    if (ishftc (k, o+1, o+3) .ne. 9) call abort
    if (not (i) .ne. -3) call abort
+   if (ishftc (a, 1, bit_size(a)) .ne. 10) call abort
+   if (ishftc (1, 1, 32) .ne. 2) call abort
 end program
Index: gcc/testsuite/g++.dg/conversion/enum1.C
===================================================================
--- gcc/testsuite/g++.dg/conversion/enum1.C	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/g++.dg/conversion/enum1.C	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,10 @@
+// { dg-do run }
+// { dg-options "-O2 -finline-functions" }
+
+enum E { V = 1 };
+static const E E_MIN = V;
+static const E E_MAX = V;
+
+bool valid(E v) { return v >= E_MIN && v <= E_MAX; }
+
+int main() { return valid(E(2)); }
Index: gcc/testsuite/g++.dg/gomp/pr31769.C
===================================================================
--- gcc/testsuite/g++.dg/gomp/pr31769.C	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/g++.dg/gomp/pr31769.C	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,61 @@
+// PR tree-optimization/31769
+// { dg-options "-O2 -fopenmp" }
+// { dg-do compile }
+
+struct B
+{
+  B () {}
+  virtual ~B () {}
+};
+struct C
+{
+  C (int x, int y) {}
+};
+template<typename T, int U>
+struct D
+{
+  D () {}
+  ~D () {}
+};
+struct E
+{
+  E () {}
+  ~E () {}
+  D<int, 1> e;
+};
+struct A
+{
+  B *b;
+  A () { b = __null; }
+  ~A () { if (b != __null) delete b; }
+};
+struct F : public A
+{
+  explicit F (int x) { foo (0); }
+  F (const F &x) {}
+  F (F &x, C y) {}
+  F operator () (C x) const
+  {
+    return F (const_cast<F &>(*this), x);
+  }
+  template <typename U> F & operator+= (const U &);
+  void foo (int);
+  E f;
+};
+
+int
+main ()
+{
+  try
+  {
+    F f (10);
+    F g (10);
+    C h (0, 9);
+#pragma omp parallel for
+    for (int i = 0; i < 2; ++i)
+      g += f (h);
+  }
+  catch (int &e)
+  {
+  }
+}
Index: gcc/testsuite/g++.dg/opt/static5.C
===================================================================
--- gcc/testsuite/g++.dg/opt/static5.C	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/g++.dg/opt/static5.C	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,29 @@
+// PR c++/31809
+// { dg-do run }
+// { dg-options "-O2" }
+
+struct S
+{
+  unsigned v;
+  static inline S f (unsigned a);
+};
+
+inline S
+S::f (unsigned a)
+{
+  static S t = { a };
+  return t;
+}
+
+const static S s = S::f (26);
+
+extern "C" void abort (void);
+
+int
+main ()
+{
+  S t = s;
+  if (t.v != 26)
+    abort ();
+  return 0;
+}
Index: gcc/testsuite/gfortran.dg/char_length_5.f90
===================================================================
--- gcc/testsuite/gfortran.dg/char_length_5.f90	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gfortran.dg/char_length_5.f90	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,61 @@
+! { dg-do run }
+! Tests the fix for PR31867, in which the interface evaluation
+! of the character length of 'join' (ie. the length available in
+! the caller) was wrong.
+!
+! Contributed by <beliavsky@aol.com> 
+!
+module util_mod
+  implicit none
+contains
+  function join (words, sep) result(str)
+    character (len=*), intent(in)        :: words(:),sep
+    character (len = (size (words) - 1) * len_trim (sep) + & 
+               sum (len_trim (words)))   :: str
+    integer                              :: i,nw
+    nw  = size (words)
+    str = ""
+    if (nw < 1) then
+      return
+    else
+      str = words(1)
+    end if
+    do i=2,nw
+      str = trim (str) // trim (sep) // words(i)
+    end do
+  end function join
+end module util_mod
+!
+program xjoin
+  use util_mod, only: join
+  implicit none
+  integer yy
+  character (len=5) :: words(5:8) = (/"two  ","three","four ","five "/), sep = "^#^"
+  character (len=5) :: words2(4) = (/"bat  ","ball ","goal ","stump"/), sep2 = "&"
+
+  if (join (words, sep) .ne. "two^#^three^#^four^#^five") call abort ()
+  if (len (join (words, sep)) .ne. 25) call abort ()
+
+  if (join (words(5:6), sep) .ne. "two^#^three") call abort ()
+  if (len (join (words(5:6), sep)) .ne. 11) call abort ()
+
+  if (join (words(7:8), sep) .ne. "four^#^five") call abort ()
+  if (len (join (words(7:8), sep)) .ne. 11) call abort ()
+
+  if (join (words(5:7:2), sep) .ne. "two^#^four") call abort ()
+  if (len (join (words(5:7:2), sep)) .ne. 10) call abort ()
+
+  if (join (words(6:8:2), sep) .ne. "three^#^five") call abort ()
+  if (len (join (words(6:8:2), sep)) .ne. 12) call abort ()
+
+  if (join (words2, sep2) .ne. "bat&ball&goal&stump") call abort ()
+  if (len (join (words2, sep2)) .ne. 19) call abort ()
+
+  if (join (words2(1:2), sep2) .ne. "bat&ball") call abort ()
+  if (len (join (words2(1:2), sep2)) .ne. 8) call abort ()
+
+  if (join (words2(2:4:2), sep2) .ne. "ball&stump") call abort ()
+  if (len (join (words2(2:4:2), sep2)) .ne. 10) call abort ()
+
+end program xjoin
+! { dg-final { cleanup-modules "util_mod" } }
Index: gcc/testsuite/gfortran.dg/array_reference_1.f90
===================================================================
--- gcc/testsuite/gfortran.dg/array_reference_1.f90	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gfortran.dg/array_reference_1.f90	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,35 @@
+! { dg-do run }
+! Tests the fix for PR31994, aka 31867, in which the offset
+! of 'a' in both subroutines was being evaluated incorrectly.
+! The testcase for PR31867 is char_length_5.f90
+!
+! Contributed by Elizabeth Yip <elizabeth.l.yip@boeing.com>
+!            and Francois-Xavier Coudert <fxcoudert@gcc.gnu.org>
+!
+program main
+  call PR31994
+  call PR31994_comment6
+contains
+  subroutine PR31994
+    implicit none
+    complex (kind=4), dimension(2,2) :: a, b, c
+    a(1,1) = (1.,1.)
+    a(2,1) = (2.,2.)
+    a(1,2) = (3.,3.)
+    a(2,2) = (4.,4.)
+    b=conjg (transpose (a))
+    c=transpose (a)
+    c=conjg (c)
+    if (any (b .ne. c)) call abort ()
+  end subroutine PR31994
+  subroutine PR31994_comment6
+    implicit none
+    real ,dimension(2,2)::a
+    integer ,dimension(2,2) :: b, c
+    a = reshape ((/1.,2.,3.,4./), (/2,2/))
+    b=int (transpose(a))
+    c = int (a)
+    c = transpose (c)
+    if (any (b .ne. c)) call abort ()
+  end subroutine PR31994_comment6
+END program main
Index: gcc/testsuite/gfortran.dg/reshape_transpose_1.f90
===================================================================
--- gcc/testsuite/gfortran.dg/reshape_transpose_1.f90	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gfortran.dg/reshape_transpose_1.f90	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,18 @@
+! { dg-do run }
+! PR 31196 - reshape of transposed derived types generated
+!            wront results.
+program main
+  implicit none
+  TYPE datatype
+     INTEGER :: I
+  END TYPE datatype
+  character (len=20) line1, line2
+  TYPE(datatype), dimension(2,2) :: data, result
+  data(1,1)%i = 1
+  data(2,1)%i = 2
+  data(1,2)%i = 3
+  data(2,2)%i = 4
+  write (unit=line1, fmt="(4I4)") reshape(transpose(data),shape(data))
+  write (unit=line2, fmt="(4I4)") (/ 1, 3, 2, 4 /)
+  if (line1 /= line2) call abort
+END program main
Index: gcc/testsuite/gfortran.dg/fmt_colon.f90
===================================================================
--- gcc/testsuite/gfortran.dg/fmt_colon.f90	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gfortran.dg/fmt_colon.f90	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,14 @@
+! { dg-do run }
+! PR31395 Colon edit descriptor is ignored.
+! Test case derived from PR. Prepared by Jerry DeLisle
+! <jvdelisle@gcc.gnu.org>
+PROGRAM test
+    INTEGER :: i = 1
+    character(30) :: astring
+    WRITE(astring, 10) i
+ 10 FORMAT('i =',I2:' this should not print')
+    if (astring.ne."i = 1") call abort
+    write(astring, 20) i, i
+ 20 format('i =',I2:' this should print',I2)
+    if (astring.ne."i = 1 this should print 1") call abort
+END PROGRAM test
\ brakuje znaku końca linii na końcu pliku 
Index: gcc/testsuite/gfortran.dg/char_result_13.f90
===================================================================
--- gcc/testsuite/gfortran.dg/char_result_13.f90	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gfortran.dg/char_result_13.f90	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,13 @@
+! { dg-do compile }
+! tests the fix for PR31540, in which the character lengths in
+! parentheses were not resolved.
+!
+! Contributed by Tobias Burnus <burnus@gcc.gnu.org>
+!
+        subroutine pfb()
+        implicit none
+        external pfname1, pfname2
+        character ((136)) pfname1
+        character ((129+7)) pfname2
+        return
+        end
Index: gcc/testsuite/gfortran.dg/altreturn_5.f90
===================================================================
--- gcc/testsuite/gfortran.dg/altreturn_5.f90	(.../tags/gcc_4_2_0_release)	(wersja 0)
+++ gcc/testsuite/gfortran.dg/altreturn_5.f90	(.../branches/gcc-4_2-branch)	(wersja 125589)
@@ -0,0 +1,30 @@
+! { dg-do run }
+! Tests the fix for PR31483, in which dummy argument procedures
+! produced an ICE if they had an alternate return.
+!