[CodeGen] fix const-ness of builtin equivalents of <math.h> and <complex.h> functions that might set errno

[spatel]

Summary

As the description in Builtins.def says: "e = const, but only when -fmath-errno=0".

This is step 2 of 3 to fix builtins and math calls as discussed in D39204.

I went through the lists at:
http://en.cppreference.com/w/c/numeric/math
http://en.cppreference.com/w/c/numeric/complex
...and changed all of the builtins that correspond to functions that could set errno.

The math.h functions that are specified to never set errno are:
fmax
fmin
nearbyint

And for complex.h:
creal
cimag
conj
cproj

powi is not a standard libm function, so that's also left as "Fnc".

[efriedma]

Please make these consistent with the non-__builtin versions.

Granted, I'm not sure all of those are right... I'm pretty sure, for example, cbrt can't set errno, and carg can. But I'd prefer to deal with that in a separate patch.

[spatel]

In D39481#912378, @efriedma wrote:

Granted, I'm not sure all of those are right... I'm pretty sure, for example, cbrt can't set errno, and carg can. But I'd prefer to deal with that in a separate patch.

I figured we have to be ultra-conservative here, and there are docs out there like this:

"On successful completion, cbrt() returns the cube root of x. If x is NaN, cbrt() returns NaN and errno may be set to [EDOM]. "

http://pubs.opengroup.org/onlinepubs/7908799/xsh/cbrt.html

[efriedma]

I think we should assume libm complies with the C99 standard (specifically, the appendix specifying the behavior of IEEE floating-point). Otherwise, we have no basis to predict the behavior of any standard library call.

From the standard: "Functions with a NaN argument return a NaN result and raise no floating-point exception, except where stated otherwise."

[craig.topper]

There's an oddity with fma. The version without __builtin has 'e' already

LIBBUILTIN(fma, "dddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fmaf, "ffff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fmal, "LdLdLdLd", "fne", "math.h", ALL_LANGUAGES)

But we don't check the const attribute in CGBuiltin.cpp before converting it to an intrinsic

case Builtin::BIfma:
case Builtin::BIfmaf:
case Builtin::BIfmal:
case Builtin::BI__builtin_fma:
case Builtin::BI__builtin_fmaf:
case Builtin::BI__builtin_fmal: {
  // Rewrite fma to intrinsic.
  Value *FirstArg = EmitScalarExpr(E->getArg(0));
  llvm::Type *ArgType = FirstArg->getType();
  Value *F = CGM.getIntrinsic(Intrinsic::fma, ArgType);
  return RValue::get(
      Builder.CreateCall(F, {FirstArg, EmitScalarExpr(E->getArg(1)),
                             EmitScalarExpr(E->getArg(2))}));
}

[efriedma]

But we don't check the const attribute in CGBuiltin.cpp before converting it to an intrinsic

In practice, fma() implementations don't set errno (at least, glibc and msvcrt don't). And people would be really annoyed if we forced them to use fast-math flags to generate an fma instruction. So this is probably okay?

[hfinkel]

In D39481#914174, @craig.topper wrote:

There's an oddity with fma. The version without __builtin has 'e' already

