[CodeGen] convert math libcalls/builtins to equivalent LLVM intrinsics

[spatel]

Summary

There are 20 LLVM math intrinsics that correspond to mathlib calls according to the LangRef:
http://llvm.org/docs/LangRef.html#standard-c-library-intrinsics

We were only converting 3 mathlib calls (sqrt, fma, pow) and 12 builtin calls (ceil, copysign, fabs, floor, fma, fmax, fmin, nearbyint, pow, rint, round, trunc) to their intrinsic-equivalents.

This patch pulls the transforms together and handles all 20 cases. The switch is guarded by a check for const-ness to make sure we're not doing the transform if errno could possibly be set by the libcall or builtin.

[spatel]

Ping.

[spatel]

Ping * 2.

[efriedma]

LGTM.

lib/CodeGen/CGBuiltin.cpp

if (E->EvaluateAsRValue(Result, CGM.getContext()) &&
     if (Result.Val.isInt())
       return RValue::get(llvm::ConstantInt::get(getLLVMContext(),
                                                 Result.Val.getInt()));
     if (Result.Val.isFloat())
       return RValue::get(llvm::ConstantFP::get(getLLVMContext(),
                                                Result.Val.getFloat()));
   }
 
+  // Math builtins have the same semantics as their math library twins.
+  // There are LLVM math intrinsics corresponding to math library functions
+  // except the intrinsic will never set errno while the math library might.
+  // Thus, we can transform math library and builtin calls to their
+  // semantically-equivalent LLVM intrinsic counterparts if the call is marked
+  // 'const' (it is known to never set errno).
+  if (FD->hasAttr<ConstAttr>()) {
+    switch (BuiltinID) {
+    case Builtin::BIceil:
+    case Builtin::BIceilf:
+    case Builtin::BIceill:
+    case Builtin::BI__builtin_ceil:
+    case Builtin::BI__builtin_ceilf:
+    case Builtin::BI__builtin_ceill:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::ceil));
+
+    case Builtin::BIcopysign:
+    case Builtin::BIcopysignf:
+    case Builtin::BIcopysignl:
+    case Builtin::BI__builtin_copysign:
+    case Builtin::BI__builtin_copysignf:
+    case Builtin::BI__builtin_copysignl:
+      return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::copysign));
+
+    case Builtin::BIcos:
+    case Builtin::BIcosf:
+    case Builtin::BIcosl:
+    case Builtin::BI__builtin_cos:
+    case Builtin::BI__builtin_cosf:
+    case Builtin::BI__builtin_cosl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::cos));
+
+    case Builtin::BIexp:
+    case Builtin::BIexpf:
+    case Builtin::BIexpl:
+    case Builtin::BI__builtin_exp:
+    case Builtin::BI__builtin_expf:
+    case Builtin::BI__builtin_expl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::exp));
+
+    case Builtin::BIexp2:
+    case Builtin::BIexp2f:
+    case Builtin::BIexp2l:
+    case Builtin::BI__builtin_exp2:
+    case Builtin::BI__builtin_exp2f:
+    case Builtin::BI__builtin_exp2l:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::exp2));
+
+    case Builtin::BIfabs:
+    case Builtin::BIfabsf:
+    case Builtin::BIfabsl:
+    case Builtin::BI__builtin_fabs:
+    case Builtin::BI__builtin_fabsf:
+    case Builtin::BI__builtin_fabsl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::fabs));
+
+    case Builtin::BIfloor:
+    case Builtin::BIfloorf:
+    case Builtin::BIfloorl:
+    case Builtin::BI__builtin_floor:
+    case Builtin::BI__builtin_floorf:
+    case Builtin::BI__builtin_floorl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::floor));
+
+    case Builtin::BIfma:
+    case Builtin::BIfmaf:
+    case Builtin::BIfmal:
+    case Builtin::BI__builtin_fma:
+    case Builtin::BI__builtin_fmaf:
+    case Builtin::BI__builtin_fmal:
+      return RValue::get(emitTernaryBuiltin(*this, E, Intrinsic::fma));
+
+    case Builtin::BIfmax:
+    case Builtin::BIfmaxf:
+    case Builtin::BIfmaxl:
+    case Builtin::BI__builtin_fmax:
+    case Builtin::BI__builtin_fmaxf:
+    case Builtin::BI__builtin_fmaxl:
+      return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::maxnum));
+
+    case Builtin::BIfmin:
+    case Builtin::BIfminf:
+    case Builtin::BIfminl:
+    case Builtin::BI__builtin_fmin:
+    case Builtin::BI__builtin_fminf:
+    case Builtin::BI__builtin_fminl:
+      return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::minnum));
+
+    case Builtin::BIlog:
+    case Builtin::BIlogf:
+    case Builtin::BIlogl:
+    case Builtin::BI__builtin_log:
+    case Builtin::BI__builtin_logf:
+    case Builtin::BI__builtin_logl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log));
+
+    case Builtin::BIlog10:
+    case Builtin::BIlog10f:
+    case Builtin::BIlog10l:
+    case Builtin::BI__builtin_log10:
+    case Builtin::BI__builtin_log10f:
+    case Builtin::BI__builtin_log10l:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log10));
+
+    case Builtin::BIlog2:
+    case Builtin::BIlog2f:
+    case Builtin::BIlog2l:
+    case Builtin::BI__builtin_log2:
+    case Builtin::BI__builtin_log2f:
+    case Builtin::BI__builtin_log2l:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log2));
+
+    case Builtin::BInearbyint:
+    case Builtin::BInearbyintf:
+    case Builtin::BInearbyintl:
+    case Builtin::BI__builtin_nearbyint:
+    case Builtin::BI__builtin_nearbyintf:
+    case Builtin::BI__builtin_nearbyintl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::nearbyint));
+
+    case Builtin::BIpow:
+    case Builtin::BIpowf:
+    case Builtin::BIpowl:
+    case Builtin::BI__builtin_pow:
+    case Builtin::BI__builtin_powf:
+    case Builtin::BI__builtin_powl:
+      return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::pow));
+
+    case Builtin::BIrint:
+    case Builtin::BIrintf:
+    case Builtin::BIrintl:
+    case Builtin::BI__builtin_rint:
+    case Builtin::BI__builtin_rintf:
+    case Builtin::BI__builtin_rintl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::rint));
+
+    case Builtin::BIround:
+    case Builtin::BIroundf:
+    case Builtin::BIroundl:
+    case Builtin::BI__builtin_round:
+    case Builtin::BI__builtin_roundf:
+    case Builtin::BI__builtin_roundl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::round));
+
+    case Builtin::BIsin:
+    case Builtin::BIsinf:
+    case Builtin::BIsinl:
+    case Builtin::BI__builtin_sin:
+    case Builtin::BI__builtin_sinf:
+    case Builtin::BI__builtin_sinl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::sin));
+
+    case Builtin::BIsqrt:
+    case Builtin::BIsqrtf:
+    case Builtin::BIsqrtl:
+    case Builtin::BI__builtin_sqrt:
+    case Builtin::BI__builtin_sqrtf:
+    case Builtin::BI__builtin_sqrtl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::sqrt));
+
+    case Builtin::BItrunc:
+    case Builtin::BItruncf:
+    case Builtin::BItruncl:
+    case Builtin::BI__builtin_trunc:
+    case Builtin::BI__builtin_truncf:
+    case Builtin::BI__builtin_truncl:
+      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::trunc));
+
+    default:
+      break;
+    }
+  }
+
   switch (BuiltinID) {
   default: break;  // Handle intrinsics and libm functions below.
   case Builtin::BI__builtin___CFStringMakeConstantString:
   case Builtin::BI__builtin___NSStringMakeConstantString:
     return RValue::get(ConstantEmitter(*this).emitAbstract(E, E->getType()));
   case Builtin::BI__builtin_stdarg_start:
   case Builtin::BI__builtin_va_start:
   case Builtin::BI__va_start:
case Builtin::BI__builtin_llabs: {
     Builder.CreateICmpSGE(ArgValue,
                           llvm::Constant::getNullValue(ArgValue->getType()),
                                                             "abscond");
     Value *Result =
       Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
 
     return RValue::get(Result);
   }
-  case Builtin::BI__builtin_fabs:
-  case Builtin::BI__builtin_fabsf:
-  case Builtin::BI__builtin_fabsl: {
-    return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::fabs));
-  }
   case Builtin::BI__builtin_fmod:
   case Builtin::BI__builtin_fmodf:
   case Builtin::BI__builtin_fmodl: {
     Value *Arg1 = EmitScalarExpr(E->getArg(0));
     Value *Arg2 = EmitScalarExpr(E->getArg(1));
     Value *Result = Builder.CreateFRem(Arg1, Arg2, "fmod");
     return RValue::get(Result);
   }
