PowerPC-specific builtin constrained FP enablement

[ajwock]

Summary

This change enables PowerPC compiler builtins to generate constrained floating point operations when clang is indicated to do so.

A couple of possibly unexpected backend divergences between constrained floating point and regular behavior are highlighted under the test tag FIXME-CHECK. This may be something for those on the PPC backend to look at.

[steven.zhang]

clang/lib/CodeGen/CGBuiltin.cpp

14069

Can we do it like this to avoid the duplicate if statement ?

if (...)
   ID = Builder.getIsFPConstrained() ? Intrinsic::experimental_constrained_floor : Intrinsic::floor;
 ...
 return Builder.getIsFPConstrained() ? Builder. CreateConstrainedFPCall() : Builder.CreateCall();

[ajwock]

Took steven.zhang's suggestion, added REQUIRES line to diff. Hopefully addressed harbormaster concerns.

[steven.zhang]

LGTM overall with some minor comments.

clang/lib/CodeGen/CGBuiltin.cpp

14047–14048

line too long. Please format the code with clang-format.

clang/test/CodeGen/builtins-ppc-fpconstrained.c

5

Do we have to specify option "-disable-O0-optnone -Wall -Wno-unused -Werror" ?

[ajwock]

It seems one of the issues that my tests revealed was already remedied in very recent changes, causing my test to fail. I changed the test to reflect that while also taking steven's recommendations.

[steven.zhang]

LGTM now and thank you for doing this. Please hold on for 2-3 days in case others have comments. And thank you for pointing a potential issue of the folding of fneg + fma. We will take a look later.

clang/lib/CodeGen/CGBuiltin.cpp

case PPC::BI__builtin_vsx_stxvll:
     llvm::Function *F = CGM.getIntrinsic(ID);
     return Builder.CreateCall(F, Ops, "");
   }
   // Square root
   case PPC::BI__builtin_vsx_xvsqrtsp:
   case PPC::BI__builtin_vsx_xvsqrtdp: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
-    ID = Intrinsic::sqrt;
-    llvm::Function *F = CGM.getIntrinsic(ID, ResultType);
+    if (Builder.getIsFPConstrained()) {
+      llvm::Function *F = CGM.getIntrinsic(
+          Intrinsic::experimental_constrained_sqrt, ResultType);
+      return Builder.CreateConstrainedFPCall(F, X);
+    } else {
+      llvm::Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType);
       return Builder.CreateCall(F, X);
     }
+  }
   // Count leading zeros
   case PPC::BI__builtin_altivec_vclzb:
   case PPC::BI__builtin_altivec_vclzh:
   case PPC::BI__builtin_altivec_vclzw:
   case PPC::BI__builtin_altivec_vclzd: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
     Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID,
   case PPC::BI__builtin_vsx_xvrspim:
   case PPC::BI__builtin_vsx_xvrdpi:
   case PPC::BI__builtin_vsx_xvrspi:
   case PPC::BI__builtin_vsx_xvrdpic:
   case PPC::BI__builtin_vsx_xvrspic:
   case PPC::BI__builtin_vsx_xvrdpiz:
   case PPC::BI__builtin_vsx_xvrspiz: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
