svn merge -r118805:118891 svn+ssh://gcc.gnu.org/svn/gcc/branches/gcc-4_1-branch

git-svn-id: https://gcc.gnu.org/svn/gcc/branches/redhat/gcc-4_1-branch@118898 138bc75d-0d04-0410-961f-82ee72b054a4

20 files changed, 390 insertions, 73 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 53540dc4669..aa0a25f02b5 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,13 +1,31 @@
-2006-11-12  Jason Merrill  <jason@redhat.com>
-	    Andrew Pinski <pinskia@physics.uc.edu>
-
-	PR middle-end/28915
-	* gimplify.c (gimplify_init_constructor): Don't reduce TREE_CONSTANT
-	vector ctors.
-	* tree-cfg.c (verify_expr): Don't look into TREE_CONSTANT
-	vector ctors.
-	* expmed.c (make_tree): Handle CONST, SYMBOL_REF.
-	* tree.c (build_vector): Handle non-_CST elements.
+2006-11-16  Joseph Myers  <joseph@codesourcery.com>
+
+	* config/rs6000/spe.md (frob_di_df_2): Handle non-offsettable
+	memory operand.
+
+2006-11-15  Steve Ellcey  <sje@cup.hp.com>
+
+	* config/ia64/ia64.c (ia64_hpux_init_libfuncs):  Use HP-UX millicode
+	routines for integer division.
+
+2006-11-15  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/29581
+	* lambda-code.c (replace_uses_equiv_to_x_with_y): Add YINIT,
+	REPLACEMENTS, FIRSTBSI arguments.  If initial condition or
+	type is different between Y and USE, create a temporary
+	variable, initialize it at the beginning of the body bb
+	and use it as replacement instead of Y.
+
+2006-11-15  Richard Guenther  <rguenther@suse.de>
+
+	Backport from mainline: 
+	2006-11-12  Michael Matz  <matz@suse.de>
+		    Roger Sayle  <roger@eyesopen.com>
+
+	PR rtl-optimization/29797
+	* ifcvt.c (noce_try_bitop): Correct calculation of bitnum on
+	BITS_BIG_ENDIAN targets.
 
 2006-11-13  Jakub Jelinek  <jakub@redhat.com>
 
diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP
index a8a904530b7..a7868e64789 100644
--- a/gcc/DATESTAMP
+++ b/gcc/DATESTAMP
@@ -1 +1 @@
-20061114
+20061116
diff --git a/gcc/config/ia64/t-hpux b/gcc/config/ia64/t-hpux
index 2897739fda1..e710312e9d2 100644
--- a/gcc/config/ia64/t-hpux
+++ b/gcc/config/ia64/t-hpux
@@ -7,6 +7,12 @@ MULTILIB_OPTIONS = milp32/mlp64
 MULTILIB_DIRNAMES = hpux32 hpux64
 MULTILIB_MATCHES =
 
+# On HP-UX we do not want _fixtfdi, _fixunstfdi, or _floatditf from
+# LIB1ASMSRC.  These functions map the 128 bit conversion function names
+# to 80 bit conversions and were done for Linux backwards compatibility.
+
+LIB1ASMFUNCS := $(filter-out _fixtfdi _fixunstfdi _floatditf,$(LIB1ASMFUNCS))
+
 # Support routines for HP-UX 128 bit floats.
 
 LIB2FUNCS_EXTRA=quadlib.c
diff --git a/gcc/config/rs6000/spe.md b/gcc/config/rs6000/spe.md
index 1ac1a8492c1..f2410dd2916 100644
--- a/gcc/config/rs6000/spe.md
+++ b/gcc/config/rs6000/spe.md
@@ -2223,6 +2223,11 @@
     case 0:
       return \"evmergehi %0,%1,%1\;mr %L0,%1\";
     case 1:
+      /* If the address is not offsettable we need to load the whole
+	 doubleword into a 64-bit register and then copy the high word
+	 to form the correct output layout.  */
+      if (!offsettable_nonstrict_memref_p (operands[1]))
+	return \"evldd%X1 %L0,%y1\;evmergehi %0,%L0,%L0\";
       /* If the low-address word is used in the address, we must load
 	it last.  Otherwise, load it first.  Note that we cannot have
 	auto-increment in that case since the address register is
diff --git a/gcc/expmed.c b/gcc/expmed.c
index b2a447ba4bc..eed3a48c589 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -5031,15 +5031,6 @@ make_tree (tree type, rtx x)
 					  GET_CODE (x) == ZERO_EXTEND);
       return fold_convert (type, make_tree (t, XEXP (x, 0)));
 
-    case CONST:
-      return make_tree (type, XEXP (x, 0));
-
-    case SYMBOL_REF:
-      t = SYMBOL_REF_DECL (x);
-      if (t)
-	return fold_convert (type, build_fold_addr_expr (t));
-      /* else fall through.  */
-
     default:
       t = build_decl (VAR_DECL, NULL_TREE, type);
 
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index ebfde96b4a2..e66f416c11d 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -3087,11 +3087,6 @@ gimplify_init_constructor (tree *expr_p, tree *pre_p,
 		TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
 		break;
 	      }