-  case Builtin::BI__builtin_copysign:
-  case Builtin::BI__builtin_copysignf:
-  case Builtin::BI__builtin_copysignl: {
-    return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::copysign));
-  }
-  case Builtin::BI__builtin_ceil:
-  case Builtin::BI__builtin_ceilf:
-  case Builtin::BI__builtin_ceill: {
-    return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::ceil));
-  }
-  case Builtin::BI__builtin_floor:
-  case Builtin::BI__builtin_floorf:
-  case Builtin::BI__builtin_floorl: {
-    return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::floor));
-  }
-  case Builtin::BI__builtin_trunc:
-  case Builtin::BI__builtin_truncf:
-  case Builtin::BI__builtin_truncl: {
-    return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::trunc));
-  }
-  case Builtin::BI__builtin_rint:
-  case Builtin::BI__builtin_rintf:
-  case Builtin::BI__builtin_rintl: {
-    return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::rint));
-  }
-  case Builtin::BI__builtin_nearbyint:
-  case Builtin::BI__builtin_nearbyintf:
-  case Builtin::BI__builtin_nearbyintl: {
-    return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::nearbyint));
-  }
-  case Builtin::BI__builtin_round:
-  case Builtin::BI__builtin_roundf:
-  case Builtin::BI__builtin_roundl: {
-    return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::round));
-  }
-  case Builtin::BI__builtin_fmin:
-  case Builtin::BI__builtin_fminf:
-  case Builtin::BI__builtin_fminl: {
-    return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::minnum));
-  }
-  case Builtin::BI__builtin_fmax:
-  case Builtin::BI__builtin_fmaxf:
-  case Builtin::BI__builtin_fmaxl: {
-    return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::maxnum));
-  }
   case Builtin::BI__builtin_conj:
   case Builtin::BI__builtin_conjf:
   case Builtin::BI__builtin_conjl: {
     ComplexPairTy ComplexVal = EmitComplexExpr(E->getArg(0));
     Value *Real = ComplexVal.first;
     Value *Imag = ComplexVal.second;
     Value *Zero =
       Imag->getType()->isFPOrFPVectorTy()
case Builtin::BI__c11_atomic_signal_fence: {
     Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent, SSID);
     Builder.CreateBr(ContBB);
     SI->addCase(Builder.getInt32(5), SeqCstBB);
 
     Builder.SetInsertPoint(ContBB);
     return RValue::get(nullptr);
   }
 
