AMDGPU: Replace fabs and copysign libcalls with intrinsics

[arsenm]

Summary

Preserves flags and metadata like the other cases.

[rampitec]

Why does it need strict-fp? Isn't it defined as just a bit operation?

[arsenm]

In D157875#4585822, @rampitec wrote:

Why does it need strict-fp? Isn't it defined as just a bit operation?

It doesn't, that's why it's allowed here unlike the other cases

[rampitec]

In D157875#4585827, @arsenm wrote:

In D157875#4585822, @rampitec wrote:

Why does it need strict-fp? Isn't it defined as just a bit operation?

It doesn't, that's why it's allowed here unlike the other cases

Ough, I see. LGTM.

[arsenm]

c7876c55acc14983a50bf2865ed87e7bb4bd4209

llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp

private:
 
   // Get a scalar native builtin single argument FP function
   FunctionCallee getNativeFunction(Module *M, const FuncInfo &FInfo);
 
   /// Substitute a call to a known libcall with an intrinsic call. If \p
   /// AllowMinSize is true, allow the replacement in a minsize function.
   bool shouldReplaceLibcallWithIntrinsic(const CallInst *CI,
                                          bool AllowMinSizeF32 = false,
-                                         bool AllowF64 = false);
+                                         bool AllowF64 = false,
+                                         bool AllowStrictFP = false);
   void replaceLibCallWithSimpleIntrinsic(CallInst *CI, Intrinsic::ID IntrID);
 
   bool tryReplaceLibcallWithSimpleIntrinsic(CallInst *CI, Intrinsic::ID IntrID,
                                             bool AllowMinSizeF32 = false,
-                                            bool AllowF64 = false);
+                                            bool AllowF64 = false,
+                                            bool AllowStrictFP = false);
 
 protected:
   bool isUnsafeMath(const FPMathOperator *FPOp) const;
 
   bool canIncreasePrecisionOfConstantFold(const FPMathOperator *FPOp) const;
 
   static void replaceCall(Instruction *I, Value *With) {
     I->replaceAllUsesWith(With);
if (canIncreasePrecisionOfConstantFold(FPOp) && evaluateCall(CI, FInfo))
       return true;
 
     // Copy fast flags from the original call.
     FastMathFlags FMF = FPOp->getFastMathFlags();
     B.setFastMathFlags(FMF);
 
     // Specialized optimizations for each function call.
     //
-    // TODO: Handle other simple intrinsic wrappers. Sqrt, copysign, fabs,
-    // ldexp, rounding intrinsics.
+    // TODO: Handle other simple intrinsic wrappers. Sqrt, ldexp, rounding
+    // intrinsics.
     //
     // TODO: Handle native functions
     switch (FInfo.getId()) {
     case AMDGPULibFunc::EI_EXP:
       if (FMF.none())
         return false;
       return tryReplaceLibcallWithSimpleIntrinsic(CI, Intrinsic::exp,
                                                   FMF.approxFunc());
case AMDGPULibFunc::EI_FMAX:
       return tryReplaceLibcallWithSimpleIntrinsic(CI, Intrinsic::maxnum, true,
                                                   true);
     case AMDGPULibFunc::EI_FMA:
       return tryReplaceLibcallWithSimpleIntrinsic(CI, Intrinsic::fma, true,
                                                   true);
     case AMDGPULibFunc::EI_MAD:
       return tryReplaceLibcallWithSimpleIntrinsic(CI, Intrinsic::fmuladd, true,
                                                   true);
+    case AMDGPULibFunc::EI_FABS:
+      return tryReplaceLibcallWithSimpleIntrinsic(CI, Intrinsic::fabs, true,
+                                                  true, true);
+    case AMDGPULibFunc::EI_COPYSIGN:
+      return tryReplaceLibcallWithSimpleIntrinsic(CI, Intrinsic::copysign, true,
+                                                  true, true);
     case AMDGPULibFunc::EI_POW:
     case AMDGPULibFunc::EI_POWR:
     case AMDGPULibFunc::EI_POWN:
       return fold_pow(FPOp, B, FInfo);
     case AMDGPULibFunc::EI_ROOTN:
       return fold_rootn(FPOp, B, FInfo);
     case AMDGPULibFunc::EI_SQRT:
       return fold_sqrt(FPOp, B, FInfo);
FunctionCallee AMDGPULibCalls::getNativeFunction(Module *M,
   return getFunction(M, nf);
 }
 
 // Some library calls are just wrappers around llvm intrinsics, but compiled
 // conservatively. Preserve the flags from the original call site by
 // substituting them with direct calls with all the flags.
 bool AMDGPULibCalls::shouldReplaceLibcallWithIntrinsic(const CallInst *CI,
                                                        bool AllowMinSizeF32,
-                                                       bool AllowF64) {
+                                                       bool AllowF64,
+                                                       bool AllowStrictFP) {
   Type *FltTy = CI->getType()->getScalarType();
   const bool IsF32 = FltTy->isFloatTy();
 
   // f64 intrinsics aren't implemented for most operations.
   if (!IsF32 && !FltTy->isHalfTy() && (!AllowF64 || !FltTy->isDoubleTy()))
     return false;
 
   // We're implicitly inlining by replacing the libcall with the intrinsic, so
   // don't do it for noinline call sites.
   if (CI->isNoInline())
     return false;
 
   const Function *ParentF = CI->getFunction();
   // TODO: Handle strictfp
-  if (ParentF->hasFnAttribute(Attribute::StrictFP))
+  if (!AllowStrictFP && ParentF->hasFnAttribute(Attribute::StrictFP))
     return false;
 
   if (IsF32 && !AllowMinSizeF32 && ParentF->hasMinSize())
     return false;
   return true;
 }
 
 void AMDGPULibCalls::replaceLibCallWithSimpleIntrinsic(CallInst *CI,
                                                        Intrinsic::ID IntrID) {
   CI->setCalledFunction(
       Intrinsic::getDeclaration(CI->getModule(), IntrID, {CI->getType()}));
 }
 
 bool AMDGPULibCalls::tryReplaceLibcallWithSimpleIntrinsic(CallInst *CI,
                                                           Intrinsic::ID IntrID,
                                                           bool AllowMinSizeF32,
-                                                          bool AllowF64) {
-  if (!shouldReplaceLibcallWithIntrinsic(CI, AllowMinSizeF32, AllowF64))
+                                                          bool AllowF64,
+                                                          bool AllowStrictFP) {
+  if (!shouldReplaceLibcallWithIntrinsic(CI, AllowMinSizeF32, AllowF64,
+                                         AllowStrictFP))
     return false;
   replaceLibCallWithSimpleIntrinsic(CI, IntrID);
   return true;
 }
 
 // fold sqrt -> native_sqrt (x)
 bool AMDGPULibCalls::fold_sqrt(FPMathOperator *FPOp, IRBuilder<> &B,
                                const FuncInfo &FInfo) {

llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-copysign.ll

 declare <3 x half> @_Z8copysignDv3_DhS_(<3 x half>, <3 x half>)
 declare <4 x half> @_Z8copysignDv4_DhS_(<4 x half>, <4 x half>)
 declare <8 x half> @_Z8copysignDv8_DhS_(<8 x half>, <8 x half>)
 declare <16 x half> @_Z8copysignDv16_DhS_(<16 x half>, <16 x half>)
 
 define float @test_copysign_f32(float %x, float %y) {
 ; CHECK-LABEL: define float @test_copysign_f32
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call float @_Z8copysignff(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call float @llvm.copysign.f32(float [[X]], float [[Y]])
 ; CHECK-NEXT:    ret float [[COPYSIGN]]
 ;
   %copysign = tail call float @_Z8copysignff(float %x, float %y)
   ret float %copysign
 }
 
 define float @test_copysign_f32_nnan(float %x, float %y) {
 ; CHECK-LABEL: define float @test_copysign_f32_nnan
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call nnan float @_Z8copysignff(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call nnan float @llvm.copysign.f32(float [[X]], float [[Y]])
 ; CHECK-NEXT:    ret float [[COPYSIGN]]
 ;
   %copysign = tail call nnan float @_Z8copysignff(float %x, float %y)
   ret float %copysign
 }
 
 define <2 x float> @test_copysign_v2f32(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: define <2 x float> @test_copysign_v2f32
 ; CHECK-SAME: (<2 x float> [[X:%.*]], <2 x float> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <2 x float> @_Z8copysignDv2_fS_(<2 x float> [[X]], <2 x float> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <2 x float> @llvm.copysign.v2f32(<2 x float> [[X]], <2 x float> [[Y]])
 ; CHECK-NEXT:    ret <2 x float> [[COPYSIGN]]
 ;
   %copysign = tail call <2 x float> @_Z8copysignDv2_fS_(<2 x float> %x, <2 x float> %y)
   ret <2 x float> %copysign
 }
 
 define <3 x float> @test_copysign_v3f32(<3 x float> %x, <3 x float> %y) {
 ; CHECK-LABEL: define <3 x float> @test_copysign_v3f32
 ; CHECK-SAME: (<3 x float> [[X:%.*]], <3 x float> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <3 x float> @_Z8copysignDv3_fS_(<3 x float> [[X]], <3 x float> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <3 x float> @llvm.copysign.v3f32(<3 x float> [[X]], <3 x float> [[Y]])
 ; CHECK-NEXT:    ret <3 x float> [[COPYSIGN]]
 ;
   %copysign = tail call <3 x float> @_Z8copysignDv3_fS_(<3 x float> %x, <3 x float> %y)
   ret <3 x float> %copysign
 }
 
 define <4 x float> @test_copysign_v4f32(<4 x float> %x, <4 x float> %y) {
 ; CHECK-LABEL: define <4 x float> @test_copysign_v4f32
 ; CHECK-SAME: (<4 x float> [[X:%.*]], <4 x float> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <4 x float> @_Z8copysignDv4_fS_(<4 x float> [[X]], <4 x float> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <4 x float> @llvm.copysign.v4f32(<4 x float> [[X]], <4 x float> [[Y]])
 ; CHECK-NEXT:    ret <4 x float> [[COPYSIGN]]
 ;
   %copysign = tail call <4 x float> @_Z8copysignDv4_fS_(<4 x float> %x, <4 x float> %y)
   ret <4 x float> %copysign
 }
 
 define <8 x float> @test_copysign_v8f32(<8 x float> %x, <8 x float> %y) {
 ; CHECK-LABEL: define <8 x float> @test_copysign_v8f32
 ; CHECK-SAME: (<8 x float> [[X:%.*]], <8 x float> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <8 x float> @_Z8copysignDv8_fS_(<8 x float> [[X]], <8 x float> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <8 x float> @llvm.copysign.v8f32(<8 x float> [[X]], <8 x float> [[Y]])
 ; CHECK-NEXT:    ret <8 x float> [[COPYSIGN]]
 ;
   %copysign = tail call <8 x float> @_Z8copysignDv8_fS_(<8 x float> %x, <8 x float> %y)
   ret <8 x float> %copysign
 }
 
 define <16 x float> @test_copysign_v16f32(<16 x float> %x, <16 x float> %y) {
 ; CHECK-LABEL: define <16 x float> @test_copysign_v16f32
 ; CHECK-SAME: (<16 x float> [[X:%.*]], <16 x float> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <16 x float> @_Z8copysignDv16_fS_(<16 x float> [[X]], <16 x float> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <16 x float> @llvm.copysign.v16f32(<16 x float> [[X]], <16 x float> [[Y]])
 ; CHECK-NEXT:    ret <16 x float> [[COPYSIGN]]
 ;
   %copysign = tail call <16 x float> @_Z8copysignDv16_fS_(<16 x float> %x, <16 x float> %y)
   ret <16 x float> %copysign
 }
 
 define double @test_copysign_f64(double %x, double %y) {
 ; CHECK-LABEL: define double @test_copysign_f64
 ; CHECK-SAME: (double [[X:%.*]], double [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call double @_Z8copysigndd(double [[X]], double [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call double @llvm.copysign.f64(double [[X]], double [[Y]])
 ; CHECK-NEXT:    ret double [[COPYSIGN]]
 ;
   %copysign = tail call double @_Z8copysigndd(double %x, double %y)
   ret double %copysign
 }
 
 define <2 x double> @test_copysign_v2f64(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: define <2 x double> @test_copysign_v2f64
 ; CHECK-SAME: (<2 x double> [[X:%.*]], <2 x double> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <2 x double> @_Z8copysignDv2_dS_(<2 x double> [[X]], <2 x double> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <2 x double> @llvm.copysign.v2f64(<2 x double> [[X]], <2 x double> [[Y]])
 ; CHECK-NEXT:    ret <2 x double> [[COPYSIGN]]
 ;
   %copysign = tail call <2 x double> @_Z8copysignDv2_dS_(<2 x double> %x, <2 x double> %y)
   ret <2 x double> %copysign
 }
 
 define <3 x double> @test_copysign_v3f64(<3 x double> %x, <3 x double> %y) {
 ; CHECK-LABEL: define <3 x double> @test_copysign_v3f64
 ; CHECK-SAME: (<3 x double> [[X:%.*]], <3 x double> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <3 x double> @_Z8copysignDv3_dS_(<3 x double> [[X]], <3 x double> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <3 x double> @llvm.copysign.v3f64(<3 x double> [[X]], <3 x double> [[Y]])
 ; CHECK-NEXT:    ret <3 x double> [[COPYSIGN]]
 ;
   %copysign = tail call <3 x double> @_Z8copysignDv3_dS_(<3 x double> %x, <3 x double> %y)
   ret <3 x double> %copysign
 }
 
 define <4 x double> @test_copysign_v4f64(<4 x double> %x, <4 x double> %y) {
 ; CHECK-LABEL: define <4 x double> @test_copysign_v4f64
 ; CHECK-SAME: (<4 x double> [[X:%.*]], <4 x double> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <4 x double> @_Z8copysignDv4_dS_(<4 x double> [[X]], <4 x double> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <4 x double> @llvm.copysign.v4f64(<4 x double> [[X]], <4 x double> [[Y]])
 ; CHECK-NEXT:    ret <4 x double> [[COPYSIGN]]
 ;
   %copysign = tail call <4 x double> @_Z8copysignDv4_dS_(<4 x double> %x, <4 x double> %y)
   ret <4 x double> %copysign
 }
 
 define <8 x double> @test_copysign_v8f64(<8 x double> %x, <8 x double> %y) {
 ; CHECK-LABEL: define <8 x double> @test_copysign_v8f64
 ; CHECK-SAME: (<8 x double> [[X:%.*]], <8 x double> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <8 x double> @_Z8copysignDv8_dS_(<8 x double> [[X]], <8 x double> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <8 x double> @llvm.copysign.v8f64(<8 x double> [[X]], <8 x double> [[Y]])
 ; CHECK-NEXT:    ret <8 x double> [[COPYSIGN]]
 ;
   %copysign = tail call <8 x double> @_Z8copysignDv8_dS_(<8 x double> %x, <8 x double> %y)
   ret <8 x double> %copysign
 }
 
 define <16 x double> @test_copysign_v16f64(<16 x double> %x, <16 x double> %y) {
 ; CHECK-LABEL: define <16 x double> @test_copysign_v16f64
 ; CHECK-SAME: (<16 x double> [[X:%.*]], <16 x double> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <16 x double> @_Z8copysignDv16_dS_(<16 x double> [[X]], <16 x double> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <16 x double> @llvm.copysign.v16f64(<16 x double> [[X]], <16 x double> [[Y]])
 ; CHECK-NEXT:    ret <16 x double> [[COPYSIGN]]
 ;
   %copysign = tail call <16 x double> @_Z8copysignDv16_dS_(<16 x double> %x, <16 x double> %y)
   ret <16 x double> %copysign
 }
 
 define half @test_copysign_f16(half %x, half %y) {
 ; CHECK-LABEL: define half @test_copysign_f16
 ; CHECK-SAME: (half [[X:%.*]], half [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call half @_Z8copysignDhDh(half [[X]], half [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call half @llvm.copysign.f16(half [[X]], half [[Y]])
 ; CHECK-NEXT:    ret half [[COPYSIGN]]
 ;
   %copysign = tail call half @_Z8copysignDhDh(half %x, half %y)
   ret half %copysign
 }
 
 define <2 x half> @test_copysign_v2f16(<2 x half> %x, <2 x half> %y) {
 ; CHECK-LABEL: define <2 x half> @test_copysign_v2f16
 ; CHECK-SAME: (<2 x half> [[X:%.*]], <2 x half> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <2 x half> @_Z8copysignDv2_DhS_(<2 x half> [[X]], <2 x half> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <2 x half> @llvm.copysign.v2f16(<2 x half> [[X]], <2 x half> [[Y]])
 ; CHECK-NEXT:    ret <2 x half> [[COPYSIGN]]
 ;
   %copysign = tail call <2 x half> @_Z8copysignDv2_DhS_(<2 x half> %x, <2 x half> %y)
   ret <2 x half> %copysign
 }
 
 define <3 x half> @test_copysign_v3f16(<3 x half> %x, <3 x half> %y) {
 ; CHECK-LABEL: define <3 x half> @test_copysign_v3f16
 ; CHECK-SAME: (<3 x half> [[X:%.*]], <3 x half> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <3 x half> @_Z8copysignDv3_DhS_(<3 x half> [[X]], <3 x half> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <3 x half> @llvm.copysign.v3f16(<3 x half> [[X]], <3 x half> [[Y]])
 ; CHECK-NEXT:    ret <3 x half> [[COPYSIGN]]
 ;
   %copysign = tail call <3 x half> @_Z8copysignDv3_DhS_(<3 x half> %x, <3 x half> %y)
   ret <3 x half> %copysign
 }
 
 define <4 x half> @test_copysign_v4f16(<4 x half> %x, <4 x half> %y) {
 ; CHECK-LABEL: define <4 x half> @test_copysign_v4f16
 ; CHECK-SAME: (<4 x half> [[X:%.*]], <4 x half> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <4 x half> @_Z8copysignDv4_DhS_(<4 x half> [[X]], <4 x half> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <4 x half> @llvm.copysign.v4f16(<4 x half> [[X]], <4 x half> [[Y]])
 ; CHECK-NEXT:    ret <4 x half> [[COPYSIGN]]
 ;
   %copysign = tail call <4 x half> @_Z8copysignDv4_DhS_(<4 x half> %x, <4 x half> %y)
   ret <4 x half> %copysign
 }
 
 define <8 x half> @test_copysign_v8f16(<8 x half> %x, <8 x half> %y) {
 ; CHECK-LABEL: define <8 x half> @test_copysign_v8f16
 ; CHECK-SAME: (<8 x half> [[X:%.*]], <8 x half> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <8 x half> @_Z8copysignDv8_DhS_(<8 x half> [[X]], <8 x half> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <8 x half> @llvm.copysign.v8f16(<8 x half> [[X]], <8 x half> [[Y]])
 ; CHECK-NEXT:    ret <8 x half> [[COPYSIGN]]
 ;
   %copysign = tail call <8 x half> @_Z8copysignDv8_DhS_(<8 x half> %x, <8 x half> %y)
   ret <8 x half> %copysign
 }
 
 define <16 x half> @test_copysign_v16f16(<16 x half> %x, <16 x half> %y) {
 ; CHECK-LABEL: define <16 x half> @test_copysign_v16f16
 ; CHECK-SAME: (<16 x half> [[X:%.*]], <16 x half> [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <16 x half> @_Z8copysignDv16_DhS_(<16 x half> [[X]], <16 x half> [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call <16 x half> @llvm.copysign.v16f16(<16 x half> [[X]], <16 x half> [[Y]])
 ; CHECK-NEXT:    ret <16 x half> [[COPYSIGN]]
 ;
   %copysign = tail call <16 x half> @_Z8copysignDv16_DhS_(<16 x half> %x, <16 x half> %y)
   ret <16 x half> %copysign
 }
 
 define float @test_copysign_f32_minsize(float %x, float %y) #0 {
 ; CHECK-LABEL: define float @test_copysign_f32_minsize
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0:[0-9]+]] {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call float @_Z8copysignff(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call float @llvm.copysign.f32(float [[X]], float [[Y]])
 ; CHECK-NEXT:    ret float [[COPYSIGN]]
 ;
   %copysign = tail call float @_Z8copysignff(float %x, float %y)
   ret float %copysign
 }
 
 define float @test_copysign_f32_nnan_minsize(float %x, float %y) #0 {
 ; CHECK-LABEL: define float @test_copysign_f32_nnan_minsize
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call nnan float @_Z8copysignff(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call nnan float @llvm.copysign.f32(float [[X]], float [[Y]])
 ; CHECK-NEXT:    ret float [[COPYSIGN]]
 ;
   %copysign = tail call nnan float @_Z8copysignff(float %x, float %y)
   ret float %copysign
 }
 
 define float @test_copysign_f32_noinline(float %x, float %y) {
 ; CHECK-LABEL: define float @test_copysign_f32_noinline
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call float @_Z8copysignff(float [[X]], float [[Y]]) #[[ATTR2:[0-9]+]]
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call float @_Z8copysignff(float [[X]], float [[Y]]) #[[ATTR3:[0-9]+]]
 ; CHECK-NEXT:    ret float [[COPYSIGN]]
 ;
   %copysign = tail call float @_Z8copysignff(float %x, float %y) #1
   ret float %copysign
 }
 
 define float @test_copysign_f32_nnan_noinline(float %x, float %y) {
 ; CHECK-LABEL: define float @test_copysign_f32_nnan_noinline
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call nnan float @_Z8copysignff(float [[X]], float [[Y]]) #[[ATTR2]]
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call nnan float @_Z8copysignff(float [[X]], float [[Y]]) #[[ATTR3]]
 ; CHECK-NEXT:    ret float [[COPYSIGN]]
 ;
   %copysign = tail call nnan float @_Z8copysignff(float %x, float %y) #1
   ret float %copysign
 }
 
 define float @test_copysign_f32_strictfp(float %x, float %y) #2 {
 ; CHECK-LABEL: define float @test_copysign_f32_strictfp
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) #[[ATTR1:[0-9]+]] {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call nnan nsz float @_Z8copysignff(float [[X]], float [[Y]]) #[[ATTR1]]
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call nnan nsz float @llvm.copysign.f32(float [[X]], float [[Y]]) #[[ATTR1]]
 ; CHECK-NEXT:    ret float [[COPYSIGN]]
 ;
   %copysign = tail call nsz nnan float @_Z8copysignff(float %x, float %y) #2
   ret float %copysign
 }
 
 define float @test_copysign_f32_fast_nobuiltin(float %x, float %y) {
 ; CHECK-LABEL: define float @test_copysign_f32_fast_nobuiltin
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call fast float @_Z8copysignff(float [[X]], float [[Y]]) #[[ATTR3:[0-9]+]]
+; CHECK-NEXT:    [[COPYSIGN:%.*]] = tail call fast float @_Z8copysignff(float [[X]], float [[Y]]) #[[ATTR4:[0-9]+]]
 ; CHECK-NEXT:    ret float [[COPYSIGN]]
 ;
   %copysign = tail call fast float @_Z8copysignff(float %x, float %y) #3
   ret float %copysign
 }
 
 attributes #0 = { minsize }
 attributes #1 = { noinline }
 attributes #2 = { strictfp }
 attributes #3 = { nobuiltin }

llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-fabs.ll

 declare <3 x half> @_Z4fabsDv3_Dh(<3 x half>)
 declare <4 x half> @_Z4fabsDv4_Dh(<4 x half>)
 declare <8 x half> @_Z4fabsDv8_Dh(<8 x half>)
 declare <16 x half> @_Z4fabsDv16_Dh(<16 x half>)
 
 define float @test_fabs_f32(float %arg) {
 ; CHECK-LABEL: define float @test_fabs_f32
 ; CHECK-SAME: (float [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call float @_Z4fabsf(float [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call float @llvm.fabs.f32(float [[ARG]])
 ; CHECK-NEXT:    ret float [[FABS]]
 ;
   %fabs = tail call float @_Z4fabsf(float %arg)
   ret float %fabs
 }
 
 define <2 x float> @test_fabs_v2f32(<2 x float> %arg) {
 ; CHECK-LABEL: define <2 x float> @test_fabs_v2f32
 ; CHECK-SAME: (<2 x float> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x float> @_Z4fabsDv2_f(<2 x float> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x float> @llvm.fabs.v2f32(<2 x float> [[ARG]])
 ; CHECK-NEXT:    ret <2 x float> [[FABS]]
 ;
   %fabs = tail call <2 x float> @_Z4fabsDv2_f(<2 x float> %arg)
   ret <2 x float> %fabs
 }
 
 define <3 x float> @test_fabs_v3f32(<3 x float> %arg) {
 ; CHECK-LABEL: define <3 x float> @test_fabs_v3f32
 ; CHECK-SAME: (<3 x float> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <3 x float> @_Z4fabsDv3_f(<3 x float> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <3 x float> @llvm.fabs.v3f32(<3 x float> [[ARG]])
 ; CHECK-NEXT:    ret <3 x float> [[FABS]]
 ;
   %fabs = tail call <3 x float> @_Z4fabsDv3_f(<3 x float> %arg)
   ret <3 x float> %fabs
 }
 
 define <4 x float> @test_fabs_v4f32(<4 x float> %arg) {
 ; CHECK-LABEL: define <4 x float> @test_fabs_v4f32
 ; CHECK-SAME: (<4 x float> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <4 x float> @_Z4fabsDv4_f(<4 x float> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <4 x float> @llvm.fabs.v4f32(<4 x float> [[ARG]])
 ; CHECK-NEXT:    ret <4 x float> [[FABS]]
 ;
   %fabs = tail call <4 x float> @_Z4fabsDv4_f(<4 x float> %arg)
   ret <4 x float> %fabs
 }
 
 define <8 x float> @test_fabs_v8f32(<8 x float> %arg) {
 ; CHECK-LABEL: define <8 x float> @test_fabs_v8f32
 ; CHECK-SAME: (<8 x float> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <8 x float> @_Z4fabsDv8_f(<8 x float> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <8 x float> @llvm.fabs.v8f32(<8 x float> [[ARG]])
 ; CHECK-NEXT:    ret <8 x float> [[FABS]]
 ;
   %fabs = tail call <8 x float> @_Z4fabsDv8_f(<8 x float> %arg)
   ret <8 x float> %fabs
 }
 
 define <16 x float> @test_fabs_v16f32(<16 x float> %arg) {
 ; CHECK-LABEL: define <16 x float> @test_fabs_v16f32
 ; CHECK-SAME: (<16 x float> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <16 x float> @_Z4fabsDv16_f(<16 x float> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <16 x float> @llvm.fabs.v16f32(<16 x float> [[ARG]])
 ; CHECK-NEXT:    ret <16 x float> [[FABS]]
 ;
   %fabs = tail call <16 x float> @_Z4fabsDv16_f(<16 x float> %arg)
   ret <16 x float> %fabs
 }
 
 define double @test_fabs_f64(double %arg) {
 ; CHECK-LABEL: define double @test_fabs_f64
 ; CHECK-SAME: (double [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call double @_Z4fabsd(double [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call double @llvm.fabs.f64(double [[ARG]])
 ; CHECK-NEXT:    ret double [[FABS]]
 ;
   %fabs = tail call double @_Z4fabsd(double %arg)
   ret double %fabs
 }
 
 define <2 x double> @test_fabs_v2f64(<2 x double> %arg) {
 ; CHECK-LABEL: define <2 x double> @test_fabs_v2f64
 ; CHECK-SAME: (<2 x double> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x double> @_Z4fabsDv2_d(<2 x double> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> [[ARG]])
 ; CHECK-NEXT:    ret <2 x double> [[FABS]]
 ;
   %fabs = tail call <2 x double> @_Z4fabsDv2_d(<2 x double> %arg)
   ret <2 x double> %fabs
 }
 
 define <3 x double> @test_fabs_v3f64(<3 x double> %arg) {
 ; CHECK-LABEL: define <3 x double> @test_fabs_v3f64
 ; CHECK-SAME: (<3 x double> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <3 x double> @_Z4fabsDv3_d(<3 x double> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <3 x double> @llvm.fabs.v3f64(<3 x double> [[ARG]])
 ; CHECK-NEXT:    ret <3 x double> [[FABS]]
 ;
   %fabs = tail call <3 x double> @_Z4fabsDv3_d(<3 x double> %arg)
   ret <3 x double> %fabs
 }
 
 define <4 x double> @test_fabs_v4f64(<4 x double> %arg) {
 ; CHECK-LABEL: define <4 x double> @test_fabs_v4f64
 ; CHECK-SAME: (<4 x double> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <4 x double> @_Z4fabsDv4_d(<4 x double> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <4 x double> @llvm.fabs.v4f64(<4 x double> [[ARG]])
 ; CHECK-NEXT:    ret <4 x double> [[FABS]]
 ;
   %fabs = tail call <4 x double> @_Z4fabsDv4_d(<4 x double> %arg)
   ret <4 x double> %fabs
 }
 
 define <8 x double> @test_fabs_v8f64(<8 x double> %arg) {
 ; CHECK-LABEL: define <8 x double> @test_fabs_v8f64
 ; CHECK-SAME: (<8 x double> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <8 x double> @_Z4fabsDv8_d(<8 x double> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <8 x double> @llvm.fabs.v8f64(<8 x double> [[ARG]])
 ; CHECK-NEXT:    ret <8 x double> [[FABS]]
 ;
   %fabs = tail call <8 x double> @_Z4fabsDv8_d(<8 x double> %arg)
   ret <8 x double> %fabs
 }
 
 define <16 x double> @test_fabs_v16f64(<16 x double> %arg) {
 ; CHECK-LABEL: define <16 x double> @test_fabs_v16f64
 ; CHECK-SAME: (<16 x double> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <16 x double> @_Z4fabsDv16_d(<16 x double> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <16 x double> @llvm.fabs.v16f64(<16 x double> [[ARG]])
 ; CHECK-NEXT:    ret <16 x double> [[FABS]]
 ;
   %fabs = tail call <16 x double> @_Z4fabsDv16_d(<16 x double> %arg)
   ret <16 x double> %fabs
 }
 
 define half @test_fabs_f16(half %arg) {
 ; CHECK-LABEL: define half @test_fabs_f16
 ; CHECK-SAME: (half [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call half @_Z4fabsDh(half [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call half @llvm.fabs.f16(half [[ARG]])
 ; CHECK-NEXT:    ret half [[FABS]]
 ;
   %fabs = tail call half @_Z4fabsDh(half %arg)
   ret half %fabs
 }
 
 define <2 x half> @test_fabs_v2f16(<2 x half> %arg) {
 ; CHECK-LABEL: define <2 x half> @test_fabs_v2f16
 ; CHECK-SAME: (<2 x half> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x half> @_Z4fabsDv2_Dh(<2 x half> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x half> @llvm.fabs.v2f16(<2 x half> [[ARG]])
 ; CHECK-NEXT:    ret <2 x half> [[FABS]]
 ;
   %fabs = tail call <2 x half> @_Z4fabsDv2_Dh(<2 x half> %arg)
   ret <2 x half> %fabs
 }
 
 define <3 x half> @test_fabs_v3f16(<3 x half> %arg) {
 ; CHECK-LABEL: define <3 x half> @test_fabs_v3f16
 ; CHECK-SAME: (<3 x half> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <3 x half> @_Z4fabsDv3_Dh(<3 x half> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <3 x half> @llvm.fabs.v3f16(<3 x half> [[ARG]])
 ; CHECK-NEXT:    ret <3 x half> [[FABS]]
 ;
   %fabs = tail call <3 x half> @_Z4fabsDv3_Dh(<3 x half> %arg)
   ret <3 x half> %fabs
 }
 
 define <4 x half> @test_fabs_v4f16(<4 x half> %arg) {
 ; CHECK-LABEL: define <4 x half> @test_fabs_v4f16
 ; CHECK-SAME: (<4 x half> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <4 x half> @_Z4fabsDv4_Dh(<4 x half> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <4 x half> @llvm.fabs.v4f16(<4 x half> [[ARG]])
 ; CHECK-NEXT:    ret <4 x half> [[FABS]]
 ;
   %fabs = tail call <4 x half> @_Z4fabsDv4_Dh(<4 x half> %arg)
   ret <4 x half> %fabs
 }
 
 define <8 x half> @test_fabs_v8f16(<8 x half> %arg) {
 ; CHECK-LABEL: define <8 x half> @test_fabs_v8f16
 ; CHECK-SAME: (<8 x half> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <8 x half> @_Z4fabsDv8_Dh(<8 x half> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <8 x half> @llvm.fabs.v8f16(<8 x half> [[ARG]])
 ; CHECK-NEXT:    ret <8 x half> [[FABS]]
 ;
   %fabs = tail call <8 x half> @_Z4fabsDv8_Dh(<8 x half> %arg)
   ret <8 x half> %fabs
 }
 
 define <16 x half> @test_fabs_v16f16(<16 x half> %arg) {
 ; CHECK-LABEL: define <16 x half> @test_fabs_v16f16
 ; CHECK-SAME: (<16 x half> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <16 x half> @_Z4fabsDv16_Dh(<16 x half> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <16 x half> @llvm.fabs.v16f16(<16 x half> [[ARG]])
 ; CHECK-NEXT:    ret <16 x half> [[FABS]]
 ;
   %fabs = tail call <16 x half> @_Z4fabsDv16_Dh(<16 x half> %arg)
   ret <16 x half> %fabs
 }
 
 define float @test_fabs_f32_nobuiltin_callsite(float %arg) {
 ; CHECK-LABEL: define float @test_fabs_f32_nobuiltin_callsite
 ; CHECK-SAME: (float [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call float @_Z4fabsf(float [[ARG]]) #[[ATTR3:[0-9]+]]
+; CHECK-NEXT:    [[FABS:%.*]] = tail call float @_Z4fabsf(float [[ARG]]) #[[ATTR4:[0-9]+]]
 ; CHECK-NEXT:    ret float [[FABS]]
 ;
   %fabs = tail call float @_Z4fabsf(float %arg) #0
   ret float %fabs
 }
 
 define <2 x float> @test_fabs_v2f32_nobuiltin_callsite(<2 x float> %arg) {
 ; CHECK-LABEL: define <2 x float> @test_fabs_v2f32_nobuiltin_callsite
 ; CHECK-SAME: (<2 x float> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x float> @_Z4fabsDv2_f(<2 x float> [[ARG]]) #[[ATTR3]]
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x float> @_Z4fabsDv2_f(<2 x float> [[ARG]]) #[[ATTR4]]
 ; CHECK-NEXT:    ret <2 x float> [[FABS]]
 ;
   %fabs = tail call <2 x float> @_Z4fabsDv2_f(<2 x float> %arg) #0
   ret <2 x float> %fabs
 }
 
 ; "no-builtins" should be ignored
 define float @test_fabs_f32_nobuiltins(float %arg) #1 {
 ; CHECK-LABEL: define float @test_fabs_f32_nobuiltins
 ; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR0:[0-9]+]] {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call float @_Z4fabsf(float [[ARG]]) #[[ATTR3]]
+; CHECK-NEXT:    [[FABS:%.*]] = tail call float @_Z4fabsf(float [[ARG]]) #[[ATTR4]]
 ; CHECK-NEXT:    ret float [[FABS]]
 ;
   %fabs = tail call float @_Z4fabsf(float %arg) #0
   ret float %fabs
 }
 
 define <2 x float> @test_fabs_v2f32_nobuiltins(<2 x float> %arg) #1 {
 ; CHECK-LABEL: define <2 x float> @test_fabs_v2f32_nobuiltins
 ; CHECK-SAME: (<2 x float> [[ARG:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x float> @_Z4fabsDv2_f(<2 x float> [[ARG]]) #[[ATTR3]]
+; CHECK-NEXT:    [[FABS:%.*]] = tail call <2 x float> @_Z4fabsDv2_f(<2 x float> [[ARG]]) #[[ATTR4]]
 ; CHECK-NEXT:    ret <2 x float> [[FABS]]
 ;
   %fabs = tail call <2 x float> @_Z4fabsDv2_f(<2 x float> %arg) #0
   ret <2 x float> %fabs
 }
 
 define float @test_fabs_f32_preserve_flags(float %arg) {
 ; CHECK-LABEL: define float @test_fabs_f32_preserve_flags
 ; CHECK-SAME: (float [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan ninf float @_Z4fabsf(float [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan ninf float @llvm.fabs.f32(float [[ARG]])
 ; CHECK-NEXT:    ret float [[FABS]]
 ;
   %fabs = tail call nnan ninf float @_Z4fabsf(float %arg)
   ret float %fabs
 }
 
 define <2 x float> @test_fabs_v2f32_preserve_flags(<2 x float> %arg) {
 ; CHECK-LABEL: define <2 x float> @test_fabs_v2f32_preserve_flags
 ; CHECK-SAME: (<2 x float> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan nsz contract <2 x float> @_Z4fabsDv2_f(<2 x float> [[ARG]])
+; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan nsz contract <2 x float> @llvm.fabs.v2f32(<2 x float> [[ARG]])
 ; CHECK-NEXT:    ret <2 x float> [[FABS]]
 ;
   %fabs = tail call contract nsz nnan <2 x float> @_Z4fabsDv2_f(<2 x float> %arg)
   ret <2 x float> %fabs
 }
 
 define float @test_fabs_f32_preserve_flags_md(float %arg) {
 ; CHECK-LABEL: define float @test_fabs_f32_preserve_flags_md
 ; CHECK-SAME: (float [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan ninf float @_Z4fabsf(float [[ARG]]), !foo !0
+; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan ninf float @llvm.fabs.f32(float [[ARG]]), !foo !0
 ; CHECK-NEXT:    ret float [[FABS]]
 ;
   %fabs = tail call nnan ninf float @_Z4fabsf(float %arg), !foo !0
   ret float %fabs
 }
 
 define <2 x float> @test_fabs_v2f32_preserve_flags_md(<2 x float> %arg) {
 ; CHECK-LABEL: define <2 x float> @test_fabs_v2f32_preserve_flags_md
 ; CHECK-SAME: (<2 x float> [[ARG:%.*]]) {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan nsz contract <2 x float> @_Z4fabsDv2_f(<2 x float> [[ARG]]), !foo !0
+; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan nsz contract <2 x float> @llvm.fabs.v2f32(<2 x float> [[ARG]]), !foo !0
 ; CHECK-NEXT:    ret <2 x float> [[FABS]]
 ;
   %fabs = tail call contract nsz nnan <2 x float> @_Z4fabsDv2_f(<2 x float> %arg), !foo !0
   ret <2 x float> %fabs
 }
 
 ; Test the libm name, not a recognized opencl builtin.
 declare float @fabsf(float) #2

 ;
   %fabs = tail call double @fabs(double %arg)
   ret double %fabs
 }
 
 define float @test_fabs_f32_strictfp(float %arg) #3 {
 ; CHECK-LABEL: define float @test_fabs_f32_strictfp
 ; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR2:[0-9]+]] {
-; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan float @_Z4fabsf(float [[ARG]]) #[[ATTR2]]
+; CHECK-NEXT:    [[FABS:%.*]] = tail call nnan float @llvm.fabs.f32(float [[ARG]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[FABS]]
 ;
   %fabs = tail call nnan float @_Z4fabsf(float %arg) #3
   ret float %fabs
 }
 
 attributes #0 = { nobuiltin }
 attributes #1 = { "no-builtins" }
 attributes #2 = { nounwind memory(none) }
 attributes #3 = { strictfp }
 
 !0 = !{i32 1234}