-
-	    /* Don't reduce a TREE_CONSTANT vector ctor even if we can't
-	       make a VECTOR_CST.  It won't do anything for us, and it'll
-	       prevent us from representing it as a single constant.  */
-	    break;
 	  }
 
 	/* Vector types use CONSTRUCTOR all the way through gimple
diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
index 2be01d64a27..d6c3dd6ea32 100644
--- a/gcc/ifcvt.c
+++ b/gcc/ifcvt.c
@@ -1942,7 +1942,9 @@ noce_try_bitop (struct noce_if_info *if_info)
 	return FALSE;
       bitnum = INTVAL (XEXP (cond, 2));
       mode = GET_MODE (x);
-      if (bitnum >= HOST_BITS_PER_WIDE_INT)
+      if (BITS_BIG_ENDIAN)
+	bitnum = GET_MODE_BITSIZE (mode) - 1 - bitnum;
+      if (bitnum < 0 || bitnum >= HOST_BITS_PER_WIDE_INT)
 	return FALSE;
     }
   else
diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c
index b3e28defe0c..4047934c0c0 100644
--- a/gcc/lambda-code.c
+++ b/gcc/lambda-code.c
@@ -2150,11 +2150,17 @@ perfect_nest_p (struct loop *loop)
   return true;
 }
 
-/* Replace the USES of X in STMT, or uses with the same step as X  with Y.  */
+/* Replace the USES of X in STMT, or uses with the same step as X with Y.
+   YINIT is the initial value of Y, REPLACEMENTS is a hash table to
+   avoid creating duplicate temporaries and FIRSTBSI is statement
+   iterator where new temporaries should be inserted at the beginning
+   of body basic block.  */
 
 static void
 replace_uses_equiv_to_x_with_y (struct loop *loop, tree stmt, tree x, 
-				int xstep, tree y)
+				int xstep, tree y, tree yinit,
+				htab_t replacements,
+				block_stmt_iterator *firstbsi)
 {
   ssa_op_iter iter;
   use_operand_p use_p;
@@ -2163,17 +2169,83 @@ replace_uses_equiv_to_x_with_y (struct loop *loop, tree stmt, tree x,
     {
       tree use = USE_FROM_PTR (use_p);
       tree step = NULL_TREE;
-      tree scev = instantiate_parameters (loop,
-					  analyze_scalar_evolution (loop, use));
+      tree scev, init, val, var, setstmt;
+      struct tree_map *h, in;
+      void **loc;
 
-      if (scev != NULL_TREE && scev != chrec_dont_know)
-	step = evolution_part_in_loop_num (scev, loop->num);
+      /* Replace uses of X with Y right away.  */
+      if (use == x)
+	{
+	  SET_USE (use_p, y);
+	  continue;
+	}
+
+      scev = instantiate_parameters (loop,
+				     analyze_scalar_evolution (loop, use));
+
+      if (scev == NULL || scev == chrec_dont_know)
+	continue;
+
+      step = evolution_part_in_loop_num (scev, loop->num);
+      if (step == NULL
+	  || step == chrec_dont_know
+	  || TREE_CODE (step) != INTEGER_CST
+	  || int_cst_value (step) != xstep)
+	continue;
+
+      /* Use REPLACEMENTS hash table to cache already created
+	 temporaries.  */
+      in.hash = htab_hash_pointer (use);
+      in.from = use;
+      h = htab_find_with_hash (replacements, &in, in.hash);
+      if (h != NULL)
+	{
+	  SET_USE (use_p, h->to);
+	  continue;
+	}
 
-      if ((step && step != chrec_dont_know 
-	   && TREE_CODE (step) == INTEGER_CST
-	   && int_cst_value (step) == xstep)
-	  || USE_FROM_PTR (use_p) == x)
-	SET_USE (use_p, y);
+      /* USE which has the same step as X should be replaced
+	 with a temporary set to Y + YINIT - INIT.  */
+      init = initial_condition_in_loop_num (scev, loop->num);
+      gcc_assert (init != NULL && init != chrec_dont_know);
+      if (TREE_TYPE (use) == TREE_TYPE (y))
+	{
+	  val = fold_build2 (MINUS_EXPR, TREE_TYPE (y), init, yinit);
+	  val = fold_build2 (PLUS_EXPR, TREE_TYPE (y), y, val);
+	  if (val == y)
+ 	    {
+	      /* If X has the same type as USE, the same step
+		 and same initial value, it can be replaced by Y.  */
+	      SET_USE (use_p, y);
+	      continue;
+	    }
+	}
+      else
+	{
+	  val = fold_build2 (MINUS_EXPR, TREE_TYPE (y), y, yinit);
+	  val = fold_convert (TREE_TYPE (use), val);
+	  val = fold_build2 (PLUS_EXPR, TREE_TYPE (use), val, init);
+	}
+
+      /* Create a temporary variable and insert it at the beginning
+	 of the loop body basic block, right after the PHI node
+	 which sets Y.  */
+      var = create_tmp_var (TREE_TYPE (use), "perfecttmp");
+      add_referenced_tmp_var (var);
+      val = force_gimple_operand_bsi (firstbsi, val, false, NULL);
+      setstmt = build2 (MODIFY_EXPR, void_type_node, var, val);
+      var = make_ssa_name (var, setstmt);
+      TREE_OPERAND (setstmt, 0) = var;
+      bsi_insert_before (firstbsi, setstmt, BSI_SAME_STMT);
+      update_stmt (setstmt);
+      SET_USE (use_p, var);
+      h = ggc_alloc (sizeof (struct tree_map));
+      h->hash = in.hash;
+      h->from = use;
+      h->to = var;
+      loc = htab_find_slot_with_hash (replacements, h, in.hash, INSERT);
+      gcc_assert ((*(struct tree_map **)loc) == NULL);
+      *(struct tree_map **) loc = h;
     }
 }
 
@@ -2433,7 +2505,7 @@ perfect_nestify (struct loops *loops,
   tree then_label, else_label, cond_stmt;
   basic_block preheaderbb, headerbb, bodybb, latchbb, olddest;
   int i;
-  block_stmt_iterator bsi;
+  block_stmt_iterator bsi, firstbsi;
   bool insert_after;
   edge e;
   struct loop *newloop;
@@ -2442,7 +2514,8 @@ perfect_nestify (struct loops *loops,
   tree stmt;
   tree oldivvar, ivvar, ivvarinced;
   VEC(tree,heap) *phis = NULL;
-  
+  htab_t replacements = NULL;
+
   /* Create the new loop.  */
   olddest = loop->single_exit->dest;
   preheaderbb = loop_split_edge_with (loop->single_exit, NULL);
@@ -2538,10 +2611,13 @@ perfect_nestify (struct loops *loops,
 					   uboundvar,
 					   ivvarinced);
   update_stmt (exit_condition);
+  replacements = htab_create_ggc (20, tree_map_hash,
+				  tree_map_eq, NULL);
   bbs = get_loop_body_in_dom_order (loop); 
   /* Now move the statements, and replace the induction variable in the moved
      statements with the correct loop induction variable.  */
   oldivvar = VEC_index (tree, loopivs, 0);
+  firstbsi = bsi_start (bodybb);
   for (i = loop->num_nodes - 1; i >= 0 ; i--)
     {
       block_stmt_iterator tobsi = bsi_last (bodybb);
@@ -2597,7 +2673,8 @@ perfect_nestify (struct loops *loops,
 		    }
 		  
 		  replace_uses_equiv_to_x_with_y 
-		    (loop, stmt, oldivvar, VEC_index (int, steps, 0), ivvar);
+		    (loop, stmt, oldivvar, VEC_index (int, steps, 0), ivvar,
+		     VEC_index (tree, lbounds, 0), replacements, &firstbsi);
 
 		  bsi_move_before (&bsi, &tobsi);
 		  
@@ -2613,6 +2690,7 @@ perfect_nestify (struct loops *loops,
     }
 
   free (bbs);
+  htab_delete (replacements);
   return perfect_nest_p (loop);
 }
 
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index fe2403dd8ea..53d99c0a91a 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,20 @@
+2006-11-15  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/29581
+	* gcc.dg/pr29581-1.c: New test.
+	* gcc.dg/pr29581-2.c: New test.
+	* gcc.dg/pr29581-3.c: New test.
+	* gcc.dg/pr29581-4.c: New test.
+	* gfortran.dg/pr29581.f90: New test.
+
+2006-11-15  Richard Guenther  <rguenther@suse.de>
+
+	Backport from mainline:
+	2006-11-12  Roger Sayle  <roger@eyesopen.com>
+
+	PR rtl-optimization/29797
+	* gcc.c-torture/execute/pr29797-1.c: New test case.
+
 2006-11-13  Jakub Jelinek  <jakub@redhat.com>
 
 	PR fortran/29759
@@ -17,12 +34,6 @@
 	* g++.dg/other/fold1.C: Adjust error markers.
 	* g++.dg/init/member1.C: Likewise.
 
-2006-11-12  Jason Merrill  <jason@redhat.com>
-	    Andrew Pinski <pinskia@physics.uc.edu>
-
-	PR middle-end/28915
-	* gcc.target/i386/vectorize1.c: New.
-
 2006-11-13  Janis Johnson  <janis187@us.ibm.com>
 
 	Backport from mainline:
diff --git a/gcc/testsuite/gcc.c-torture/execute/pr29797-1.c b/gcc/testsuite/gcc.c-torture/execute/pr29797-1.c
new file mode 100644
index 00000000000..9bcc2a9c59b
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr29797-1.c
@@ -0,0 +1,14 @@
+extern void abort(void);
+
+unsigned int bar(void) { return 32768; }
+
+int main()
+{
+  unsigned int nStyle = bar ();
+  if (nStyle & 32768)
+    nStyle |= 65536;
+  if (nStyle != (32768 | 65536))
+    abort ();
+  return 0;
+}
+
diff --git a/gcc/testsuite/gcc.dg/pr29581-1.c b/gcc/testsuite/gcc.dg/pr29581-1.c
new file mode 100644
index 00000000000..e5400735525
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr29581-1.c
@@ -0,0 +1,44 @@
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-85.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+	{
+	  k = i + N;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < N; j++)
+    if (a[j] != i + N - 1)
+      abort();	
+
+  for (j = 0; j < N; j++)
+    if (b[j] != j + N)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N] __attribute__ ((__aligned__(16)));
+
+  main1 (a);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/pr29581-2.c b/gcc/testsuite/gcc.dg/pr29581-2.c
new file mode 100644
index 00000000000..c99d78ce2f1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr29581-2.c
@@ -0,0 +1,46 @@
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-86.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int n)
+{
+  int i, j, k;
+  int a[N], b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+	{
+	  k = i + n;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (i = 0; i < n; i++)
+    if (b[i] != i + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  main1 (N);
+  main1 (0);
+  main1 (1);
+  main1 (2);
+  main1 (N-1);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/pr29581-3.c b/gcc/testsuite/gcc.dg/pr29581-3.c
new file mode 100644
index 00000000000..c9d72ce281f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr29581-3.c
@@ -0,0 +1,48 @@
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-87.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int n, int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+	{
+	  k = i + n;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (j = 0; j < n; j++)
+    if (b[j] != j + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N] __attribute__ ((__aligned__(16)));
+
+  main1 (N, a);
+  main1 (0, a);
+  main1 (1, a);
+  main1 (2, a);
+  main1 (N-1, a);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/pr29581-4.c b/gcc/testsuite/gcc.dg/pr29581-4.c
new file mode 100644
index 00000000000..c2d894c8d20
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr29581-4.c
@@ -0,0 +1,48 @@
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-88.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int n, int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+	{
+	  k = i + n;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (j = 0; j < n; j++)
+    if (b[j] != j + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N+1] __attribute__ ((__aligned__(16)));
+
+  main1 (N, a+1);
+  main1 (0, a+1);
+  main1 (1, a+1);
+  main1 (2, a+1);
+  main1 (N-1, a+1);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/i386/vectorize1.c b/gcc/testsuite/gcc.target/i386/vectorize1.c
deleted file mode 100644
index 28994bd72d9..00000000000
--- a/gcc/testsuite/gcc.target/i386/vectorize1.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/* PR middle-end/28915 */
-/* { dg-options "-msse -O2 -ftree-vectorize -fdump-tree-vect" } */
-
-extern char lanip[3][40];
-typedef struct
-{
-  char *t[4];
-}tx_typ;
-
-int set_names (void)
-{
-  static tx_typ tt1;
-  int ln;
-  for (ln = 0; ln < 4; ln++)
-      tt1.t[ln] = lanip[1];
-}
-
-/* { dg-final { scan-tree-dump "vect_cst" "vect" } } */
diff --git a/gcc/testsuite/gfortran.dg/pr29581.f90 b/gcc/testsuite/gfortran.dg/pr29581.f90
new file mode 100644
index 00000000000..3e4a39efb63
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr29581.f90
@@ -0,0 +1,27 @@
+! PR tree-optimization/29581
+! { dg-do run }
+! { dg-options "-O2 -ftree-loop-linear" }
+
+      SUBROUTINE FOO (K)
+      INTEGER I, J, K, A(5,5), B
+      COMMON A
+      A(1,1) = 1
+ 10   B = 0
+      DO 30 I = 1, K
+        DO 20 J = 1, K
+          B = B + A(I,J)
+ 20     CONTINUE
+        A(I,I) = A(I,I) * 2
+ 30   CONTINUE
+      IF (B.GE.3) RETURN
+      GO TO 10
+      END SUBROUTINE
+
+      PROGRAM BAR
+        INTEGER A(5,5)
+        COMMON A
+        CALL FOO (2)
+        IF (A(1,1).NE.8) CALL ABORT
+        A(1,1) = 0
+        IF (ANY(A.NE.0)) CALL ABORT
+      END
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 2e664d35d05..b564d6f9d85 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -3386,11 +3386,6 @@ verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
       CHECK_OP (1, "invalid operand to binary operator");
       break;
 
-    case CONSTRUCTOR:
-      if (TREE_CONSTANT (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
-	*walk_subtrees = 0;
-      break;
-
     default:
       break;
     }
diff --git a/gcc/tree.c b/gcc/tree.c
index e247a585fd7..6a64320dc39 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -952,10 +952,6 @@ build_vector (tree type, tree vals)
     {
       tree value = TREE_VALUE (link);
 
-      /* Don't crash if we get an address constant.  */
-      if (!CONSTANT_CLASS_P (value))
-	continue;
-
       over1 |= TREE_OVERFLOW (value);
       over2 |= TREE_CONSTANT_OVERFLOW (value);
     }
diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index f2b1a7e88c2..721147a3a00 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,8 @@
+2006-11-14  Joseph Myers  <joseph@codesourcery.com>
+
+	* testsuite/26_numerics/complex/13450.cc: Do not test long double
+	in IBM long double case.
+
 2006-11-13  Paolo Carlini  <pcarlini@suse.de>
 
 	* src/debug.cc (_Safe_sequence_base::_M_revalidate_singular): Fix
diff --git a/libstdc++-v3/testsuite/26_numerics/complex/13450.cc b/libstdc++-v3/testsuite/26_numerics/complex/13450.cc
index f5640dec879..22bdb5eed44 100644
--- a/libstdc++-v3/testsuite/26_numerics/complex/13450.cc
+++ b/libstdc++-v3/testsuite/26_numerics/complex/13450.cc
@@ -61,6 +61,11 @@ void test01()
   d2 = 1.4;
   test01_do(d1, d2);
 
+#if __LDBL_MANT_DIG__ != 106
+  /* For IBM long double, epsilon is too small (since 1.0 plus any
+     double is representable) to be able to expect results within
+     epsilon * 100 (which may be much less than 1ulp for a particular
+     long double value).  */
   long double ld1 = -1.0l;
   long double ld2 = 0.5l;
   test01_do(ld1, ld2);
@@ -68,6 +73,7 @@ void test01()
   ld1 = -3.2l;
   ld2 = 1.4l;
   test01_do(ld1, ld2);
+#endif
 }
 
 int main()