-  case Builtin::BIsqrt:
-  case Builtin::BIsqrtf:
-  case Builtin::BIsqrtl:
-    // Builtins have the same semantics as library functions. The LLVM intrinsic
-    // has the same semantics as the library function except it does not set
-    // errno. Thus, we can transform either sqrt or __builtin_sqrt to @llvm.sqrt
-    // if the call is 'const' (the call must not set errno).
-    //
-    // FIXME: The builtin cases are not here because they are marked 'const' in
-    // Builtins.def. So that means they are wrongly defined to have different
-    // semantics than the library functions. If we included them here, we would
-    // turn them into LLVM intrinsics regardless of whether -fmath-errno was on.
-    if (FD->hasAttr<ConstAttr>())
-      return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::sqrt));
-    break;
-
-  case Builtin::BI__builtin_pow:
-  case Builtin::BI__builtin_powf:
-  case Builtin::BI__builtin_powl:
-  case Builtin::BIpow:
-  case Builtin::BIpowf:
-  case Builtin::BIpowl: {
-    // Transform a call to pow* into a @llvm.pow.* intrinsic call.
-    if (!FD->hasAttr<ConstAttr>())
-      break;
-    Value *Base = EmitScalarExpr(E->getArg(0));
-    Value *Exponent = EmitScalarExpr(E->getArg(1));
-    llvm::Type *ArgType = Base->getType();
-    Value *F = CGM.getIntrinsic(Intrinsic::pow, ArgType);
-    return RValue::get(Builder.CreateCall(F, {Base, Exponent}));
-  }
-
-  case Builtin::BIfma:
-  case Builtin::BIfmaf:
-  case Builtin::BIfmal:
-  case Builtin::BI__builtin_fma:
-  case Builtin::BI__builtin_fmaf:
-  case Builtin::BI__builtin_fmal:
-    // A constant libcall or builtin is equivalent to the LLVM intrinsic.
-    if (FD->hasAttr<ConstAttr>())
-      return RValue::get(emitTernaryBuiltin(*this, E, Intrinsic::fma));
-    break;
-
   case Builtin::BI__builtin_signbit:
   case Builtin::BI__builtin_signbitf:
   case Builtin::BI__builtin_signbitl: {
     return RValue::get(
         Builder.CreateZExt(EmitSignBit(*this, EmitScalarExpr(E->getArg(0))),
                            ConvertType(E->getType())));
   }
   case Builtin::BI__annotation: {

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 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
+  // NO_ERRNO: call float @llvm.sqrt.f32(float
   return __builtin_sqrtf(X);
 }
 
 // HAS_ERRNO: declare float @sqrtf(float) [[ATTR:#[0-9]+]]
 // HAS_ERRNO-NOT: attributes [[ATTR]] = {{{.*}} readnone
 