Something that is potentially relevant: POSIX says that fma() can set errno (http://pubs.opengroup.org/onlinepubs/9699919799/functions/fma.html), however, the glibc man page says that its fma() does not set errno (https://linux.die.net/man/3/fma).

LIBBUILTIN(fma, "dddd", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fmaf, "ffff", "fne", "math.h", ALL_LANGUAGES)
LIBBUILTIN(fmal, "LdLdLdLd", "fne", "math.h", ALL_LANGUAGES)

But we don't check the const attribute in CGBuiltin.cpp before converting it to an intrinsic

case Builtin::BIfma:
case Builtin::BIfmaf:
case Builtin::BIfmal:
case Builtin::BI__builtin_fma:
case Builtin::BI__builtin_fmaf:
case Builtin::BI__builtin_fmal: {
  // Rewrite fma to intrinsic.
  Value *FirstArg = EmitScalarExpr(E->getArg(0));
  llvm::Type *ArgType = FirstArg->getType();
  Value *F = CGM.getIntrinsic(Intrinsic::fma, ArgType);
  return RValue::get(
      Builder.CreateCall(F, {FirstArg, EmitScalarExpr(E->getArg(1)),
                             EmitScalarExpr(E->getArg(2))}));
}

[spatel]

Patch updated:
Make const-ness of the builtins match const-ness of their lib function siblings. We're deferring fixing some of these that are obviously wrong to follow-up patches. Hopefully, the bugs are visible in the new test file (added at rL317220).

These are the differences I noted from the previous rev of the patch:
ceil, floor, rint, round, and everything in complex are left as constant regardless of errno.
lgamma is not constant regardless of errno.

[efriedma]

LGTM.

(For reference, lgamma is weird because of the POSIX signgam.)

cfe/trunk/include/clang/Basic/Builtins.def

 #  define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
 #endif
 
 #if defined(BUILTIN) && !defined(LANGBUILTIN)
 #  define LANGBUILTIN(ID, TYPE, ATTRS, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
 #endif
 
 // Standard libc/libm functions:
-BUILTIN(__builtin_atan2 , "ddd"  , "Fnc")
-BUILTIN(__builtin_atan2f, "fff"  , "Fnc")
-BUILTIN(__builtin_atan2l, "LdLdLd", "Fnc")
+BUILTIN(__builtin_atan2 , "ddd"  , "Fne")
+BUILTIN(__builtin_atan2f, "fff"  , "Fne")
+BUILTIN(__builtin_atan2l, "LdLdLd", "Fne")
 BUILTIN(__builtin_abs  , "ii"  , "ncF")
 BUILTIN(__builtin_copysign, "ddd", "ncF")
 BUILTIN(__builtin_copysignf, "fff", "ncF")
 BUILTIN(__builtin_copysignl, "LdLdLd", "ncF")
 BUILTIN(__builtin_fabs , "dd"  , "ncF")
 BUILTIN(__builtin_fabsf, "ff"  , "ncF")
 BUILTIN(__builtin_fabsl, "LdLd", "ncF")
-BUILTIN(__builtin_fmod , "ddd"  , "Fnc")
-BUILTIN(__builtin_fmodf, "fff"  , "Fnc")
-BUILTIN(__builtin_fmodl, "LdLdLd", "Fnc")
+BUILTIN(__builtin_fmod , "ddd"  , "Fne")
+BUILTIN(__builtin_fmodf, "fff"  , "Fne")
+BUILTIN(__builtin_fmodl, "LdLdLd", "Fne")
 BUILTIN(__builtin_frexp , "ddi*"  , "Fn")
 BUILTIN(__builtin_frexpf, "ffi*"  , "Fn")
 BUILTIN(__builtin_frexpl, "LdLdi*", "Fn")
 BUILTIN(__builtin_huge_val, "d", "nc")
 BUILTIN(__builtin_huge_valf, "f", "nc")
 BUILTIN(__builtin_huge_vall, "Ld", "nc")
 BUILTIN(__builtin_inf  , "d"   , "nc")
 BUILTIN(__builtin_inff , "f"   , "nc")
 BUILTIN(__builtin_infl , "Ld"  , "nc")
 BUILTIN(__builtin_labs , "LiLi"  , "Fnc")
 BUILTIN(__builtin_llabs, "LLiLLi", "Fnc")
-BUILTIN(__builtin_ldexp , "ddi"  , "Fnc")
-BUILTIN(__builtin_ldexpf, "ffi"  , "Fnc")
-BUILTIN(__builtin_ldexpl, "LdLdi", "Fnc")
+BUILTIN(__builtin_ldexp , "ddi"  , "Fne")
+BUILTIN(__builtin_ldexpf, "ffi"  , "Fne")
+BUILTIN(__builtin_ldexpl, "LdLdi", "Fne")
 BUILTIN(__builtin_modf , "ddd*"  , "Fn")
 BUILTIN(__builtin_modff, "fff*"  , "Fn")
 BUILTIN(__builtin_modfl, "LdLdLd*", "Fn")
 BUILTIN(__builtin_nan,  "dcC*" , "ncF")
 BUILTIN(__builtin_nanf, "fcC*" , "ncF")
 BUILTIN(__builtin_nanl, "LdcC*", "ncF")
 BUILTIN(__builtin_nans,  "dcC*" , "ncF")
 BUILTIN(__builtin_nansf, "fcC*" , "ncF")
 BUILTIN(__builtin_nansl, "LdcC*", "ncF")
 BUILTIN(__builtin_powi , "ddi"  , "Fnc")
 BUILTIN(__builtin_powif, "ffi"  , "Fnc")
 BUILTIN(__builtin_powil, "LdLdi", "Fnc")
-BUILTIN(__builtin_pow , "ddd"  , "Fnc")
-BUILTIN(__builtin_powf, "fff"  , "Fnc")
-BUILTIN(__builtin_powl, "LdLdLd", "Fnc")
+BUILTIN(__builtin_pow , "ddd"  , "Fne")
+BUILTIN(__builtin_powf, "fff"  , "Fne")
+BUILTIN(__builtin_powl, "LdLdLd", "Fne")
 
 // Standard unary libc/libm functions with double/float/long double variants:
-BUILTIN(__builtin_acos , "dd"  , "Fnc")
-BUILTIN(__builtin_acosf, "ff"  , "Fnc")
-BUILTIN(__builtin_acosl, "LdLd", "Fnc")
-BUILTIN(__builtin_acosh , "dd"  , "Fnc")
-BUILTIN(__builtin_acoshf, "ff"  , "Fnc")
-BUILTIN(__builtin_acoshl, "LdLd", "Fnc")
-BUILTIN(__builtin_asin , "dd"  , "Fnc")
-BUILTIN(__builtin_asinf, "ff"  , "Fnc")
-BUILTIN(__builtin_asinl, "LdLd", "Fnc")
-BUILTIN(__builtin_asinh , "dd"  , "Fnc")
-BUILTIN(__builtin_asinhf, "ff"  , "Fnc")
-BUILTIN(__builtin_asinhl, "LdLd", "Fnc")
-BUILTIN(__builtin_atan , "dd"  , "Fnc")
-BUILTIN(__builtin_atanf, "ff"  , "Fnc")
-BUILTIN(__builtin_atanl, "LdLd", "Fnc")
-BUILTIN(__builtin_atanh , "dd", "Fnc")
-BUILTIN(__builtin_atanhf, "ff", "Fnc")
-BUILTIN(__builtin_atanhl, "LdLd", "Fnc")
-BUILTIN(__builtin_cbrt , "dd", "Fnc")
-BUILTIN(__builtin_cbrtf, "ff", "Fnc")
-BUILTIN(__builtin_cbrtl, "LdLd", "Fnc")
+BUILTIN(__builtin_acos , "dd"  , "Fne")
+BUILTIN(__builtin_acosf, "ff"  , "Fne")
+BUILTIN(__builtin_acosl, "LdLd", "Fne")
+BUILTIN(__builtin_acosh , "dd"  , "Fne")
+BUILTIN(__builtin_acoshf, "ff"  , "Fne")
+BUILTIN(__builtin_acoshl, "LdLd", "Fne")
+BUILTIN(__builtin_asin , "dd"  , "Fne")
+BUILTIN(__builtin_asinf, "ff"  , "Fne")
+BUILTIN(__builtin_asinl, "LdLd", "Fne")
+BUILTIN(__builtin_asinh , "dd"  , "Fne")
+BUILTIN(__builtin_asinhf, "ff"  , "Fne")
+BUILTIN(__builtin_asinhl, "LdLd", "Fne")
+BUILTIN(__builtin_atan , "dd"  , "Fne")
+BUILTIN(__builtin_atanf, "ff"  , "Fne")
+BUILTIN(__builtin_atanl, "LdLd", "Fne")
+BUILTIN(__builtin_atanh , "dd", "Fne")
+BUILTIN(__builtin_atanhf, "ff", "Fne")
+BUILTIN(__builtin_atanhl, "LdLd", "Fne")
+BUILTIN(__builtin_cbrt , "dd", "Fne")
+BUILTIN(__builtin_cbrtf, "ff", "Fne")
+BUILTIN(__builtin_cbrtl, "LdLd", "Fne")
 BUILTIN(__builtin_ceil , "dd"  , "Fnc")
 BUILTIN(__builtin_ceilf, "ff"  , "Fnc")
 BUILTIN(__builtin_ceill, "LdLd", "Fnc")
-BUILTIN(__builtin_cos , "dd"  , "Fnc")
-BUILTIN(__builtin_cosf, "ff"  , "Fnc")
-BUILTIN(__builtin_cosh , "dd"  , "Fnc")
-BUILTIN(__builtin_coshf, "ff"  , "Fnc")
-BUILTIN(__builtin_coshl, "LdLd", "Fnc")
-BUILTIN(__builtin_cosl, "LdLd", "Fnc")
-BUILTIN(__builtin_erf , "dd", "Fnc")
-BUILTIN(__builtin_erff, "ff", "Fnc")
-BUILTIN(__builtin_erfl, "LdLd", "Fnc")
-BUILTIN(__builtin_erfc , "dd", "Fnc")
-BUILTIN(__builtin_erfcf, "ff", "Fnc")
-BUILTIN(__builtin_erfcl, "LdLd", "Fnc")
-BUILTIN(__builtin_exp , "dd"  , "Fnc")
-BUILTIN(__builtin_expf, "ff"  , "Fnc")
-BUILTIN(__builtin_expl, "LdLd", "Fnc")
-BUILTIN(__builtin_exp2 , "dd"  , "Fnc")
-BUILTIN(__builtin_exp2f, "ff"  , "Fnc")
-BUILTIN(__builtin_exp2l, "LdLd", "Fnc")
-BUILTIN(__builtin_expm1 , "dd", "Fnc")
-BUILTIN(__builtin_expm1f, "ff", "Fnc")
-BUILTIN(__builtin_expm1l, "LdLd", "Fnc")
-BUILTIN(__builtin_fdim, "ddd", "Fnc")
-BUILTIN(__builtin_fdimf, "fff", "Fnc")
-BUILTIN(__builtin_fdiml, "LdLdLd", "Fnc")
+BUILTIN(__builtin_cos , "dd"  , "Fne")
+BUILTIN(__builtin_cosf, "ff"  , "Fne")
+BUILTIN(__builtin_cosh , "dd"  , "Fne")
+BUILTIN(__builtin_coshf, "ff"  , "Fne")
+BUILTIN(__builtin_coshl, "LdLd", "Fne")
+BUILTIN(__builtin_cosl, "LdLd", "Fne")
+BUILTIN(__builtin_erf , "dd", "Fne")
+BUILTIN(__builtin_erff, "ff", "Fne")
+BUILTIN(__builtin_erfl, "LdLd", "Fne")
+BUILTIN(__builtin_erfc , "dd", "Fne")
+BUILTIN(__builtin_erfcf, "ff", "Fne")
+BUILTIN(__builtin_erfcl, "LdLd", "Fne")
+BUILTIN(__builtin_exp , "dd"  , "Fne")
+BUILTIN(__builtin_expf, "ff"  , "Fne")
+BUILTIN(__builtin_expl, "LdLd", "Fne")
+BUILTIN(__builtin_exp2 , "dd"  , "Fne")
+BUILTIN(__builtin_exp2f, "ff"  , "Fne")
+BUILTIN(__builtin_exp2l, "LdLd", "Fne")
+BUILTIN(__builtin_expm1 , "dd", "Fne")
+BUILTIN(__builtin_expm1f, "ff", "Fne")
+BUILTIN(__builtin_expm1l, "LdLd", "Fne")
+BUILTIN(__builtin_fdim, "ddd", "Fne")
+BUILTIN(__builtin_fdimf, "fff", "Fne")
+BUILTIN(__builtin_fdiml, "LdLdLd", "Fne")
 BUILTIN(__builtin_floor , "dd"  , "Fnc")
 BUILTIN(__builtin_floorf, "ff"  , "Fnc")
 BUILTIN(__builtin_floorl, "LdLd", "Fnc")
-BUILTIN(__builtin_fma, "dddd", "Fnc")
-BUILTIN(__builtin_fmaf, "ffff", "Fnc")
-BUILTIN(__builtin_fmal, "LdLdLdLd", "Fnc")
+BUILTIN(__builtin_fma, "dddd", "Fne")
+BUILTIN(__builtin_fmaf, "ffff", "Fne")
+BUILTIN(__builtin_fmal, "LdLdLdLd", "Fne")
 BUILTIN(__builtin_fmax, "ddd", "Fnc")
 BUILTIN(__builtin_fmaxf, "fff", "Fnc")
 BUILTIN(__builtin_fmaxl, "LdLdLd", "Fnc")
 BUILTIN(__builtin_fmin, "ddd", "Fnc")
 BUILTIN(__builtin_fminf, "fff", "Fnc")
 BUILTIN(__builtin_fminl, "LdLdLd", "Fnc")
-BUILTIN(__builtin_hypot , "ddd"  , "Fnc")
-BUILTIN(__builtin_hypotf, "fff"  , "Fnc")
-BUILTIN(__builtin_hypotl, "LdLdLd", "Fnc")
-BUILTIN(__builtin_ilogb , "id", "Fnc")
-BUILTIN(__builtin_ilogbf, "if", "Fnc")
-BUILTIN(__builtin_ilogbl, "iLd", "Fnc")
-BUILTIN(__builtin_lgamma , "dd", "Fnc")
-BUILTIN(__builtin_lgammaf, "ff", "Fnc")
-BUILTIN(__builtin_lgammal, "LdLd", "Fnc")
-BUILTIN(__builtin_llrint, "LLid", "Fnc")
-BUILTIN(__builtin_llrintf, "LLif", "Fnc")
-BUILTIN(__builtin_llrintl, "LLiLd", "Fnc")
-BUILTIN(__builtin_llround , "LLid", "Fnc")
-BUILTIN(__builtin_llroundf, "LLif", "Fnc")
-BUILTIN(__builtin_llroundl, "LLiLd", "Fnc")
-BUILTIN(__builtin_log , "dd"  , "Fnc")
-BUILTIN(__builtin_log10 , "dd"  , "Fnc")
-BUILTIN(__builtin_log10f, "ff"  , "Fnc")
-BUILTIN(__builtin_log10l, "LdLd", "Fnc")
-BUILTIN(__builtin_log1p , "dd"  , "Fnc")
-BUILTIN(__builtin_log1pf, "ff"  , "Fnc")
-BUILTIN(__builtin_log1pl, "LdLd", "Fnc")
-BUILTIN(__builtin_log2, "dd"  , "Fnc")
-BUILTIN(__builtin_log2f, "ff"  , "Fnc")
-BUILTIN(__builtin_log2l, "LdLd"  , "Fnc")
-BUILTIN(__builtin_logb , "dd", "Fnc")
-BUILTIN(__builtin_logbf, "ff", "Fnc")
-BUILTIN(__builtin_logbl, "LdLd", "Fnc")
-BUILTIN(__builtin_logf, "ff"  , "Fnc")
-BUILTIN(__builtin_logl, "LdLd", "Fnc")
-BUILTIN(__builtin_lrint , "Lid", "Fnc")
-BUILTIN(__builtin_lrintf, "Lif", "Fnc")
-BUILTIN(__builtin_lrintl, "LiLd", "Fnc")
-BUILTIN(__builtin_lround , "Lid", "Fnc")
-BUILTIN(__builtin_lroundf, "Lif", "Fnc")
-BUILTIN(__builtin_lroundl, "LiLd", "Fnc")
+BUILTIN(__builtin_hypot , "ddd"  , "Fne")
+BUILTIN(__builtin_hypotf, "fff"  , "Fne")
+BUILTIN(__builtin_hypotl, "LdLdLd", "Fne")
+BUILTIN(__builtin_ilogb , "id", "Fne")
+BUILTIN(__builtin_ilogbf, "if", "Fne")
+BUILTIN(__builtin_ilogbl, "iLd", "Fne")
+BUILTIN(__builtin_lgamma , "dd", "Fn")
+BUILTIN(__builtin_lgammaf, "ff", "Fn")
+BUILTIN(__builtin_lgammal, "LdLd", "Fn")
+BUILTIN(__builtin_llrint, "LLid", "Fne")
+BUILTIN(__builtin_llrintf, "LLif", "Fne")
+BUILTIN(__builtin_llrintl, "LLiLd", "Fne")
+BUILTIN(__builtin_llround , "LLid", "Fne")
+BUILTIN(__builtin_llroundf, "LLif", "Fne")
+BUILTIN(__builtin_llroundl, "LLiLd", "Fne")
+BUILTIN(__builtin_log , "dd"  , "Fne")
+BUILTIN(__builtin_log10 , "dd"  , "Fne")
+BUILTIN(__builtin_log10f, "ff"  , "Fne")
+BUILTIN(__builtin_log10l, "LdLd", "Fne")
+BUILTIN(__builtin_log1p , "dd"  , "Fne")
+BUILTIN(__builtin_log1pf, "ff"  , "Fne")
+BUILTIN(__builtin_log1pl, "LdLd", "Fne")
+BUILTIN(__builtin_log2, "dd"  , "Fne")
+BUILTIN(__builtin_log2f, "ff"  , "Fne")
+BUILTIN(__builtin_log2l, "LdLd"  , "Fne")
+BUILTIN(__builtin_logb , "dd", "Fne")
+BUILTIN(__builtin_logbf, "ff", "Fne")
+BUILTIN(__builtin_logbl, "LdLd", "Fne")
+BUILTIN(__builtin_logf, "ff"  , "Fne")
+BUILTIN(__builtin_logl, "LdLd", "Fne")
+BUILTIN(__builtin_lrint , "Lid", "Fne")
+BUILTIN(__builtin_lrintf, "Lif", "Fne")
+BUILTIN(__builtin_lrintl, "LiLd", "Fne")
+BUILTIN(__builtin_lround , "Lid", "Fne")
+BUILTIN(__builtin_lroundf, "Lif", "Fne")
+BUILTIN(__builtin_lroundl, "LiLd", "Fne")
 BUILTIN(__builtin_nearbyint , "dd", "Fnc")
 BUILTIN(__builtin_nearbyintf, "ff", "Fnc")
 BUILTIN(__builtin_nearbyintl, "LdLd", "Fnc")
-BUILTIN(__builtin_nextafter , "ddd", "Fnc")
-BUILTIN(__builtin_nextafterf, "fff", "Fnc")
-BUILTIN(__builtin_nextafterl, "LdLdLd", "Fnc")
-BUILTIN(__builtin_nexttoward , "ddLd", "Fnc")
-BUILTIN(__builtin_nexttowardf, "ffLd", "Fnc")
-BUILTIN(__builtin_nexttowardl, "LdLdLd", "Fnc")
-BUILTIN(__builtin_remainder , "ddd", "Fnc")
-BUILTIN(__builtin_remainderf, "fff", "Fnc")
-BUILTIN(__builtin_remainderl, "LdLdLd", "Fnc")
+BUILTIN(__builtin_nextafter , "ddd", "Fne")
+BUILTIN(__builtin_nextafterf, "fff", "Fne")
+BUILTIN(__builtin_nextafterl, "LdLdLd", "Fne")
+BUILTIN(__builtin_nexttoward , "ddLd", "Fne")
+BUILTIN(__builtin_nexttowardf, "ffLd", "Fne")
+BUILTIN(__builtin_nexttowardl, "LdLdLd", "Fne")
+BUILTIN(__builtin_remainder , "ddd", "Fne")
+BUILTIN(__builtin_remainderf, "fff", "Fne")
+BUILTIN(__builtin_remainderl, "LdLdLd", "Fne")
 BUILTIN(__builtin_remquo , "dddi*", "Fn")
 BUILTIN(__builtin_remquof, "fffi*", "Fn")
 BUILTIN(__builtin_remquol, "LdLdLdi*", "Fn")
 BUILTIN(__builtin_rint , "dd", "Fnc")
 BUILTIN(__builtin_rintf, "ff", "Fnc")
 BUILTIN(__builtin_rintl, "LdLd", "Fnc")
 BUILTIN(__builtin_round, "dd"  , "Fnc")
 BUILTIN(__builtin_roundf, "ff"  , "Fnc")
 BUILTIN(__builtin_roundl, "LdLd"  , "Fnc")
-BUILTIN(__builtin_scalbln , "ddLi", "Fnc")
-BUILTIN(__builtin_scalblnf, "ffLi", "Fnc")
-BUILTIN(__builtin_scalblnl, "LdLdLi", "Fnc")
-BUILTIN(__builtin_scalbn , "ddi", "Fnc")
-BUILTIN(__builtin_scalbnf, "ffi", "Fnc")
-BUILTIN(__builtin_scalbnl, "LdLdi", "Fnc")
-BUILTIN(__builtin_sin , "dd"  , "Fnc")
-BUILTIN(__builtin_sinf, "ff"  , "Fnc")
-BUILTIN(__builtin_sinh , "dd"  , "Fnc")
-BUILTIN(__builtin_sinhf, "ff"  , "Fnc")
-BUILTIN(__builtin_sinhl, "LdLd", "Fnc")
-BUILTIN(__builtin_sinl, "LdLd", "Fnc")
-BUILTIN(__builtin_sqrt , "dd"  , "Fnc")
-BUILTIN(__builtin_sqrtf, "ff"  , "Fnc")
-BUILTIN(__builtin_sqrtl, "LdLd", "Fnc")
-BUILTIN(__builtin_tan , "dd"  , "Fnc")
-BUILTIN(__builtin_tanf, "ff"  , "Fnc")
-BUILTIN(__builtin_tanh , "dd"  , "Fnc")
-BUILTIN(__builtin_tanhf, "ff"  , "Fnc")
-BUILTIN(__builtin_tanhl, "LdLd", "Fnc")
-BUILTIN(__builtin_tanl, "LdLd", "Fnc")
-BUILTIN(__builtin_tgamma , "dd", "Fnc")
-BUILTIN(__builtin_tgammaf, "ff", "Fnc")
-BUILTIN(__builtin_tgammal, "LdLd", "Fnc")
+BUILTIN(__builtin_scalbln , "ddLi", "Fne")
+BUILTIN(__builtin_scalblnf, "ffLi", "Fne")
+BUILTIN(__builtin_scalblnl, "LdLdLi", "Fne")
+BUILTIN(__builtin_scalbn , "ddi", "Fne")
+BUILTIN(__builtin_scalbnf, "ffi", "Fne")
+BUILTIN(__builtin_scalbnl, "LdLdi", "Fne")
+BUILTIN(__builtin_sin , "dd"  , "Fne")
+BUILTIN(__builtin_sinf, "ff"  , "Fne")
+BUILTIN(__builtin_sinh , "dd"  , "Fne")
+BUILTIN(__builtin_sinhf, "ff"  , "Fne")
+BUILTIN(__builtin_sinhl, "LdLd", "Fne")
+BUILTIN(__builtin_sinl, "LdLd", "Fne")
+BUILTIN(__builtin_sqrt , "dd"  , "Fne")
+BUILTIN(__builtin_sqrtf, "ff"  , "Fne")
+BUILTIN(__builtin_sqrtl, "LdLd", "Fne")
+BUILTIN(__builtin_tan , "dd"  , "Fne")
+BUILTIN(__builtin_tanf, "ff"  , "Fne")
+BUILTIN(__builtin_tanh , "dd"  , "Fne")
+BUILTIN(__builtin_tanhf, "ff"  , "Fne")
+BUILTIN(__builtin_tanhl, "LdLd", "Fne")
+BUILTIN(__builtin_tanl, "LdLd", "Fne")
+BUILTIN(__builtin_tgamma , "dd", "Fne")
+BUILTIN(__builtin_tgammaf, "ff", "Fne")
+BUILTIN(__builtin_tgammal, "LdLd", "Fne")
 BUILTIN(__builtin_trunc , "dd", "Fnc")
 BUILTIN(__builtin_truncf, "ff", "Fnc")
 BUILTIN(__builtin_truncl, "LdLd", "Fnc")
 
 // C99 complex builtins
 BUILTIN(__builtin_cabs, "dXd", "Fnc")
 BUILTIN(__builtin_cabsf, "fXf", "Fnc")
 BUILTIN(__builtin_cabsl, "LdXLd", "Fnc")

cfe/trunk/test/CodeGen/builtin-errno.c

 // HAS_ERRNO-NOT: @labs
 // HAS_ERRNO-NOT: @llabs
 
   __builtin_atan2(f,f);    __builtin_atan2f(f,f) ;  __builtin_atan2l(f, f);
 
 // NO__ERRNO: declare double @atan2(double, double) [[READNONE:#[0-9]+]]
 // NO__ERRNO: declare float @atan2f(float, float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @atan2(double, double) [[READNONE:#[0-9]+]]
-// HAS_ERRNO: declare float @atan2f(float, float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @atan2(double, double) [[NOT_READNONE:#[0-9]+]]
+// HAS_ERRNO: declare float @atan2f(float, float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[NOT_READNONE]]
 
   __builtin_copysign(f,f); __builtin_copysignf(f,f);__builtin_copysignl(f,f);
 
 // NO__ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC:#[0-9]+]]
 // NO__ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC:#[0-9]+]]
 // HAS_ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC]]

 // HAS_ERRNO-NOT: .fmod
 // HAS_ERRNO-NOT: @fmod
 
   __builtin_frexp(f,i);    __builtin_frexpf(f,i);   __builtin_frexpl(f,i);
 
 // NO__ERRNO: declare double @frexp(double, i32*) [[NOT_READNONE:#[0-9]+]]
 // NO__ERRNO: declare float @frexpf(float, i32*) [[NOT_READNONE]]
 // NO__ERRNO: declare x86_fp80 @frexpl(x86_fp80, i32*) [[NOT_READNONE]]
-// HAS_ERRNO: declare double @frexp(double, i32*) [[NOT_READNONE:#[0-9]+]]
+// HAS_ERRNO: declare double @frexp(double, i32*) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @frexpf(float, i32*) [[NOT_READNONE]]
 // HAS_ERRNO: declare x86_fp80 @frexpl(x86_fp80, i32*) [[NOT_READNONE]]
 
   __builtin_huge_val();    __builtin_huge_valf();   __builtin_huge_vall();
 
 // NO__ERRNO-NOT: .huge
 // NO__ERRNO-NOT: @huge
 // HAS_ERRNO-NOT: .huge
 // HAS_ERRNO-NOT: @huge
 
   __builtin_inf();    __builtin_inff();   __builtin_infl();
 
 // NO__ERRNO-NOT: .inf
 // NO__ERRNO-NOT: @inf
 // HAS_ERRNO-NOT: .inf
 // HAS_ERRNO-NOT: @inf
 
   __builtin_ldexp(f,f);    __builtin_ldexpf(f,f);   __builtin_ldexpl(f,f);  
 
 // NO__ERRNO: declare double @ldexp(double, i32) [[READNONE]]
 // NO__ERRNO: declare float @ldexpf(float, i32) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @ldexpl(x86_fp80, i32) [[READNONE]]
-// HAS_ERRNO: declare double @ldexp(double, i32) [[READNONE]]
-// HAS_ERRNO: declare float @ldexpf(float, i32) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @ldexpl(x86_fp80, i32) [[READNONE]]
+// HAS_ERRNO: declare double @ldexp(double, i32) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @ldexpf(float, i32) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @ldexpl(x86_fp80, i32) [[NOT_READNONE]]
 
   __builtin_modf(f,d);       __builtin_modff(f,fp);      __builtin_modfl(f,l); 
 
 // NO__ERRNO: declare double @modf(double, double*) [[NOT_READNONE]]
 // NO__ERRNO: declare float @modff(float, float*) [[NOT_READNONE]]
 // NO__ERRNO: declare x86_fp80 @modfl(x86_fp80, x86_fp80*) [[NOT_READNONE]]
 // HAS_ERRNO: declare double @modf(double, double*) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @modff(float, float*) [[NOT_READNONE]]

 // HAS_ERRNO: declare float @nansf(i8*) [[READNONE]]
 // HAS_ERRNO: declare x86_fp80 @nansl(i8*) [[READNONE]]
 
   __builtin_pow(f,f);        __builtin_powf(f,f);       __builtin_powl(f,f);
 
 // NO__ERRNO: declare double @llvm.pow.f64(double, double) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare float @llvm.pow.f32(float, float) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare x86_fp80 @llvm.pow.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
-// HAS_ERRNO: declare double @llvm.pow.f64(double, double) [[READNONE_INTRINSIC]]
-// HAS_ERRNO: declare float @llvm.pow.f32(float, float) [[READNONE_INTRINSIC]]
-// HAS_ERRNO: declare x86_fp80 @llvm.pow.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare double @pow(double, double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @powf(float, float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @powl(x86_fp80, x86_fp80) [[NOT_READNONE]]
 
   __builtin_powi(f,f);        __builtin_powif(f,f);       __builtin_powil(f,f);
 
 // NO__ERRNO: declare double @llvm.powi.f64(double, i32) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare float @llvm.powi.f32(float, i32) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare x86_fp80 @llvm.powi.f80(x86_fp80, i32) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare double @llvm.powi.f64(double, i32) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare float @llvm.powi.f32(float, i32) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare x86_fp80 @llvm.powi.f80(x86_fp80, i32) [[READNONE_INTRINSIC]]
 
   /* math */
   __builtin_acos(f);       __builtin_acosf(f);      __builtin_acosl(f);
 
 // NO__ERRNO: declare double @acos(double) [[READNONE]]
 // NO__ERRNO: declare float @acosf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @acosl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @acos(double) [[READNONE]]
-// HAS_ERRNO: declare float @acosf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @acosl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @acos(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @acosf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @acosl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_acosh(f);      __builtin_acoshf(f);     __builtin_acoshl(f);  
 
 // NO__ERRNO: declare double @acosh(double) [[READNONE]]
 // NO__ERRNO: declare float @acoshf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @acoshl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @acosh(double) [[READNONE]]
-// HAS_ERRNO: declare float @acoshf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @acoshl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @acosh(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @acoshf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @acoshl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_asin(f);       __builtin_asinf(f);      __builtin_asinl(f); 
 
 // NO__ERRNO: declare double @asin(double) [[READNONE]]
 // NO__ERRNO: declare float @asinf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @asinl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @asin(double) [[READNONE]]
-// HAS_ERRNO: declare float @asinf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @asinl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @asin(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @asinf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @asinl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_asinh(f);      __builtin_asinhf(f);     __builtin_asinhl(f);
 
 // NO__ERRNO: declare double @asinh(double) [[READNONE]]
 // NO__ERRNO: declare float @asinhf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @asinhl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @asinh(double) [[READNONE]]
-// HAS_ERRNO: declare float @asinhf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @asinhl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @asinh(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @asinhf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @asinhl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_atan(f);       __builtin_atanf(f);      __builtin_atanl(f);
 
 // NO__ERRNO: declare double @atan(double) [[READNONE]]
 // NO__ERRNO: declare float @atanf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @atanl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @atan(double) [[READNONE]]
-// HAS_ERRNO: declare float @atanf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @atanl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @atan(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @atanf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @atanl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_atanh(f);      __builtin_atanhf(f);     __builtin_atanhl(f); 
 
 // NO__ERRNO: declare double @atanh(double) [[READNONE]]
 // NO__ERRNO: declare float @atanhf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @atanhl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @atanh(double) [[READNONE]]
-// HAS_ERRNO: declare float @atanhf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @atanhl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @atanh(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @atanhf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @atanhl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_cbrt(f);       __builtin_cbrtf(f);      __builtin_cbrtl(f);
 
 // NO__ERRNO: declare double @cbrt(double) [[READNONE]]
 // NO__ERRNO: declare float @cbrtf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @cbrtl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @cbrt(double) [[READNONE]]
-// HAS_ERRNO: declare float @cbrtf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @cbrtl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @cbrt(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @cbrtf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @cbrtl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_ceil(f);       __builtin_ceilf(f);      __builtin_ceill(f);
 
 // NO__ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC]]
 
   __builtin_cos(f);        __builtin_cosf(f);       __builtin_cosl(f); 
 
 // NO__ERRNO: declare double @cos(double) [[READNONE]]
 // NO__ERRNO: declare float @cosf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @cosl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @cos(double) [[READNONE]]
-// HAS_ERRNO: declare float @cosf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @cosl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @cos(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @cosf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @cosl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_cosh(f);       __builtin_coshf(f);      __builtin_coshl(f);
 
 // NO__ERRNO: declare double @cosh(double) [[READNONE]]
 // NO__ERRNO: declare float @coshf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @coshl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @cosh(double) [[READNONE]]
-// HAS_ERRNO: declare float @coshf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @coshl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @cosh(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @coshf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @coshl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_erf(f);        __builtin_erff(f);       __builtin_erfl(f);
 
 // NO__ERRNO: declare double @erf(double) [[READNONE]]
 // NO__ERRNO: declare float @erff(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @erfl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @erf(double) [[READNONE]]
-// HAS_ERRNO: declare float @erff(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @erfl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @erf(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @erff(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @erfl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_erfc(f);       __builtin_erfcf(f);      __builtin_erfcl(f);
 
 // NO__ERRNO: declare double @erfc(double) [[READNONE]]
 // NO__ERRNO: declare float @erfcf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @erfcl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @erfc(double) [[READNONE]]
-// HAS_ERRNO: declare float @erfcf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @erfcl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @erfc(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @erfcf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @erfcl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_exp(f);        __builtin_expf(f);       __builtin_expl(f);
 
 // NO__ERRNO: declare double @exp(double) [[READNONE]]
 // NO__ERRNO: declare float @expf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @expl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @exp(double) [[READNONE]]
-// HAS_ERRNO: declare float @expf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @expl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @exp(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @expf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @expl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_exp2(f);       __builtin_exp2f(f);      __builtin_exp2l(f); 
 
 // NO__ERRNO: declare double @exp2(double) [[READNONE]]
 // NO__ERRNO: declare float @exp2f(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @exp2l(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @exp2(double) [[READNONE]]
-// HAS_ERRNO: declare float @exp2f(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @exp2l(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @exp2(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @exp2f(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @exp2l(x86_fp80) [[NOT_READNONE]]
 
   __builtin_expm1(f);      __builtin_expm1f(f);     __builtin_expm1l(f);
 
 // NO__ERRNO: declare double @expm1(double) [[READNONE]]
 // NO__ERRNO: declare float @expm1f(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @expm1l(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @expm1(double) [[READNONE]]
-// HAS_ERRNO: declare float @expm1f(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @expm1l(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @expm1(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @expm1f(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @expm1l(x86_fp80) [[NOT_READNONE]]
 
   __builtin_fdim(f,f);       __builtin_fdimf(f,f);      __builtin_fdiml(f,f);
 
 // NO__ERRNO: declare double @fdim(double, double) [[READNONE]]
 // NO__ERRNO: declare float @fdimf(float, float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @fdiml(x86_fp80, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @fdim(double, double) [[READNONE]]
-// HAS_ERRNO: declare float @fdimf(float, float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @fdiml(x86_fp80, x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @fdim(double, double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @fdimf(float, float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @fdiml(x86_fp80, x86_fp80) [[NOT_READNONE]]
 
   __builtin_floor(f);      __builtin_floorf(f);     __builtin_floorl(f);
 
 // NO__ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC]]

 // HAS_ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
 
   __builtin_hypot(f,f);      __builtin_hypotf(f,f);     __builtin_hypotl(f,f);
 
 // NO__ERRNO: declare double @hypot(double, double) [[READNONE]]
 // NO__ERRNO: declare float @hypotf(float, float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @hypotl(x86_fp80, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @hypot(double, double) [[READNONE]]
-// HAS_ERRNO: declare float @hypotf(float, float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @hypotl(x86_fp80, x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @hypot(double, double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @hypotf(float, float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @hypotl(x86_fp80, x86_fp80) [[NOT_READNONE]]
 
   __builtin_ilogb(f);      __builtin_ilogbf(f);     __builtin_ilogbl(f); 
 
 // NO__ERRNO: declare i32 @ilogb(double) [[READNONE]]
 // NO__ERRNO: declare i32 @ilogbf(float) [[READNONE]]
 // NO__ERRNO: declare i32 @ilogbl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare i32 @ilogb(double) [[READNONE]]
-// HAS_ERRNO: declare i32 @ilogbf(float) [[READNONE]]
-// HAS_ERRNO: declare i32 @ilogbl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare i32 @ilogb(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare i32 @ilogbf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare i32 @ilogbl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_lgamma(f);     __builtin_lgammaf(f);    __builtin_lgammal(f);
 
-// NO__ERRNO: declare double @lgamma(double) [[READNONE]]
-// NO__ERRNO: declare float @lgammaf(float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @lgammal(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @lgamma(double) [[READNONE]]
-// HAS_ERRNO: declare float @lgammaf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @lgammal(x86_fp80) [[READNONE]]
+// NO__ERRNO: declare double @lgamma(double) [[NOT_READNONE]]
+// NO__ERRNO: declare float @lgammaf(float) [[NOT_READNONE]]
+// NO__ERRNO: declare x86_fp80 @lgammal(x86_fp80) [[NOT_READNONE]]
+// HAS_ERRNO: declare double @lgamma(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @lgammaf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @lgammal(x86_fp80) [[NOT_READNONE]]
 
   __builtin_llrint(f);     __builtin_llrintf(f);    __builtin_llrintl(f);
 
 // NO__ERRNO: declare i64 @llrint(double) [[READNONE]]
 // NO__ERRNO: declare i64 @llrintf(float) [[READNONE]]
 // NO__ERRNO: declare i64 @llrintl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare i64 @llrint(double) [[READNONE]]
-// HAS_ERRNO: declare i64 @llrintf(float) [[READNONE]]
-// HAS_ERRNO: declare i64 @llrintl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare i64 @llrint(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare i64 @llrintf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare i64 @llrintl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_llround(f);    __builtin_llroundf(f);   __builtin_llroundl(f);
 
 // NO__ERRNO: declare i64 @llround(double) [[READNONE]]
 // NO__ERRNO: declare i64 @llroundf(float) [[READNONE]]
 // NO__ERRNO: declare i64 @llroundl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare i64 @llround(double) [[READNONE]]
-// HAS_ERRNO: declare i64 @llroundf(float) [[READNONE]]
-// HAS_ERRNO: declare i64 @llroundl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare i64 @llround(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare i64 @llroundf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare i64 @llroundl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_log(f);        __builtin_logf(f);       __builtin_logl(f);
 
 // NO__ERRNO: declare double @log(double) [[READNONE]]
 // NO__ERRNO: declare float @logf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @logl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @log(double) [[READNONE]]
-// HAS_ERRNO: declare float @logf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @logl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @log(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @logf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @logl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_log10(f);      __builtin_log10f(f);     __builtin_log10l(f);
 
 // NO__ERRNO: declare double @log10(double) [[READNONE]]
 // NO__ERRNO: declare float @log10f(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @log10l(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @log10(double) [[READNONE]]
-// HAS_ERRNO: declare float @log10f(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @log10l(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @log10(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @log10f(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @log10l(x86_fp80) [[NOT_READNONE]]
 
   __builtin_log1p(f);      __builtin_log1pf(f);     __builtin_log1pl(f);
 
 // NO__ERRNO: declare double @log1p(double) [[READNONE]]
 // NO__ERRNO: declare float @log1pf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @log1pl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @log1p(double) [[READNONE]]
-// HAS_ERRNO: declare float @log1pf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @log1pl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @log1p(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @log1pf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @log1pl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_log2(f);       __builtin_log2f(f);      __builtin_log2l(f);
 
 // NO__ERRNO: declare double @log2(double) [[READNONE]]
 // NO__ERRNO: declare float @log2f(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @log2l(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @log2(double) [[READNONE]]
-// HAS_ERRNO: declare float @log2f(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @log2l(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @log2(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @log2f(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @log2l(x86_fp80) [[NOT_READNONE]]
 
   __builtin_logb(f);       __builtin_logbf(f);      __builtin_logbl(f);
 
 // NO__ERRNO: declare double @logb(double) [[READNONE]]
 // NO__ERRNO: declare float @logbf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @logbl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @logb(double) [[READNONE]]
-// HAS_ERRNO: declare float @logbf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @logbl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @logb(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @logbf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @logbl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_lrint(f);      __builtin_lrintf(f);     __builtin_lrintl(f);
 
 // NO__ERRNO: declare i64 @lrint(double) [[READNONE]]
 // NO__ERRNO: declare i64 @lrintf(float) [[READNONE]]
 // NO__ERRNO: declare i64 @lrintl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare i64 @lrint(double) [[READNONE]]
-// HAS_ERRNO: declare i64 @lrintf(float) [[READNONE]]
-// HAS_ERRNO: declare i64 @lrintl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare i64 @lrint(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare i64 @lrintf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare i64 @lrintl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_lround(f);     __builtin_lroundf(f);    __builtin_lroundl(f);
 
 // NO__ERRNO: declare i64 @lround(double) [[READNONE]]
 // NO__ERRNO: declare i64 @lroundf(float) [[READNONE]]
 // NO__ERRNO: declare i64 @lroundl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare i64 @lround(double) [[READNONE]]
-// HAS_ERRNO: declare i64 @lroundf(float) [[READNONE]]
-// HAS_ERRNO: declare i64 @lroundl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare i64 @lround(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare i64 @lroundf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare i64 @lroundl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_nearbyint(f);  __builtin_nearbyintf(f); __builtin_nearbyintl(f);
 
 // NO__ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC]]
 
   __builtin_nextafter(f,f);  __builtin_nextafterf(f,f); __builtin_nextafterl(f,f);
 
 // NO__ERRNO: declare double @nextafter(double, double) [[READNONE]]
 // NO__ERRNO: declare float @nextafterf(float, float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @nextafterl(x86_fp80, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @nextafter(double, double) [[READNONE]]
-// HAS_ERRNO: declare float @nextafterf(float, float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @nextafterl(x86_fp80, x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @nextafter(double, double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @nextafterf(float, float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @nextafterl(x86_fp80, x86_fp80) [[NOT_READNONE]]
 
   __builtin_nexttoward(f,f); __builtin_nexttowardf(f,f);__builtin_nexttowardl(f,f);
 
 // NO__ERRNO: declare double @nexttoward(double, x86_fp80) [[READNONE]]
 // NO__ERRNO: declare float @nexttowardf(float, x86_fp80) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @nexttowardl(x86_fp80, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @nexttoward(double, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare float @nexttowardf(float, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @nexttowardl(x86_fp80, x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @nexttoward(double, x86_fp80) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @nexttowardf(float, x86_fp80) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @nexttowardl(x86_fp80, x86_fp80) [[NOT_READNONE]]
 
   __builtin_remainder(f,f);  __builtin_remainderf(f,f); __builtin_remainderl(f,f);
 
 // NO__ERRNO: declare double @remainder(double, double) [[READNONE]]
 // NO__ERRNO: declare float @remainderf(float, float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @remainderl(x86_fp80, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @remainder(double, double) [[READNONE]]
-// HAS_ERRNO: declare float @remainderf(float, float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @remainderl(x86_fp80, x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @remainder(double, double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @remainderf(float, float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @remainderl(x86_fp80, x86_fp80) [[NOT_READNONE]]
 
   __builtin_remquo(f,f,i);  __builtin_remquof(f,f,i); __builtin_remquol(f,f,i);
 
 // NO__ERRNO: declare double @remquo(double, double, i32*) [[NOT_READNONE]]
 // NO__ERRNO: declare float @remquof(float, float, i32*) [[NOT_READNONE]]
 // NO__ERRNO: declare x86_fp80 @remquol(x86_fp80, x86_fp80, i32*) [[NOT_READNONE]]
 // HAS_ERRNO: declare double @remquo(double, double, i32*) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @remquof(float, float, i32*) [[NOT_READNONE]]

 // HAS_ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC]]
 
   __builtin_scalbln(f,f);    __builtin_scalblnf(f,f);   __builtin_scalblnl(f,f);
 
 // NO__ERRNO: declare double @scalbln(double, i64) [[READNONE]]
 // NO__ERRNO: declare float @scalblnf(float, i64) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @scalblnl(x86_fp80, i64) [[READNONE]]
-// HAS_ERRNO: declare double @scalbln(double, i64) [[READNONE]]
-// HAS_ERRNO: declare float @scalblnf(float, i64) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @scalblnl(x86_fp80, i64) [[READNONE]]
+// HAS_ERRNO: declare double @scalbln(double, i64) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @scalblnf(float, i64) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @scalblnl(x86_fp80, i64) [[NOT_READNONE]]
 
   __builtin_scalbn(f,f);     __builtin_scalbnf(f,f);    __builtin_scalbnl(f,f);
 
 // NO__ERRNO: declare double @scalbn(double, i32) [[READNONE]]
 // NO__ERRNO: declare float @scalbnf(float, i32) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @scalbnl(x86_fp80, i32) [[READNONE]]
-// HAS_ERRNO: declare double @scalbn(double, i32) [[READNONE]]
-// HAS_ERRNO: declare float @scalbnf(float, i32) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @scalbnl(x86_fp80, i32) [[READNONE]]
+// HAS_ERRNO: declare double @scalbn(double, i32) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @scalbnf(float, i32) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @scalbnl(x86_fp80, i32) [[NOT_READNONE]]
 
   __builtin_sin(f);        __builtin_sinf(f);       __builtin_sinl(f);
 
 // NO__ERRNO: declare double @sin(double) [[READNONE]]
 // NO__ERRNO: declare float @sinf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @sinl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @sin(double) [[READNONE]]
-// HAS_ERRNO: declare float @sinf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @sinl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @sin(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @sinf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @sinl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_sinh(f);       __builtin_sinhf(f);      __builtin_sinhl(f);
 
 // NO__ERRNO: declare double @sinh(double) [[READNONE]]
 // NO__ERRNO: declare float @sinhf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @sinhl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @sinh(double) [[READNONE]]
-// HAS_ERRNO: declare float @sinhf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @sinhl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @sinh(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @sinhf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @sinhl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_sqrt(f);       __builtin_sqrtf(f);      __builtin_sqrtl(f); 
 
 // NO__ERRNO: declare double @sqrt(double) [[READNONE]]
 // NO__ERRNO: declare float @sqrtf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @sqrtl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @sqrt(double) [[READNONE]]
-// HAS_ERRNO: declare float @sqrtf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @sqrtl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @sqrt(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @sqrtf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @sqrtl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_tan(f);        __builtin_tanf(f);       __builtin_tanl(f);
 
 // NO__ERRNO: declare double @tan(double) [[READNONE]]
 // NO__ERRNO: declare float @tanf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @tanl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @tan(double) [[READNONE]]
-// HAS_ERRNO: declare float @tanf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @tanl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @tan(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @tanf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @tanl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_tanh(f);       __builtin_tanhf(f);      __builtin_tanhl(f);
 
 // NO__ERRNO: declare double @tanh(double) [[READNONE]]
 // NO__ERRNO: declare float @tanhf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @tanhl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @tanh(double) [[READNONE]]
-// HAS_ERRNO: declare float @tanhf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @tanhl(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @tanh(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @tanhf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @tanhl(x86_fp80) [[NOT_READNONE]]
 
   __builtin_tgamma(f);     __builtin_tgammaf(f);    __builtin_tgammal(f);
 
 // NO__ERRNO: declare double @tgamma(double) [[READNONE]]
 // NO__ERRNO: declare float @tgammaf(float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @tgammal(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @tgamma(double) [[READNONE]]
-// HAS_ERRNO: declare float @tgammaf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @tgammal(x86_fp80) [[READNONE]]
+// HAS_ERRNO: declare double @tgamma(double) [[NOT_READNONE]]
+// HAS_ERRNO: declare float @tgammaf(float) [[NOT_READNONE]]
+// HAS_ERRNO: declare x86_fp80 @tgammal(x86_fp80) [[NOT_READNONE]]
 
   __builtin_trunc(f);      __builtin_truncf(f);     __builtin_truncl(f);
 
 // NO__ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare x86_fp80 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC]]

 // HAS_ERRNO: declare { x86_fp80, x86_fp80 } @ctanhl({ x86_fp80, x86_fp80 }* byval align 16) [[NOT_READNONE]]
 };
 
 
 // NO__ERRNO: attributes [[READNONE]] = { {{.*}}readnone{{.*}} }
 // NO__ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}readnone{{.*}} }
 // NO__ERRNO: attributes [[NOT_READNONE]] = { nounwind "correctly{{.*}} }
 