+    if (Builder.getIsFPConstrained()) {
+      if (BuiltinID == PPC::BI__builtin_vsx_xvrdpim ||
+          BuiltinID == PPC::BI__builtin_vsx_xvrspim)
+        ID = Intrinsic::experimental_constrained_floor;
+      else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpi ||
+               BuiltinID == PPC::BI__builtin_vsx_xvrspi)
+        ID = Intrinsic::experimental_constrained_round;
+      else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpic ||
+               BuiltinID == PPC::BI__builtin_vsx_xvrspic)
+        ID = Intrinsic::experimental_constrained_nearbyint;
+      else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpip ||
+               BuiltinID == PPC::BI__builtin_vsx_xvrspip)
+        ID = Intrinsic::experimental_constrained_ceil;
+      else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpiz ||
+               BuiltinID == PPC::BI__builtin_vsx_xvrspiz)
+        ID = Intrinsic::experimental_constrained_trunc;
+      llvm::Function *F = CGM.getIntrinsic(ID, ResultType);
+      return Builder.CreateConstrainedFPCall(F, X);
+    } else {
       if (BuiltinID == PPC::BI__builtin_vsx_xvrdpim ||
           BuiltinID == PPC::BI__builtin_vsx_xvrspim)
         ID = Intrinsic::floor;
       else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpi ||
                BuiltinID == PPC::BI__builtin_vsx_xvrspi)
         ID = Intrinsic::round;
       else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpic ||
                BuiltinID == PPC::BI__builtin_vsx_xvrspic)
         ID = Intrinsic::nearbyint;
       else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpip ||
                BuiltinID == PPC::BI__builtin_vsx_xvrspip)
         ID = Intrinsic::ceil;
       else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpiz ||
                BuiltinID == PPC::BI__builtin_vsx_xvrspiz)
         ID = Intrinsic::trunc;
       llvm::Function *F = CGM.getIntrinsic(ID, ResultType);
       return Builder.CreateCall(F, X);
     }
+  }
 
   // Absolute value
   case PPC::BI__builtin_vsx_xvabsdp:
   case PPC::BI__builtin_vsx_xvabssp: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
     llvm::Function *F = CGM.getIntrinsic(Intrinsic::fabs, ResultType);
     return Builder.CreateCall(F, X);
   }
 
   // FMA variations
   case PPC::BI__builtin_vsx_xvmaddadp:
   case PPC::BI__builtin_vsx_xvmaddasp:
   case PPC::BI__builtin_vsx_xvnmaddadp:
   case PPC::BI__builtin_vsx_xvnmaddasp:
   case PPC::BI__builtin_vsx_xvmsubadp:
   case PPC::BI__builtin_vsx_xvmsubasp:
   case PPC::BI__builtin_vsx_xvnmsubadp:
   case PPC::BI__builtin_vsx_xvnmsubasp: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
     Value *Y = EmitScalarExpr(E->getArg(1));
     Value *Z = EmitScalarExpr(E->getArg(2));