-// NO_ERRNO: declare float @sqrtf(float) [[ATTR:#[0-9]+]]
+// NO_ERRNO: declare float @llvm.sqrt.f32(float) [[ATTR:#[0-9]+]]
 // NO_ERRNO: attributes [[ATTR]] = { nounwind readnone {{.*}}}
 

test/CodeGen/builtins.c

void test_float_builtin_ops(float F, double D, long double LD) {
 
   resd = __builtin_floor(D);
   // CHECK: call double @llvm.floor.f64
 
   resld = __builtin_floorl(LD);
   // CHECK: call x86_fp80 @llvm.floor.f80
 
   resf = __builtin_sqrtf(F);
-  // CHECK: call float @sqrtf(
+  // CHECK: call float @llvm.sqrt.f32(
 
   resd = __builtin_sqrt(D);
-  // CHECK: call double @sqrt(
+  // CHECK: call double @llvm.sqrt.f64(
 
   resld = __builtin_sqrtl(LD);
-  // CHECK: call x86_fp80 @sqrtl(
+  // CHECK: call x86_fp80 @llvm.sqrt.f80
 
   resf = __builtin_truncf(F);
   // CHECK: call float @llvm.trunc.f32
 
   resd = __builtin_trunc(D);
   // CHECK: call double @llvm.trunc.f64
 
   resld = __builtin_truncl(LD);

test/CodeGen/libcalls.c

 // CHECK-NO: declare float @atan2f(float, float) [[NUW_RN]]
 // CHECK-YES-NOT: declare double @atan2(double, double) [[NUW_RN]]
 // CHECK-YES-NOT: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[NUW_RN]]
 // CHECK-YES-NOT: declare float @atan2f(float, float) [[NUW_RN]]
 
   double exp_ = exp(d);
   long double expl_ = expl(ld);
   float expf_ = expf(f);
-// CHECK-NO: declare double @exp(double) [[NUW_RN]]
-// CHECK-NO: declare x86_fp80 @expl(x86_fp80) [[NUW_RN]]
-// CHECK-NO: declare float @expf(float) [[NUW_RN]]
+// CHECK-NO: declare double @llvm.exp.f64(double) [[NUW_RNI]]
+// CHECK-NO: declare x86_fp80 @llvm.exp.f80(x86_fp80) [[NUW_RNI]]
+// CHECK-NO: declare float @llvm.exp.f32(float) [[NUW_RNI]]
 // CHECK-YES-NOT: declare double @exp(double) [[NUW_RN]]
 // CHECK-YES-NOT: declare x86_fp80 @expl(x86_fp80) [[NUW_RN]]
 // CHECK-YES-NOT: declare float @expf(float) [[NUW_RN]]
 
   double log_ = log(d);
   long double logl_ = logl(ld);
   float logf_ = logf(f);
-// CHECK-NO: declare double @log(double) [[NUW_RN]]
-// CHECK-NO: declare x86_fp80 @logl(x86_fp80) [[NUW_RN]]
-// CHECK-NO: declare float @logf(float) [[NUW_RN]]
+// CHECK-NO: declare double @llvm.log.f64(double) [[NUW_RNI]]
+// CHECK-NO: declare x86_fp80 @llvm.log.f80(x86_fp80) [[NUW_RNI]]
+// CHECK-NO: declare float @llvm.log.f32(float) [[NUW_RNI]]
 // CHECK-YES-NOT: declare double @log(double) [[NUW_RN]]
 // CHECK-YES-NOT: declare x86_fp80 @logl(x86_fp80) [[NUW_RN]]
 // CHECK-YES-NOT: declare float @logf(float) [[NUW_RN]]
 }
 
 // CHECK-NO-DAG: attributes [[NUW_RN]] = { nounwind readnone{{.*}} }
 // CHECK-NO-DAG: attributes [[NUW_RNI]] = { nounwind readnone speculatable }