-// HAS_ERRNO: attributes [[READNONE]] = { {{.*}}readnone{{.*}} }
-// HAS_ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}readnone{{.*}} }
 // HAS_ERRNO: attributes [[NOT_READNONE]] = { nounwind "correctly{{.*}} }
+// HAS_ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}readnone{{.*}} }
+// HAS_ERRNO: attributes [[READNONE]] = { {{.*}}readnone{{.*}} }
 

cfe/trunk/test/CodeGen/builtin-sqrt.c

 // RUN: %clang_cc1 -fmath-errno -triple x86_64-apple-darwin %s -emit-llvm -o - | FileCheck %s --check-prefix=HAS_ERRNO
 // RUN: %clang_cc1              -triple x86_64-apple-darwin %s -emit-llvm -o - | FileCheck %s --check-prefix=NO_ERRNO
 
-// FIXME: If a builtin is supposed to have identical semantics to its libm twin, then it
-// should not be marked "constant" in Builtins.def because that means it can't set errno.
-// Note that both runs have 'readnone' on the libcall here.
+// FIXME: If the builtin does not set errno, it should be converted to an LLVM intrinsic.
 
 float foo(float X) {
   // HAS_ERRNO: call float @sqrtf(float
   // NO_ERRNO: call float @sqrtf(float
   return __builtin_sqrtf(X);
 }
 
 // HAS_ERRNO: declare float @sqrtf(float) [[ATTR:#[0-9]+]]
-// HAS_ERRNO: attributes [[ATTR]] = { nounwind readnone {{.*}}}
+// HAS_ERRNO-NOT: attributes [[ATTR]] = {{{.*}} readnone
 
 // NO_ERRNO: declare float @sqrtf(float) [[ATTR:#[0-9]+]]
 // NO_ERRNO: attributes [[ATTR]] = { nounwind readnone {{.*}}}