-    llvm::Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
+    llvm::Function *F;
+    if (Builder.getIsFPConstrained()) {
+      F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
+    } else {
+      F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
+    }
     switch (BuiltinID) {
       case PPC::BI__builtin_vsx_xvmaddadp:
       case PPC::BI__builtin_vsx_xvmaddasp:
+        if (Builder.getIsFPConstrained()) {
+          return Builder.CreateConstrainedFPCall(F, {X, Y, Z});
+        } else {
           return Builder.CreateCall(F, {X, Y, Z});
+        }
       case PPC::BI__builtin_vsx_xvnmaddadp:
       case PPC::BI__builtin_vsx_xvnmaddasp:
+        if (Builder.getIsFPConstrained()) {
+          return Builder.CreateFNeg(
+              Builder.CreateConstrainedFPCall(F, {X, Y, Z}), "neg");
+        } else {
           return Builder.CreateFNeg(Builder.CreateCall(F, {X, Y, Z}), "neg");
+        }
       case PPC::BI__builtin_vsx_xvmsubadp:
       case PPC::BI__builtin_vsx_xvmsubasp:
+        if (Builder.getIsFPConstrained()) {
+          return Builder.CreateConstrainedFPCall(
+              F, {X, Y, Builder.CreateFNeg(Z, "neg")});
+        } else {
           return Builder.CreateCall(F, {X, Y, Builder.CreateFNeg(Z, "neg")});
+        }
       case PPC::BI__builtin_vsx_xvnmsubadp:
       case PPC::BI__builtin_vsx_xvnmsubasp:
+        if (Builder.getIsFPConstrained()) {
+          return Builder.CreateFNeg(
+              Builder.CreateConstrainedFPCall(
+                  F, {X, Y, Builder.CreateFNeg(Z, "neg")}),
+              "neg");
+        } else {
           return Builder.CreateFNeg(
-            Builder.CreateCall(F, {X, Y, Builder.CreateFNeg(Z, "neg")}), "neg");
+              Builder.CreateCall(F, {X, Y, Builder.CreateFNeg(Z, "neg")}),
+              "neg");
+        }
     }
     llvm_unreachable("Unknown FMA operation");
     return nullptr; // Suppress no-return warning
   }
 
   case PPC::BI__builtin_vsx_insertword: {
     llvm::Function *F = CGM.getIntrinsic(Intrinsic::ppc_vsx_xxinsertw);
 

clang/test/CodeGen/builtins-ppc-fpconstrained.c

+// RUN: %clang_cc1 -triple powerpc64le-gnu-linux -target-feature +vsx \
+// RUN: -disable-O0-optnone -Wall -Wno-unused -Werror -emit-llvm %s -o - | \
+// RUN: FileCheck --check-prefix=CHECK-UNCONSTRAINED -vv %s
+// RUN: %clang_cc1 -triple powerpc64le-gnu-linux -target-feature +vsx \
+// RUN: -disable-O0-optnone -ffp-exception-behavior=strict -Wall \
+// RUN: -Wno-unused -Werror -emit-llvm %s -o - | FileCheck \
+// RUN: --check-prefix=CHECK-CONSTRAINED -vv %s
+// RUN: %clang_cc1 -triple powerpc64le-gnu-linux -target-feature +vsx \
+// RUN: -disable-O0-optnone -fallow-half-arguments-and-returns -S -o - %s | \
+// RUN: FileCheck --check-prefix=CHECK-ASM --check-prefix=NOT-FIXME-CHECK  %s
+// RUN: %clang_cc1 -triple powerpc64le-gnu-linux -target-feature +vsx \
+// RUN: -disable-O0-optnone -fallow-half-arguments-and-returns -S \
+// RUN: -ffp-exception-behavior=strict  -o - %s | FileCheck \
+// RUN: --check-prefix=CHECK-ASM --check-prefix=FIXME-CHECK  %s
+
+typedef __attribute__((vector_size(4 * sizeof(float)))) float vec_float;
+typedef __attribute__((vector_size(2 * sizeof(double)))) double vec_double;
+
+volatile vec_double vd;
+volatile vec_float vf;
+
+void test_float(void) {
+  vf = __builtin_vsx_xvsqrtsp(vf);
+  // CHECK-LABEL: try-xvsqrtsp
+  // CHECK-UNCONSTRAINED: @llvm.sqrt.v4f32(<4 x float> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.sqrt.v4f32(<4 x float> %{{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-ASM: xvsqrtsp
+
+  vd = __builtin_vsx_xvsqrtdp(vd);
+  // CHECK-LABEL: try-xvsqrtdp
+  // CHECK-UNCONSTRAINED: @llvm.sqrt.v2f64(<2 x double> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.sqrt.v2f64(<2 x double> %{{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-ASM: xvsqrtdp
+
+  vf = __builtin_vsx_xvrspim(vf);
+  // CHECK-LABEL: try-xvrspim
+  // CHECK-UNCONSTRAINED: @llvm.floor.v4f32(<4 x float> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.floor.v4f32(<4 x float> %{{.*}}, metadata !"fpexcept.strict")
+  // CHECK-ASM: xvrspim
+
+  vd = __builtin_vsx_xvrdpim(vd);
+  // CHECK-LABEL: try-xvrdpim
+  // CHECK-UNCONSTRAINED: @llvm.floor.v2f64(<2 x double> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.floor.v2f64(<2 x double> %{{.*}}, metadata !"fpexcept.strict")
+  // CHECK-ASM: xvrdpim
+
+  vf = __builtin_vsx_xvrspi(vf);
+  // CHECK-LABEL: try-xvrspi
+  // CHECK-UNCONSTRAINED: @llvm.round.v4f32(<4 x float> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.round.v4f32(<4 x float> %{{.*}}, metadata !"fpexcept.strict")
+  // CHECK-ASM: xvrspi
+
+  vd = __builtin_vsx_xvrdpi(vd);
+  // CHECK-LABEL: try-xvrdpi
+  // CHECK-UNCONSTRAINED: @llvm.round.v2f64(<2 x double> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.round.v2f64(<2 x double> %{{.*}}, metadata !"fpexcept.strict")
+  // CHECK-ASM: xvrdpi
+
+  vf = __builtin_vsx_xvrspic(vf);
+  // CHECK-LABEL: try-xvrspic
+  // CHECK-UNCONSTRAINED: @llvm.nearbyint.v4f32(<4 x float> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.nearbyint.v4f32(<4 x float> %{{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // NO-FIXME-CHECK: xvrspic
+  // FIXME-CHECK: bl nearbyintf
+  // FIXME-CHECK: bl nearbyintf
+  // FIXME-CHECK: bl nearbyintf
+  // FIXME-CHECK: bl nearbyintf
+
+  vd = __builtin_vsx_xvrdpic(vd);
+  // CHECK-LABEL: try-xvrdpic
+  // CHECK-UNCONSTRAINED: @llvm.nearbyint.v2f64(<2 x double> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.nearbyint.v2f64(<2 x double> %{{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // NO-FIXME-CHECK: xvrdpic
+  // FIXME-CHECK: bl nearbyint
+  // FIXME-CHECK: bl nearbyint
+
+  vf = __builtin_vsx_xvrspip(vf);
+  // CHECK-LABEL: try-xvrspip
+  // CHECK-UNCONSTRAINED: @llvm.ceil.v4f32(<4 x float> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.ceil.v4f32(<4 x float> %{{.*}}, metadata !"fpexcept.strict")
+  // CHECK-ASM: xvrspip
+
+  vd = __builtin_vsx_xvrdpip(vd);
+  // CHECK-LABEL: try-xvrdpip
+  // CHECK-UNCONSTRAINED: @llvm.ceil.v2f64(<2 x double> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.ceil.v2f64(<2 x double> %{{.*}}, metadata !"fpexcept.strict")
+  // CHECK-ASM: xvrdpip
+
+  vf = __builtin_vsx_xvrspiz(vf);
+  // CHECK-LABEL: try-xvrspiz
+  // CHECK-UNCONSTRAINED: @llvm.trunc.v4f32(<4 x float> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.trunc.v4f32(<4 x float> %{{.*}}, metadata !"fpexcept.strict")
+  // CHECK-ASM: xvrspiz
+
+  vd = __builtin_vsx_xvrdpiz(vd);
+  // CHECK-LABEL: try-xvrdpiz
+  // CHECK-UNCONSTRAINED: @llvm.trunc.v2f64(<2 x double> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.trunc.v2f64(<2 x double> %{{.*}}, metadata !"fpexcept.strict")
+  // CHECK-ASM: xvrdpiz
+
+  vf = __builtin_vsx_xvmaddasp(vf, vf, vf);
+  // CHECK-LABEL: try-xvmaddasp
+  // CHECK-UNCONSTRAINED: @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-ASM: xvmaddasp
+
+  vd = __builtin_vsx_xvmaddadp(vd, vd, vd);
+  // CHECK-LABEL: try-xvmaddadp
+  // CHECK-UNCONSTRAINED: @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-ASM: xvmaddadp
+
+  vf = __builtin_vsx_xvnmaddasp(vf, vf, vf);
+  // CHECK-LABEL: try-xvnmaddasp
+  // CHECK-UNCONSTRAINED: [[RESULT:%[^ ]+]] = call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}})
+  // CHECK-UNCONSTRAINED: fneg <4 x float> [[RESULT]]
+  // CHECK-CONSTRAINED: [[RESULT:%[^ ]+]] = call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-CONSTRAINED: fneg <4 x float> [[RESULT]]
+  // NOT-FIXME-CHECK: xvnmaddasp
+  // FIXME-CHECK: xvmaddasp
+  // FIXME-CHECK: xvnegsp
+
+  vd = __builtin_vsx_xvnmaddadp(vd, vd, vd);
+  // CHECK-LABEL: try-xvnmaddadp
+  // CHECK-UNCONSTRAINED: [[RESULT:%[^ ]+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
+  // CHECK-UNCONSTRAINED: fneg <2 x double> [[RESULT]]
+  // CHECK-CONSTRAINED: [[RESULT:%[^ ]+]] = call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-CONSTRAINED: fneg <2 x double> [[RESULT]]
+  // CHECK-ASM: xvnmaddadp
+
+  vf = __builtin_vsx_xvmsubasp(vf, vf, vf);
+  // CHECK-LABEL: try-xvmsubasp
+  // CHECK-UNCONSTRAINED: [[RESULT:%[^ ]+]] = fneg <4 x float> %{{.*}}
+  // CHECK-UNCONSTRAINED: @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[RESULT]])
+  // CHECK-CONSTRAINED: [[RESULT:%[^ ]+]] = fneg <4 x float> %{{.*}}
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[RESULT]], metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-ASM: xvmsubasp
+
+  vd = __builtin_vsx_xvmsubadp(vd, vd, vd);
+  // CHECK-LABEL: try-xvmsubadp
+  // CHECK-UNCONSTRAINED: [[RESULT:%[^ ]+]] = fneg <2 x double> %{{.*}}
+  // CHECK-UNCONSTRAINED: @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[RESULT]])
+  // CHECK-CONSTRAINED: [[RESULT:%[^ ]+]] = fneg <2 x double> %{{.*}}
+  // CHECK-CONSTRAINED: @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[RESULT]], metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-ASM:  xvmsubadp
+
+  vf = __builtin_vsx_xvnmsubasp(vf, vf, vf);
+  // CHECK-LABEL: try-xvnmsubasp
+  // CHECK-UNCONSTRAINED: [[RESULT0:%[^ ]+]] = fneg <4 x float> %{{.*}}
+  // CHECK-UNCONSTRAINED: [[RESULT1:%[^ ]+]] = call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[RESULT0]])
+  // CHECK-UNCONSTRAINED: fneg <4 x float> [[RESULT1]]
+  // CHECK-CONSTRAINED: [[RESULT0:%[^ ]+]] = fneg <4 x float> %{{.*}}
+  // CHECK-CONSTRAINED: [[RESULT1:%[^ ]+]] = call <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[RESULT0]], metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-CONSTRAINED: fneg <4 x float> [[RESULT1]]
+  // CHECK-ASM: xvnmsubasp
+
+  vd = __builtin_vsx_xvnmsubadp(vd, vd, vd);
+  // CHECK-LABEL: try-xvnmsubadp
+  // CHECK-UNCONSTRAINED: [[RESULT0:%[^ ]+]] = fneg <2 x double> %{{.*}}
+  // CHECK-UNCONSTRAINED: [[RESULT1:%[^ ]+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[RESULT0]])
+  // CHECK-UNCONSTRAINED: fneg <2 x double> [[RESULT1]]
+  // CHECK-CONSTRAINED: [[RESULT0:%[^ ]+]] = fneg <2 x double> %{{.*}}
+  // CHECK-CONSTRAINED: [[RESULT1:%[^ ]+]] = call <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[RESULT0]], metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // CHECK-CONSTRAINED: fneg <2 x double> [[RESULT1]]
+  // CHECK-ASM: xvnmsubadp
+}