test/CodeGen/math-builtins.c

 // 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]]
+// NO__ERRNO: declare double @llvm.cos.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.cos.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.cos.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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 float @erfcf(float) [[READNONE]]
 // NO__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]]
+// NO__ERRNO: declare double @llvm.exp.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.exp.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.exp.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]
+// NO__ERRNO: declare double @llvm.exp2.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.exp2.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.exp2.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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 i64 @llroundf(float) [[READNONE]]
 // NO__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]]
+// NO__ERRNO: declare double @llvm.log.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.log.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.log.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]
+// NO__ERRNO: declare double @llvm.log10.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.log10.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.log10.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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) [[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]]
+// NO__ERRNO: declare double @llvm.log2.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.log2.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.log2.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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 float @scalbnf(float, i32) [[READNONE]]
 // NO__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]]
+// NO__ERRNO: declare double @llvm.sin.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.sin.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.sin.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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) [[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]]
+// NO__ERRNO: declare double @llvm.sqrt.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.sqrt.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.sqrt.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]

test/CodeGen/math-libcalls.c

 // 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) [[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]]
 
   copysign(f,f); copysignf(f,f);copysignl(f,f);
 
-// NO__ERRNO: declare double @copysign(double, double) [[READNONE]]
-// NO__ERRNO: declare float @copysignf(float, float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @copysignl(x86_fp80, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @copysign(double, double) [[READNONE:#[0-9]+]]
-// HAS_ERRNO: declare float @copysignf(float, float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @copysignl(x86_fp80, x86_fp80) [[READNONE]]
+// 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: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
 
   fabs(f);       fabsf(f);      fabsl(f);
 
