Merge to HEAD at tree-cleanup-merge-20041024 .new-regalloc-branch

git-svn-id: https://gcc.gnu.org/svn/gcc/branches/new-regalloc-branch@95203 138bc75d-0d04-0410-961f-82ee72b054a4

6 files changed, 194 insertions, 30 deletions

diff --git a/gcc/testsuite/gcc.dg/torture/builtin-attr-1.c b/gcc/testsuite/gcc.dg/torture/builtin-attr-1.c
index 304e92afa8f..0e521d84e3f 100644
--- a/gcc/testsuite/gcc.dg/torture/builtin-attr-1.c
+++ b/gcc/testsuite/gcc.dg/torture/builtin-attr-1.c
@@ -26,9 +26,10 @@ void test_builtin_##FN(TYPE x, TYPE y) \
 { if (__builtin_##FN(x,y) != __builtin_##FN(x,y)) link_failure_builtin_##FN(); }
 
 /* Also test the regular (non-__builtin_) function.  */
-#define TEST1(FN, TYPE) \
+#define TEST1(FN, TYPE, RTYPE) \
 BUILTIN_TEST1(FN, TYPE) \
 extern void link_failure_##FN(void); \
+extern RTYPE FN(TYPE); \
 void test_##FN(TYPE x) { if (FN(x) != FN(x)) link_failure_##FN(); }
 
 /* Test the __builtin_ functions taking void arguments (with the "f"
@@ -153,12 +154,32 @@ void test_builtin_##FN##l(_Complex long double ld1, _Complex long double ld2) \
 /* These macros additionally test the non-__builtin_ functions.  */
 
 /* Test the functions taking one FP argument (with the "f" and "l"
-   variants).  */
+   variants) and returning that type.  */
 #define FPTEST1(FN) \
 BUILTIN_FPTEST1(FN) \
 extern void link_failure_##FN(void); \
 extern void link_failure_##FN##f(void); \
 extern void link_failure_##FN##l(void); \
+extern double FN(double); \
+extern float FN##f(float); \
+extern long double FN##l(long double); \
+void test_##FN(double d) \
+{ if (FN(d) != FN(d)) link_failure_##FN(); } \
+void test_##FN##f(float f) \
+{ if (FN##f(f) != FN##f(f)) link_failure_##FN##f(); } \
+void test_##FN##l(long double ld) \
+{ if (FN##l(ld) != FN##l(ld)) link_failure_##FN##l(); }
+
+/* Test the functions taking one FP argument (with the "f" and "l"
+   variants) and returning TYPE.  */
+#define FPTEST1T(FN, TYPE) \
+BUILTIN_FPTEST1(FN) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern TYPE FN(double); \
+extern TYPE FN##f(float); \
+extern TYPE FN##l(long double); \
 void test_##FN(double d) \
 { if (FN(d) != FN(d)) link_failure_##FN(); } \
 void test_##FN##f(float f) \
@@ -173,6 +194,9 @@ BUILTIN_FPTEST2(FN) \
 extern void link_failure_##FN(void); \
 extern void link_failure_##FN##f(void); \
 extern void link_failure_##FN##l(void); \
+extern double FN(double, double); \
+extern float FN##f(float, float); \
+extern long double FN##l(long double, long double); \
 void test_##FN(double d1, double d2) \
 { if (FN(d1,d2) != FN(d1,d2)) link_failure_##FN(); } \
 void test_##FN##f(float f1, float f2) \
@@ -188,6 +212,9 @@ BUILTIN_FPTEST2ARG1(FN, TYPE) \
 extern void link_failure_##FN(void); \
 extern void link_failure_##FN##f(void); \
 extern void link_failure_##FN##l(void); \
+extern double FN(TYPE, double); \
+extern float FN##f(TYPE, float); \
+extern long double FN##l(TYPE, long double); \
 void test_##FN(TYPE x, double d) \
 { if (FN(x,d) != FN(x,d)) link_failure_##FN(); } \
 void test_##FN##f(TYPE x, float f) \
@@ -203,6 +230,9 @@ BUILTIN_FPTEST2ARG2(FN, TYPE) \
 extern void link_failure_##FN(void); \
 extern void link_failure_##FN##f(void); \
 extern void link_failure_##FN##l(void); \
+extern double FN(double, TYPE); \
+extern float FN##f(float, TYPE); \
+extern long double FN##l(long double, TYPE); \
 void test_##FN(double d, TYPE x) \
 { if (FN(d,x) != FN(d,x)) link_failure_##FN(); } \
 void test_##FN##f(float f, TYPE x) \
@@ -217,6 +247,9 @@ BUILTIN_FPTEST3(FN) \
 extern void link_failure_##FN(void); \
 extern void link_failure_##FN##f(void); \
 extern void link_failure_##FN##l(void); \
+extern double FN(double, double, double); \
+extern float FN##f(float, float, float); \
+extern long double FN##l(long double, long double, long double); \
 void test_##FN(double d1, double d2, double d3) \
 { if (FN(d1,d2,d3) != FN(d1,d2,d3)) link_failure_##FN(); } \
 void test_##FN##f(float f1, float f2, float f3) \
@@ -225,12 +258,32 @@ void test_##FN##l(long double ld1, long double ld2, long double ld3) \
 { if (FN##l(ld1,ld2,ld3) != FN##l(ld1,ld2,ld3)) link_failure_##FN##l(); }
 
 /* Test the functions taking one complex argument (with the "f" and
-   "l" variants).  */
+   "l" variants) and returning that type.  */
 #define CPTEST1(FN) \
 BUILTIN_CPTEST1(FN) \
 extern void link_failure_##FN(void); \
 extern void link_failure_##FN##f(void); \
 extern void link_failure_##FN##l(void); \
+extern _Complex double FN(_Complex double); \
+extern _Complex float FN##f(_Complex float); \
+extern _Complex long double FN##l(_Complex long double); \
+void test_##FN(_Complex double d) \
+{ if (FN(d) != FN(d)) link_failure_##FN(); } \
+void test_##FN##f(_Complex float f) \
+{ if (FN##f(f) != FN##f(f)) link_failure_##FN##f(); } \
+void test_##FN##l(_Complex long double ld) \
+{ if (FN##l(ld) != FN##l(ld)) link_failure_##FN##l(); }
+
+/* Test the functions taking one complex argument (with the "f" and
+   "l" variants) and returning the real type.  */
+#define CPTEST1R(FN) \
+BUILTIN_CPTEST1(FN) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern double FN(_Complex double); \
+extern float FN##f(_Complex float); \
+extern long double FN##l(_Complex long double); \
 void test_##FN(_Complex double d) \
 { if (FN(d) != FN(d)) link_failure_##FN(); } \
 void test_##FN##f(_Complex float f) \
@@ -245,6 +298,9 @@ BUILTIN_CPTEST2(FN) \
 extern void link_failure_##FN(void); \
 extern void link_failure_##FN##f(void); \
 extern void link_failure_##FN##l(void); \
+extern _Complex double FN(_Complex double, _Complex double); \
+extern _Complex float FN##f(_Complex float, _Complex float); \
+extern _Complex long double FN##l(_Complex long double, _Complex long double); \
 void test_##FN(_Complex double d1, _Complex double d2) \
 { if (FN(d1,d2) != FN(d1,d2)) link_failure_##FN(); } \
 void test_##FN##f(_Complex float f1, _Complex float f2) \
@@ -283,35 +339,35 @@ FPTEST2            (fmod)
 FPTEST1            (gamma)
 BUILTIN_FPTEST0    (huge_val)
 FPTEST2            (hypot)
-FPTEST1            (ilogb)
+FPTEST1T           (ilogb, int)
 BUILTIN_FPTEST0    (inf)
 FPTEST1            (j0)
 FPTEST1            (j1)
 FPTEST2ARG1        (jn, int)
 FPTEST2ARG2        (ldexp, int)
 FPTEST1            (lgamma)
-FPTEST1            (llrint)
-FPTEST1            (llround)
+FPTEST1T           (llrint, long long)
+FPTEST1T           (llround, long long)
 FPTEST1            (log)
 FPTEST1            (log10)
 FPTEST1            (log1p)
 FPTEST1            (log2)
 FPTEST1            (logb)
-FPTEST1            (lrint)
-FPTEST1            (lround)
+FPTEST1T           (lrint, long)
+FPTEST1T           (lround, long)
 BUILTIN_FPTEST1ARG (nan, char *)
 BUILTIN_FPTEST1ARG (nans, char *)
 FPTEST1            (nearbyint)
 FPTEST2            (nextafter)
-FPTEST2            (nexttoward)
+FPTEST2ARG2        (nexttoward, long double)
 FPTEST2            (pow)
 FPTEST1            (pow10)
 FPTEST2            (remainder)
 FPTEST1            (rint)
 FPTEST1            (round)
 FPTEST2            (scalb)
-FPTEST2ARG2        (scalbln, int)
 FPTEST2ARG2        (scalbn, int)
+FPTEST2ARG2        (scalbln, long int)
 FPTEST1            (significand)
 FPTEST1            (sin)
 FPTEST1            (sinh)
@@ -328,7 +384,7 @@ FPTEST2ARG1        (yn, int)
 /*CPTEST1 (cabs) See http://gcc.gnu.org/ml/gcc-patches/2003-09/msg00040.html */
 CPTEST1 (cacos)
 CPTEST1 (cacosh)
-CPTEST1 (carg)
+CPTEST1R (carg)
 CPTEST1 (casin)
 CPTEST1 (casinh)
 CPTEST1 (catan)
@@ -336,32 +392,34 @@ CPTEST1 (catanh)
 CPTEST1 (ccos)
 CPTEST1 (ccosh)
 CPTEST1 (cexp)
-CPTEST1 (cimag)
+CPTEST1R (cimag)
 /*CPTEST1 (clog)*/
 CPTEST1 (conj)
 CPTEST2 (cpow)
 CPTEST1 (cproj)
-CPTEST1 (creal)
+CPTEST1R (creal)
 CPTEST1 (csin)
 CPTEST1 (csinh)
 CPTEST1 (csqrt)
 CPTEST1 (ctan)
 CPTEST1 (ctanh)
 
+typedef __INTMAX_TYPE__ intmax_t;
+
 /* Various other const builtins.  */
-TEST1         (abs, int)
+TEST1         (abs, int, int)
 BUILTIN_TEST1 (clz, int)
 BUILTIN_TEST1 (clzl, long)
 BUILTIN_TEST1 (clzll, long long)
 BUILTIN_TEST1 (ctz, int)
 BUILTIN_TEST1 (ctzl, long)
 BUILTIN_TEST1 (ctzll, long long)
-TEST1         (ffs, int)
-TEST1         (ffsl, long)
-TEST1         (ffsll, long long)
-TEST1         (imaxabs, int)
-TEST1         (labs, long)
-TEST1         (llabs, long long)
+TEST1         (ffs, int, int)
+TEST1         (ffsl, long, int)
+TEST1         (ffsll, long long, int)
+TEST1         (imaxabs, intmax_t, intmax_t)
+TEST1         (labs, long, long)
+TEST1         (llabs, long long, long long)
 BUILTIN_TEST1 (parity, int)
 BUILTIN_TEST1 (parityl, long)
 BUILTIN_TEST1 (parityll, long long)
diff --git a/gcc/testsuite/gcc.dg/torture/builtin-explog-1.c b/gcc/testsuite/gcc.dg/torture/builtin-explog-1.c
index 352f5b037b1..4d7de84cbb5 100644
--- a/gcc/testsuite/gcc.dg/torture/builtin-explog-1.c
+++ b/gcc/testsuite/gcc.dg/torture/builtin-explog-1.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2003  Free Software Foundation.
+/* Copyright (C) 2003, 2004  Free Software Foundation.
 
    Verify that built-in math function constant folding of log & exp is
    correctly performed by the compiler.
@@ -13,9 +13,10 @@
 #define M_EF 2.7182818284590452353602874713526624977572470936999595749669676277241F
 #define M_EL 2.7182818284590452353602874713526624977572470936999595749669676277241L
 /* Precision for comparison tests.  */
-#define PREC  0.0000001
+#define PREC  (sizeof (float) < sizeof (double) ? 0.0000001 : PRECF)
 #define PRECF 0.0001F
-#define PRECL 0.0000000000001L
+#define PRECL (sizeof (float) < sizeof (long double)	\
+	       ? 0.0000000000001L : PRECF)
 #define PROTOTYPE(FN) extern double FN(double); extern float FN##f(float); \
   extern long double FN##l(long double);
 #define PROTOTYPE2(FN) extern double FN(double, double); \
@@ -36,6 +37,7 @@ PROTOTYPE2(pow)
 void test(double d1, double d2, float f1, float f2,
 	  long double ld1, long double ld2)
 {
+  /* Test logN(1) -> 0.  */
 #define LOG_1(LOG) \
  extern void link_failure_##LOG##_1(void); \
  if (LOG(1.0) != 0.0 || LOG##f(1.0F) != 0.0F || LOG##l(1.0L) != 0.0L) \
@@ -45,6 +47,7 @@ void test(double d1, double d2, float f1, float f2,
   LOG_1(log2);
   LOG_1(log10);
   
+  /* Test logN(N) -> 1.  */
 #define LOG_N(LOG, BASE) \
  extern void link_failure_##LOG##_N(void); \
  if (LOG(BASE) != 1.0 || LOG##f(BASE##F) != 1.0F || LOG##l(BASE##L) != 1.0L) \
@@ -54,6 +57,7 @@ void test(double d1, double d2, float f1, float f2,
   LOG_N(log2, 2.0);
   LOG_N(log10, 10.0);
 
+  /* Test logN(expN(x)) -> x.  */
 #define LOGEXP_SAME(LOG, EXP) \
  extern void link_failure_##LOG##_##EXP##_same(void); \
  if (LOG(EXP(d1)) != d1 || LOG##f(EXP##f(f1)) != f1 \
@@ -64,6 +68,7 @@ void test(double d1, double d2, float f1, float f2,
   LOGEXP_SAME(log10,exp10);
   LOGEXP_SAME(log10,pow10);
 
+  /* Test logN(expM(x)) -> x*logN(M).  */
 #define LOGEXP(LOG, EXP, BASE) \
  extern void link_failure_##LOG##_##EXP(void); \
  if (LOG(EXP(d1)) != d1*LOG(BASE) || LOG##f(EXP##f(f1)) != f1*LOG##f(BASE##F) \
@@ -82,6 +87,7 @@ void test(double d1, double d2, float f1, float f2,
   LOGEXP(log10,exp10,10.0);
   LOGEXP(log10,pow10,10.0);
   
+  /* Test logN(sqrt(x)) -> 0.5*logN(x).  */
 #define LOG_SQRT(LOG) \
  extern void link_failure_##LOG##_sqrt(void); \
  if (LOG(sqrt(d1)) != 0.5*LOG(d1) || LOG##f(sqrtf(f1)) != 0.5F*LOG##f(f1) \
@@ -91,6 +97,18 @@ void test(double d1, double d2, float f1, float f2,
   LOG_SQRT(log2);
   LOG_SQRT(log10);
   
+  /* Test sqrt(expN(x)) -> expN(x*0.5).  */
+#define SQRT_EXP(EXP) \
+ extern void link_failure_sqrt_##EXP(void); \
+ if (sqrt(EXP(d1)) != EXP(d1*0.5) || sqrtf(EXP##f(f1)) != EXP##f(f1*0.5F) \
+  || sqrtl(EXP##l(ld1)) != EXP##l(ld1*0.5L)) link_failure_sqrt_##EXP()
+    
+  SQRT_EXP(exp);
+  SQRT_EXP(exp2);
+  SQRT_EXP(exp10);
+  SQRT_EXP(pow10);
+  
+  /* Test logN(cbrt(x)) -> (1/3)*logN(x).  */
 #define LOG_CBRT(LOG) \
  extern void link_failure_##LOG##_cbrt(void); \
  if (LOG(cbrt(d1)) != (1.0/3)*LOG(d1) \
@@ -101,15 +119,39 @@ void test(double d1, double d2, float f1, float f2,
   LOG_CBRT(log2);
   LOG_CBRT(log10);
   
-#define LOGPOW(LOG, POW) \
+  /* Test cbrt(expN(x)) -> expN(x/3).  */
+#define CBRT_EXP(EXP) \
+ extern void link_failure_cbrt_##EXP(void); \
+ if (cbrt(EXP(d1)) != EXP(d1/3.0) || cbrtf(EXP##f(f1)) != EXP##f(f1/3.0F) \
+  || cbrtl(EXP##l(ld1)) != EXP##l(ld1/3.0L)) link_failure_cbrt_##EXP()
+    
+  CBRT_EXP(exp);
+  CBRT_EXP(exp2);
+  CBRT_EXP(exp10);
+  CBRT_EXP(pow10);
+  
+  /* Test logN(pow(x,y)) -> y*logN(x).  */
+#define LOG_POW(LOG, POW) \
  extern void link_failure_##LOG##_##POW(void); \
  if (LOG(POW(d1,d2)) != d2*LOG(d1) || LOG##f(POW##f(f1,f2)) != f2*LOG##f(f1) \
   || LOG##l(POW##l(ld1,ld2)) != ld2*LOG##l(ld1)) link_failure_##LOG##_##POW()
   
-  LOGPOW(log,pow);
-  LOGPOW(log2,pow);
-  LOGPOW(log10,pow);
+  LOG_POW(log,pow);
+  LOG_POW(log2,pow);
+  LOG_POW(log10,pow);
+
+  /* Test pow(expN(x),y)) -> expN(x*y).  */
+#define POW_EXP(POW, EXP) \
+ extern void link_failure_##POW##_##EXP(void); \
+ if (POW(EXP(d1),d2) != EXP(d1*d2) || POW##f(EXP##f(f1),f2) != EXP##f(f1*f2) \
+  || POW##l(EXP##l(ld1),ld2) != EXP##l(ld1*ld2)) link_failure_##POW##_##EXP()
+  
+  POW_EXP(pow, exp);
+  POW_EXP(pow, exp2);
+  POW_EXP(pow, exp10);
+  POW_EXP(pow, pow10);
 
+  /* Test expN(0) -> 1.  */
 #define EXP_0(EXP) \
  extern void link_failure_##EXP##_0(void); \
  if (EXP(0.0) != 1.0 || EXP##f(0.0F) != 1.0F || EXP##l(0.0L) != 1.0L) \
@@ -120,6 +162,7 @@ void test(double d1, double d2, float f1, float f2,
   EXP_0(exp10);
   EXP_0(pow10);
   
+  /* Test expN(1) -> N.  */
 #define EXP_N(EXP, BASE) \
  extern void link_failure_##EXP##_N(void); \
  if (EXP(1.0) != BASE || EXP##f(1.0F) != BASE##F || EXP##l(1.0L) != BASE##L) \
@@ -130,6 +173,7 @@ void test(double d1, double d2, float f1, float f2,
   EXP_N(exp10, 10.0);
   EXP_N(pow10, 10.0);
 
+  /* Test expN(integer) -> N*N*N*...  */
 #define EXP_INT(EXP, BASE) \
  extern void link_failure_##EXP##_INT(void); \
  if (EXP(5.0) < (BASE)*(BASE)*(BASE)*(BASE)*(BASE) - PREC \
@@ -145,6 +189,7 @@ void test(double d1, double d2, float f1, float f2,
   EXP_INT(exp10, 10.0);
   EXP_INT(pow10, 10.0);
 
+  /* Test expN(logN(x)) -> x.  */
 #define EXPLOG_SAME(EXP, LOG) \
  extern void link_failure_##EXP##_##LOG##_same(void); \
  if (EXP(LOG(d1)) != d1 || EXP##f(LOG##f(f1)) != f1 \
@@ -155,6 +200,7 @@ void test(double d1, double d2, float f1, float f2,
   EXPLOG_SAME(exp10, log10);
   EXPLOG_SAME(pow10, log10);
 
+  /* Test expN(x)*expN(y)) -> expN(x+y).  */
 #define EXPXEXP(EXP) \
  extern void link_failure_##EXP##X##EXP(void); \
  if (EXP(d1)*EXP(d2) != EXP(d1+d2) || EXP##f(f1)*EXP##f(f2) != EXP##f(f1+f2) \
@@ -165,6 +211,8 @@ void test(double d1, double d2, float f1, float f2,
   EXPXEXP(exp10);
   EXPXEXP(pow10);
 
+  /* Test x/expN(y) -> x*expN(-y).  */
+  /* Test expN(x)/expN(y) -> expN(x-y).  */
 #define DIVEXP(EXP) \
  extern void link_failure_div1_##EXP(void); \
  if (d1/EXP(d2) != d1*EXP(-d2) || f1/EXP##f(f2) != f1*EXP##f(-f2) \
diff --git a/gcc/testsuite/gcc.dg/torture/builtin-math-1.c b/gcc/testsuite/gcc.dg/torture/builtin-math-1.c
index 47b91d7e25d..d052f5347bc 100644
--- a/gcc/testsuite/gcc.dg/torture/builtin-math-1.c
+++ b/gcc/testsuite/gcc.dg/torture/builtin-math-1.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003  Free Software Foundation.
+/* Copyright (C) 2002, 2003, 2004  Free Software Foundation.
 
    Verify that built-in math function constant folding of constant
    arguments is correctly performed by the compiler.
@@ -7,6 +7,34 @@
 
 /* { dg-do link } */
 
+extern double atan (double);
+extern float atanf (float);
+extern long double atanl (long double);
+extern double cbrt (double);
+extern float cbrtf (float);
+extern long double cbrtl (long double);
+extern double cos (double);
+extern float cosf (float);
+extern long double cosl (long double);
+extern double exp (double);
+extern float expf (float);
+extern long double expl (long double);
+extern double log (double);
+extern float logf (float);
+extern long double logl (long double);
+extern double pow (double, double);
+extern float powf (float, float);
+extern long double powl (long double, long double);
+extern double sin (double);
+extern float sinf (float);
+extern long double sinl (long double);
+extern double sqrt (double);
+extern float sqrtf (float);
+extern long double sqrtl (long double);
+extern double tan (double);
+extern float tanf (float);
+extern long double tanl (long double);
+
 /* All references to link_error should go away at compile-time.  */
 extern void link_error(void);
 
@@ -18,6 +46,15 @@ void test (float f, double d, long double ld)
   if (sqrt (1.0) != 1.0)
     link_error ();
 
+  if (cbrt (0.0) != 0.0)
+    link_error ();
+
+  if (cbrt (1.0) != 1.0)
+    link_error ();
+
+  if (cbrt (-1.0) != -1.0)
+    link_error ();
+
   if (exp (0.0) != 1.0)
     link_error ();
 
@@ -55,6 +92,15 @@ void test (float f, double d, long double ld)
   if (sqrtf (1.0F) != 1.0F)
     link_error ();
 
+  if (cbrtf (0.0F) != 0.0F)
+    link_error ();
+
+  if (cbrtf (1.0F) != 1.0F)
+    link_error ();
+
+  if (cbrtf (-1.0F) != -1.0F)
+    link_error ();
+
   if (expf (0.0F) != 1.0F)
     link_error ();
 
@@ -92,6 +138,15 @@ void test (float f, double d, long double ld)
   if (sqrtl (1.0L) != 1.0L)
     link_error ();
 
+  if (cbrtl (0.0L) != 0.0L)
+    link_error ();
+
+  if (cbrtl (1.0L) != 1.0L)
+    link_error ();
+
+  if (cbrtl (-1.0L) != -1.0L)
+    link_error ();
+
   if (expl (0.0L) != 1.0L)
     link_error ();
 
diff --git a/gcc/testsuite/gcc.dg/torture/builtin-noret-2.c b/gcc/testsuite/gcc.dg/torture/builtin-noret-2.c
index d49de7f66de..c8c8609f62c 100644
--- a/gcc/testsuite/gcc.dg/torture/builtin-noret-2.c
+++ b/gcc/testsuite/gcc.dg/torture/builtin-noret-2.c
@@ -15,6 +15,7 @@ int
 main (void)
 {
   volatile int i = 0;
+  extern void exit (int);
   if (i)
     tabort ();
   if (i)
@@ -60,6 +61,7 @@ t_exit (void)
 void
 _exit (int i)
 {
+  extern void abort (void);
   abort ();
 }
 
@@ -81,5 +83,6 @@ t_Exit (void)
 void
 _Exit (int i)
 {
+  extern void abort (void);
   abort ();
 }
diff --git a/gcc/testsuite/gcc.dg/torture/builtin-power-1.c b/gcc/testsuite/gcc.dg/torture/builtin-power-1.c
index 7cdc00c23fb..45566118a81 100644
--- a/gcc/testsuite/gcc.dg/torture/builtin-power-1.c
+++ b/gcc/testsuite/gcc.dg/torture/builtin-power-1.c
@@ -63,7 +63,7 @@ void test(double d1, double d2, double d3,
      || FN##l(powl(ld1,ld2)) != powl(ld1,ld2/N)) \
     link_failure_##FN##_pow()
 
-  /*ROOT_POW(sqrt,2); Invalid. */
+  ROOT_POW(sqrt,2);
   /*ROOT_POW(cbrt,3); Intentionally not implemented.  */
 
   /* Test pow(pow(x,y),z) -> pow(x,y*z).  */
diff --git a/gcc/testsuite/gcc.dg/torture/mips-sdata-1.c b/gcc/testsuite/gcc.dg/torture/mips-sdata-1.c
index b665d96cd56..8ffd4d84857 100644
--- a/gcc/testsuite/gcc.dg/torture/mips-sdata-1.c
+++ b/gcc/testsuite/gcc.dg/torture/mips-sdata-1.c
@@ -1,6 +1,6 @@
 /* Check that sdata-accesses are applied regardless of size or ABI.  */
 /* { dg-options -mexplicit-relocs } */
-/* { dg-do compile { target mips*-*-* } } */
+/* { dg-do compile { target mips*-*-elf* } } */
 
 struct s { int x[4]; };
 struct s my_struct __attribute__((__section__(".sdata")));