[PowerPC] swdiv builtins for XL compatibility

[quinnp]

Summary

This patch is in a series of patches to provide builtins for compatibility with
the XL compiler. This patch implements the software divide builtin as
wrappers for a floating point divide. XL provided these builtins because it
didn't produce software estimates by default at -Ofast. When compiled
with -Ofast these builtins will produce the software estimate for divide.

[quinnp]

Fixing a failing test case.

[efriedma]

llvm/test/CodeGen/PowerPC/LowerCheckedFPArith.ll

36 ↗

(On Diff #362400)

A "fast" fdiv never produces NaN, per LangRef. Using fcmp like this is fragile at best.

(Maybe you want "fdiv arcp"?)

[NeHuang]

llvm/test/CodeGen/PowerPC/O3-pipeline.ll

211 ↗

(On Diff #362400)

unrelated change?

llvm/test/CodeGen/PowerPC/int-ppc-ftdivdp.ll

7 ↗

(On Diff #362400)

nit: pwr7 for aix run lines

8 ↗

(On Diff #362400)

can we also add a run line for 64 bit AIX?

[quinnp]

Addressing review comments.

[quinnp]

llvm/test/CodeGen/PowerPC/LowerCheckedFPArith.ll

36 ↗

(On Diff #362400)

Thank you, I see what you mean. I have changed it to emit a fdiv ninf arcp instead of a fdiv fast. I included the ninf flag because without it the compiler doesn't produce the software div estimate.

[efriedma]

llvm/test/CodeGen/PowerPC/LowerCheckedFPArith.ll

36 ↗

(On Diff #362400)

ninf is also an issue, although maybe less likely to bite in practice. Consider what happens if someone passes infinity to swdivs: the fdiv reduces to poison, so the branch is undefined behavior.

[amyk]

llvm/include/llvm/IR/IntrinsicsPowerPC.td

1436 ↗

(On Diff #363189)

Line too long?

1724 ↗

(On Diff #363189)

Minor indentation nit.

1727 ↗

(On Diff #363189)

Minor indentation nit.

llvm/lib/Target/PowerPC/PPCTargetMachine.cpp

451 ↗

(On Diff #363189)

Nit: Add a comment before creating the pass as the other pass calls also follow a comment.

[NeHuang]

clang/test/CodeGen/builtins-ppc-xlcompat-swdiv.c

18

nit: alignment with CHECKs below. Same for the other test cases.

llvm/lib/Target/PowerPC/PPCTargetMachine.cpp

452 ↗

(On Diff #363189)

+1,

[quinnp]

Updating the patch to emit a fdiv for each of the builtins without any fast math flags. This will be safe and will still emit a software estimate when -Ofast is used.

llvm/test/CodeGen/PowerPC/LowerCheckedFPArith.ll

36 ↗

(On Diff #362400)

We've decided to emit an fdiv without any fast math flags for these builtins. This will be safe and will emit the software estimate for -Ofast.

[NeHuang]

Do we already have a backend test case for fdiv emitting a software estimate when -Ofast is used?

[quinnp]

Added a backend testcase which goes from fdiv fast to software estimate. Added a runline in the front end testcase that sets the fast math flags.

[quinnp]

In D106959#3021069, @NeHuang wrote:

Do we already have a backend test case for fdiv emitting a software estimate when -Ofast is used?

I've added a testcase in llvm/test/CodeGen/PowerPC/fdiv.ll which goes from fdiv fast to the assembly for the software divide estimate.

[nemanjai]

LGTM. Please note in the commit message that this is simply a wrapper for a floating point divide. XL provided this builtin because it doesn't produce software estimates by default at -Ofast.

[quinnp]

Fixing failing test case after rebasing with https://reviews.llvm.org/D110213.

clang/include/clang/Basic/BuiltinsPPC.def

 BUILTIN(__builtin_ppc_swdivs_nochk, "fff", "")
 BUILTIN(__builtin_ppc_alignx, "vIivC*", "nc")
 BUILTIN(__builtin_ppc_rdlam, "UWiUWiUWiUWIi", "nc")
 BUILTIN(__builtin_ppc_compare_exp_uo, "idd", "")
 BUILTIN(__builtin_ppc_compare_exp_lt, "idd", "")
 BUILTIN(__builtin_ppc_compare_exp_gt, "idd", "")
 BUILTIN(__builtin_ppc_compare_exp_eq, "idd", "")
 BUILTIN(__builtin_ppc_test_data_class, "idIi", "t")
+BUILTIN(__builtin_ppc_swdiv, "ddd", "")
+BUILTIN(__builtin_ppc_swdivs, "fff", "")
 // Compare
 BUILTIN(__builtin_ppc_cmpeqb, "LLiLLiLLi", "")
 BUILTIN(__builtin_ppc_cmprb, "iCIiii", "")
 BUILTIN(__builtin_ppc_setb, "LLiLLiLLi", "")
 BUILTIN(__builtin_ppc_cmpb, "LLiLLiLLi", "")
 // Multiply
 BUILTIN(__builtin_ppc_mulhd, "LLiLiLi", "")
 BUILTIN(__builtin_ppc_mulhdu, "ULLiULiULi", "")

clang/lib/Basic/Targets/PPC.cpp

static void defineXLCompatMacros(MacroBuilder &Builder) {
   Builder.defineMacro("__fsqrts", "__builtin_ppc_fsqrts");
   Builder.defineMacro("__addex", "__builtin_ppc_addex");
   Builder.defineMacro("__cmplxl", "__builtin_complex");
   Builder.defineMacro("__compare_exp_uo", "__builtin_ppc_compare_exp_uo");
   Builder.defineMacro("__compare_exp_lt", "__builtin_ppc_compare_exp_lt");
   Builder.defineMacro("__compare_exp_gt", "__builtin_ppc_compare_exp_gt");
   Builder.defineMacro("__compare_exp_eq", "__builtin_ppc_compare_exp_eq");
   Builder.defineMacro("__test_data_class", "__builtin_ppc_test_data_class");
+  Builder.defineMacro("__swdiv", "__builtin_ppc_swdiv");
+  Builder.defineMacro("__swdivs", "__builtin_ppc_swdivs");
 }
 
 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
 /// #defines that are not tied to a specific subtarget.
 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
                                      MacroBuilder &Builder) const {
 
   // We define the XLC compatibility macros only on AIX and Linux since XLC

clang/lib/CodeGen/CGBuiltin.cpp

return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(
                            Intrinsic::experimental_constrained_trunc))
         .getScalarVal();
   case PPC::BI__builtin_ppc_fsqrt:
   case PPC::BI__builtin_ppc_fsqrts:
     return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(
                            *this, E, Intrinsic::sqrt,
                            Intrinsic::experimental_constrained_sqrt))
         .getScalarVal();
-  case PPC::BI__builtin_ppc_test_data_class:
+  case PPC::BI__builtin_ppc_test_data_class: {
     llvm::Type *ArgType = EmitScalarExpr(E->getArg(0))->getType();
     unsigned IntrinsicID;
     if (ArgType->isDoubleTy())
       IntrinsicID = Intrinsic::ppc_test_data_class_d;
     else if (ArgType->isFloatTy())
       IntrinsicID = Intrinsic::ppc_test_data_class_f;
     else
       llvm_unreachable("Invalid Argument Type");
     return Builder.CreateCall(CGM.getIntrinsic(IntrinsicID), Ops,
                               "test_data_class");
   }
+  case PPC::BI__builtin_ppc_swdiv:
+  case PPC::BI__builtin_ppc_swdivs:
+    return Builder.CreateFDiv(Ops[0], Ops[1], "swdiv");
+  }
 }
 
 namespace {
 // If \p E is not null pointer, insert address space cast to match return
 // type of \p E if necessary.
 Value *EmitAMDGPUDispatchPtr(CodeGenFunction &CGF,
                              const CallExpr *E = nullptr) {
   auto *F = CGF.CGM.getIntrinsic(Intrinsic::amdgcn_dispatch_ptr);

clang/test/CodeGen/builtins-ppc-xlcompat-swdiv.c

+// REQUIRES: powerpc-registered-target
+// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu \
+// RUN:   -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s
+// RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu \
+// RUN:   -emit-llvm %s -o - -target-cpu pwr8 | FileCheck %s
+// RUN: %clang_cc1 -triple powerpc64-unknown-aix \
+// RUN:   -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s
+// RUN: %clang_cc1 -triple powerpc-unknown-aix \
+// RUN:   -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s
+// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -ffast-math -ffp-contract=fast \
+// RUN:   -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s --check-prefix CHECK-OFAST
+
+extern double a;
+extern double b;
+extern float c;
+extern float d;
+
+// CHECK-LABEL:   @test_swdiv(
+// CHECK:         [[TMP0:%.*]] = load double, double* @a
+// CHECK-NEXT:    [[TMP1:%.*]] = load double, double* @b
+// CHECK-NEXT:    [[SWDIV:%.*]] = fdiv double [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    ret double [[SWDIV]]
+//
+// CHECK-OFAST-LABEL:   @test_swdiv(
+// CHECK-OFAST:         [[TMP0:%.*]] = load double, double* @a
+// CHECK-OFAST-NEXT:    [[TMP1:%.*]] = load double, double* @b
+// CHECK-OFAST-NEXT:    [[SWDIV:%.*]] = fdiv fast double [[TMP0]], [[TMP1]]
+// CHECK-OFAST-NEXT:    ret double [[SWDIV]]
+//
+double test_swdiv() {
+  return __swdiv(a, b);
+}
+
+// CHECK-LABEL:   @test_swdivs(
+// CHECK:         [[TMP0:%.*]] = load float, float* @c
+// CHECK-NEXT:    [[TMP1:%.*]] = load float, float* @d
+// CHECK-NEXT:    [[SWDIVS:%.*]] = fdiv float [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    ret float [[SWDIVS]]
+//
+// CHECK-OFAST-LABEL:   @test_swdivs(
+// CHECK-OFAST:         [[TMP0:%.*]] = load float, float* @c
+// CHECK-OFAST-NEXT:    [[TMP1:%.*]] = load float, float* @d
+// CHECK-OFAST-NEXT:    [[SWDIVS:%.*]] = fdiv fast float [[TMP0]], [[TMP1]]
+// CHECK-OFAST-NEXT:    ret float [[SWDIVS]]
+//
+float test_swdivs() {
+  return __swdivs(c, d);
+}
+
+// CHECK-LABEL:   @test_builtin_ppc_swdiv(
+// CHECK:         [[TMP0:%.*]] = load double, double* @a
+// CHECK-NEXT:    [[TMP1:%.*]] = load double, double* @b
+// CHECK-NEXT:    [[SWDIV:%.*]] = fdiv double [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    ret double [[SWDIV]]
+//
+// CHECK-OFAST-LABEL:   @test_builtin_ppc_swdiv(
+// CHECK-OFAST:         [[TMP0:%.*]] = load double, double* @a
+// CHECK-OFAST-NEXT:    [[TMP1:%.*]] = load double, double* @b
+// CHECK-OFAST-NEXT:    [[SWDIV:%.*]] = fdiv fast double [[TMP0]], [[TMP1]]
+// CHECK-OFAST-NEXT:    ret double [[SWDIV]]
+//
+double test_builtin_ppc_swdiv() {
+  return __builtin_ppc_swdiv(a, b);
+}
+
+// CHECK-LABEL:   @test_builtin_ppc_swdivs(
+// CHECK:         [[TMP0:%.*]] = load float, float* @c
+// CHECK-NEXT:    [[TMP1:%.*]] = load float, float* @d
+// CHECK-NEXT:    [[SWDIVS:%.*]] = fdiv float [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    ret float [[SWDIVS]]
+//
+// CHECK-OFAST-LABEL:   @test_builtin_ppc_swdivs(
+// CHECK-OFAST:         [[TMP0:%.*]] = load float, float* @c
+// CHECK-OFAST-NEXT:    [[TMP1:%.*]] = load float, float* @d
+// CHECK-OFAST-NEXT:    [[SWDIVS:%.*]] = fdiv fast float [[TMP0]], [[TMP1]]
+// CHECK-OFAST-NEXT:    ret float [[SWDIVS]]
+//
+float test_builtin_ppc_swdivs() {
+  return __builtin_ppc_swdivs(c, d);
+}

llvm/test/CodeGen/PowerPC/fdiv.ll

 ; CHECK-NEXT:    xsmulsp 0, 1, 3
 ; CHECK-NEXT:    xsnmsubasp 1, 2, 0
 ; CHECK-NEXT:    xsmaddasp 0, 3, 1
 ; CHECK-NEXT:    fmr 1, 0
 ; CHECK-NEXT:    blr
   %3 = fdiv contract reassoc arcp nsz ninf float %0, %1
   ret float %3
 }
+
+define dso_local float @fdiv_fast(float %0, float %1) local_unnamed_addr {
+; CHECK-LABEL: fdiv_fast:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xsresp 3, 2
+; CHECK-NEXT:    xsmulsp 0, 1, 3
+; CHECK-NEXT:    xsnmsubasp 1, 2, 0
+; CHECK-NEXT:    xsmaddasp 0, 3, 1
+; CHECK-NEXT:    fmr 1, 0
+; CHECK-NEXT:    blr
+  %3 = fdiv fast float %0, %1
+  ret float %3
+}