-// NO__ERRNO: declare double @fabs(double) [[READNONE]]
-// NO__ERRNO: declare float @fabsf(float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @fabsl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @fabs(double) [[READNONE]]
-// HAS_ERRNO: declare float @fabsf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @fabsl(x86_fp80) [[READNONE]]
+// NO__ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC]]
 
   fmod(f,f);     fmodf(f,f);    fmodl(f,f);
 
 // NO__ERRNO: declare double @fmod(double, double) [[READNONE]]
 // NO__ERRNO: declare float @fmodf(float, float) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @fmodl(x86_fp80, x86_fp80) [[READNONE]]
 // HAS_ERRNO: declare double @fmod(double, double) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @fmodf(float, float) [[NOT_READNONE]]

 // NO__ERRNO: declare float @nanf(i8*) [[READONLY]]
 // NO__ERRNO: declare x86_fp80 @nanl(i8*) [[READONLY]]
 // HAS_ERRNO: declare double @nan(i8*) [[READONLY:#[0-9]+]]
 // HAS_ERRNO: declare float @nanf(i8*) [[READONLY]]
 // HAS_ERRNO: declare x86_fp80 @nanl(i8*) [[READONLY]]
 
   pow(f,f);        powf(f,f);       powl(f,f);
 
-// NO__ERRNO: declare double @llvm.pow.f64(double, double) [[READNONE_INTRINSIC:#[0-9]+]]
+// 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 @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]]
 
   /* math */
   acos(f);       acosf(f);      acosl(f);

 // HAS_ERRNO: declare float @atanhf(float) [[NOT_READNONE]]
 // HAS_ERRNO: declare x86_fp80 @atanhl(x86_fp80) [[NOT_READNONE]]
 
   cbrt(f);       cbrtf(f);      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 double @cbrt(double) [[READNONE:#[0-9]+]]
 // HAS_ERRNO: declare float @cbrtf(float) [[READNONE]]
 // HAS_ERRNO: declare x86_fp80 @cbrtl(x86_fp80) [[READNONE]]
 
   ceil(f);       ceilf(f);      ceill(f);
 
-// NO__ERRNO: declare double @ceil(double) [[READNONE]]
-// NO__ERRNO: declare float @ceilf(float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @ceill(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @ceil(double) [[READNONE]]
-// HAS_ERRNO: declare float @ceilf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @ceill(x86_fp80) [[READNONE]]
+// 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]]
 
   cos(f);        cosf(f);       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]]
+// NO__ERRNO: declare double @llvm.cos.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.cos.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.cos.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]
 
   cosh(f);       coshf(f);      coshl(f);
 
 // NO__ERRNO: declare double @cosh(double) [[READNONE]]
 // NO__ERRNO: declare float @coshf(float) [[READNONE]]

 // NO__ERRNO: declare float @erfcf(float) [[READNONE]]
 // NO__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]]
 
   exp(f);        expf(f);       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]]
+// NO__ERRNO: declare double @llvm.exp.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.exp.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.exp.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]
 
   exp2(f);       exp2f(f);      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]]
+// NO__ERRNO: declare double @llvm.exp2.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.exp2.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.exp2.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]
 
   expm1(f);      expm1f(f);     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) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @expm1f(float) [[NOT_READNONE]]
 // HAS_ERRNO: declare x86_fp80 @expm1l(x86_fp80) [[NOT_READNONE]]
 
   fdim(f,f);       fdimf(f,f);      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) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @fdimf(float, float) [[NOT_READNONE]]
 // HAS_ERRNO: declare x86_fp80 @fdiml(x86_fp80, x86_fp80) [[NOT_READNONE]]
 
   floor(f);      floorf(f);     floorl(f);
 
-// NO__ERRNO: declare double @floor(double) [[READNONE]]
-// NO__ERRNO: declare float @floorf(float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @floorl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @floor(double) [[READNONE]]
-// HAS_ERRNO: declare float @floorf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @floorl(x86_fp80) [[READNONE]]
+// 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 x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC]]
 
   fma(f,f,f);        fmaf(f,f,f);       fmal(f,f,f);
 
 // NO__ERRNO: declare double @llvm.fma.f64(double, double, double) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare float @llvm.fma.f32(float, float, float) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare double @fma(double, double, double) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @fmaf(float, float, float) [[NOT_READNONE]]
 // HAS_ERRNO: declare x86_fp80 @fmal(x86_fp80, x86_fp80, x86_fp80) [[NOT_READNONE]]
 
 // On GNU or Win, fma never sets errno, so we can convert to the intrinsic.
 
 // HAS_ERRNO_GNU: declare double @llvm.fma.f64(double, double, double) [[READNONE_INTRINSIC:#[0-9]+]]
 // HAS_ERRNO_GNU: declare float @llvm.fma.f32(float, float, float) [[READNONE_INTRINSIC]]
 // HAS_ERRNO_GNU: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
 
 // HAS_ERRNO_WIN: declare double @llvm.fma.f64(double, double, double) [[READNONE_INTRINSIC:#[0-9]+]]
 // HAS_ERRNO_WIN: declare float @llvm.fma.f32(float, float, float) [[READNONE_INTRINSIC]]
 // Long double is just double on win, so no f80 use/declaration.
 // HAS_ERRNO_WIN-NOT: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80)
 
   fmax(f,f);       fmaxf(f,f);      fmaxl(f,f);
 
-// NO__ERRNO: declare double @fmax(double, double) [[READNONE]]
-// NO__ERRNO: declare float @fmaxf(float, float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @fmaxl(x86_fp80, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @fmax(double, double) [[READNONE]]
-// HAS_ERRNO: declare float @fmaxf(float, float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @fmaxl(x86_fp80, x86_fp80) [[READNONE]]
+// NO__ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
 
   fmin(f,f);       fminf(f,f);      fminl(f,f);
 
-// NO__ERRNO: declare double @fmin(double, double) [[READNONE]]
-// NO__ERRNO: declare float @fminf(float, float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @fminl(x86_fp80, x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @fmin(double, double) [[READNONE]]
-// HAS_ERRNO: declare float @fminf(float, float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @fminl(x86_fp80, x86_fp80) [[READNONE]]
+// NO__ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare double @llvm.minnum.f64(double, double) [[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]]
 
   hypot(f,f);      hypotf(f,f);     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) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @hypotf(float, float) [[NOT_READNONE]]

 // NO__ERRNO: declare i64 @llroundf(float) [[READNONE]]
 // NO__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]]
 
   log(f);        logf(f);       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]]
+// NO__ERRNO: declare double @llvm.log.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.log.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.log.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]
 
   log10(f);      log10f(f);     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]]
+// NO__ERRNO: declare double @llvm.log10.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.log10.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.log10.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]
 
   log1p(f);      log1pf(f);     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) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @log1pf(float) [[NOT_READNONE]]
 // HAS_ERRNO: declare x86_fp80 @log1pl(x86_fp80) [[NOT_READNONE]]
 
   log2(f);       log2f(f);      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]]
+// NO__ERRNO: declare double @llvm.log2.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.log2.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.log2.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]
 
   logb(f);       logbf(f);      logbl(f);
 
 // NO__ERRNO: declare double @logb(double) [[READNONE]]
 // NO__ERRNO: declare float @logbf(float) [[READNONE]]

 // NO__ERRNO: declare i64 @lroundf(float) [[READNONE]]
 // NO__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]]
 
   nearbyint(f);  nearbyintf(f); nearbyintl(f);
 
-// NO__ERRNO: declare double @nearbyint(double) [[READNONE]]
-// NO__ERRNO: declare float @nearbyintf(float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @nearbyintl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @nearbyint(double) [[READNONE]]
-// HAS_ERRNO: declare float @nearbyintf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @nearbyintl(x86_fp80) [[READNONE]]
+// 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]]
 
   nextafter(f,f);  nextafterf(f,f); 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) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @nextafterf(float, float) [[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 x86_fp80 @remquol(x86_fp80, x86_fp80, i32*) [[NOT_READNONE]]
 
   rint(f);       rintf(f);      rintl(f);
 
-// NO__ERRNO: declare double @rint(double) [[READNONE]]
-// NO__ERRNO: declare float @rintf(float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @rintl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @rint(double) [[READNONE]]
-// HAS_ERRNO: declare float @rintf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @rintl(x86_fp80) [[READNONE]]
+// NO__ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC]]
 
   round(f);      roundf(f);     roundl(f);
 
-// NO__ERRNO: declare double @round(double) [[READNONE]]
-// NO__ERRNO: declare float @roundf(float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @roundl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @round(double) [[READNONE]]
-// HAS_ERRNO: declare float @roundf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @roundl(x86_fp80) [[READNONE]]
+// NO__ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC]]
 
   scalbln(f,f);    scalblnf(f,f);   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) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @scalblnf(float, i64) [[NOT_READNONE]]
 // HAS_ERRNO: declare x86_fp80 @scalblnl(x86_fp80, i64) [[NOT_READNONE]]
 
   scalbn(f,f);     scalbnf(f,f);    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) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @scalbnf(float, i32) [[NOT_READNONE]]
 // HAS_ERRNO: declare x86_fp80 @scalbnl(x86_fp80, i32) [[NOT_READNONE]]
 
   sin(f);        sinf(f);       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]]
+// NO__ERRNO: declare double @llvm.sin.f64(double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.sin.f32(float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.sin.f80(x86_fp80) [[READNONE_INTRINSIC]]
 // 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]]
 
   sinh(f);       sinhf(f);      sinhl(f);
 
 // NO__ERRNO: declare double @sinh(double) [[READNONE]]
 // NO__ERRNO: declare float @sinhf(float) [[READNONE]]

 // NO__ERRNO: declare float @tgammaf(float) [[READNONE]]
 // NO__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]]
 
   trunc(f);      truncf(f);     truncl(f);
 
-// NO__ERRNO: declare double @trunc(double) [[READNONE]]
-// NO__ERRNO: declare float @truncf(float) [[READNONE]]
-// NO__ERRNO: declare x86_fp80 @truncl(x86_fp80) [[READNONE]]
-// HAS_ERRNO: declare double @trunc(double) [[READNONE]]
-// HAS_ERRNO: declare float @truncf(float) [[READNONE]]
-// HAS_ERRNO: declare x86_fp80 @truncl(x86_fp80) [[READNONE]]
+// 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 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC]]
 };
 
 
 // NO__ERRNO: attributes [[READNONE]] = { {{.*}}readnone{{.*}} }
+// NO__ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}readnone{{.*}} }
 // NO__ERRNO: attributes [[NOT_READNONE]] = { nounwind "correctly{{.*}} }
 // NO__ERRNO: attributes [[READONLY]] = { {{.*}}readonly{{.*}} }
-// NO__ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}readnone{{.*}} }
 
 // HAS_ERRNO: attributes [[NOT_READNONE]] = { nounwind "correctly{{.*}} }
-// HAS_ERRNO: attributes [[READNONE]] = { {{.*}}readnone{{.*}} }
+// HAS_ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}readnone{{.*}} }
 // HAS_ERRNO: attributes [[READONLY]] = { {{.*}}readonly{{.*}} }
+// HAS_ERRNO: attributes [[READNONE]] = { {{.*}}readnone{{.*}} }
 
 // HAS_ERRNO_GNU: attributes [[READNONE_INTRINSIC]] = { {{.*}}readnone{{.*}} }
 // HAS_ERRNO_WIN: attributes [[READNONE_INTRINSIC]] = { {{.*}}readnone{{.*}} }