[PowerPC] Fix the check for scalar MASS conversion

[masoud.ataei]

Summary

Proposing to move the check for scalar MASS conversion from constructor
of PPCTargetLowering to the lowerLibCallBase function which decides
about the lowering.

The Target machine option Options.PPCGenScalarMASSEntries is set in
PPCTargetMachine.cpp. But an object of the class PPCTargetLowering
is created in one of the included header files. So, the constructor will run
before setting PPCGenScalarMASSEntries to correct value. So, we cannot
check this option in the constructor.

[bmahjour]

The description should explain why this change is necessary.

clang/test/CodeGen/lower-mass-end-to-end.c

2

Please add negative end-to-end tests as well (eg. when -enable-ppc-gen-scalar-mass is false or when -fno-approx-func).

[masoud.ataei]

Add more tests.

[bmahjour]

clang/test/CodeGen/lower-mass-end-to-end.c

33–34

Please also check for

CHECK-NOMASS-FAST-NOT: xl_sin
CHECK-NOMASS-AFN-NOT: xl_sin_finit

and do the same for other tests.

[masoud.ataei]

Test updated.

[bmahjour]

clang/test/CodeGen/lower-mass-end-to-end.c

34

I don't think this works the way you expect it:

> cat input.txt
; CHECK-NOT: __xl_sin{{_finite}}
> echo "__xl_sin" | ./bin/FileCheck ./input.txt
>

this seems closer to what you want:

; CHECK-NOT: {{__xl_sin|__xl_sin_finite}}

[masoud.ataei]

Update the test

[bmahjour]

LGTM. Thanks!

[dyung]

Hi @masoud.ataei, the test you added in this commit is failing on the PS4 bot, can you take a look?

https://lab.llvm.org/buildbot/#/builders/139/builds/24469

clang (LLVM option parsing): Unknown command line argument '-enable-ppc-gen-scalar-mass'.  Try: 'clang (LLVM option parsing) --help'
clang (LLVM option parsing): Did you mean '--enable-x86-scalar-amx'?

[masoud.ataei]

Just took it down temporarily. -- Looking at it...

[lenary]

You likely need // REQUIRES: powerpc-registered-target in the top of the test, as -enable-ppc-gen-scalar-mass is only present if the PowerPC target has been compiled into LLVM.

[masoud.ataei]

In D128653#3633704, @lenary wrote:

You likely need // REQUIRES: powerpc-registered-target in the top of the test, as -enable-ppc-gen-scalar-mass is only present if the PowerPC target has been compiled into LLVM.

Thanks, I was looking for that. -- re-committing...

clang/test/CodeGen/lower-mass-end-to-end.c

+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -O3 -fapprox-func --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-MASS-AFN
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -Ofast --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-MASS-FAST
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -O3 -fapprox-func --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-MASS-AFN
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -Ofast --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-MASS-FAST
+
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass=false -O3 -fapprox-func --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-NOMASS-AFN
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass=false -Ofast --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-NOMASS-FAST
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass=false -O3 -fapprox-func --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-NOMASS-AFN
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass=false -Ofast --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-NOMASS-FAST
+
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -O3 -fno-approx-func --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-NOMASS-AFN
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -fno-fast-math --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-NOMASS-FAST
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -O3 -fno-approx-func --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-NOMASS-AFN
+// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -fno-fast-math --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-NOMASS-FAST
+
+extern double sin(double a);
+extern double cos(double a);
+extern double pow(double a, double b);
+extern double log(double a);
+extern double log10(double a);
+extern double exp(double a);
+extern float sinf(float a);
+extern float cosf(float a);
+extern float powf(float a, float b);
+extern float logf(float a);
+extern float log10f(float a);
+extern float expf(float a);
+
+double sin_f64(double a) {
+// CHECK-LABEL: sin_f64
+// CHECK-MASS-FAST: __xl_sin_finite
+// CHECK-MASS-AFN: __xl_sin
+// CHECK-NOMASS-FAST-NOT: __xl_sin_finite
+// CHECK-NOMASS-AFN-NOT: __xl_sin
+// CHECK: blr
+  return sin(a);
+}
+
+double cos_f64(double a) {
+// CHECK-LABEL: cos_f64
+// CHECK-MASS-FAST: __xl_cos_finite
+// CHECK-MASS-AFN: __xl_cos
+// CHECK-NOMASS-FAST-NOT: __xl_cos_finite
+// CHECK-NOMASS-AFN-NOT: __xl_cos
+// CHECK: blr
+  return cos(a);
+}
+
+double pow_f64(double a, double b) {
+// CHECK-LABEL: pow_f64
+// CHECK-MASS-FAST: __xl_pow_finite
+// CHECK-MASS-AFN: __xl_pow
+// CHECK-NOMASS-FAST-NOT: __xl_pow_finite
+// CHECK-NOMASS-AFN-NOT: __xl_pow
+// CHECK: blr
+  return pow(a, b);
+}
+
+double log_f64(double a) {
+// CHECK-LABEL: log_f64
+// CHECK-MASS-FAST: __xl_log_finite
+// CHECK-MASS-AFN: __xl_log
+// CHECK-NOMASS-FAST-NOT: __xl_log_finite
+// CHECK-NOMASS-AFN-NOT: __xl_log
+// CHECK: blr
+  return log(a);
+}
+
+double log10_f64(double a) {
+// CHECK-LABEL: log10_f64
+// CHECK-MASS-FAST: __xl_log10_finite
+// CHECK-MASS-AFN: __xl_log10
+// CHECK-NOMASS-FAST-NOT: __xl_log10_finite
+// CHECK-NOMASS-AFN-NOT: __xl_log10
+// CHECK: blr
+  return log10(a);
+}
+
+double exp_f64(double a) {
+// CHECK-LABEL: exp_f64
+// CHECK-MASS-FAST: __xl_exp_finite
+// CHECK-MASS-AFN: __xl_exp
+// CHECK-NOMASS-FAST-NOT: __xl_exp_finite
+// CHECK-NOMASS-AFN-NOT: __xl_exp
+// CHECK: blr
+  return exp(a);
+}
+
+float sin_f32(float a) {
+// CHECK-LABEL: sin_f32
+// CHECK-MASS-FAST: __xl_sinf_finite
+// CHECK-MASS-AFN: __xl_sinf
+// CHECK-NOMASS-FAST-NOT: __xl_sinf_finite
+// CHECK-NOMASS-AFN-NOT: __xl_sinf
+// CHECK: blr
+  return sinf(a);
+}
+
+float cos_f32(float a) {
+// CHECK-LABEL: cos_f32
+// CHECK-MASS-FAST: __xl_cosf_finite
+// CHECK-MASS-AFN: __xl_cosf
+// CHECK-NOMASS-FAST-NOT: __xl_cosf_finite
+// CHECK-NOMASS-AFN-NOT: __xl_cosf
+// CHECK: blr
+  return cosf(a);
+}
+
+float pow_f32(float a, float b) {
+// CHECK-LABEL: pow_f32
+// CHECK-MASS-FAST: __xl_powf_finite
+// CHECK-MASS-AFN: __xl_powf
+// CHECK-NOMASS-FAST-NOT: __xl_powf_finite
+// CHECK-NOMASS-AFN-NOT: __xl_powf
+// CHECK: blr
+  return powf(a, b);
+}
+
+float log_f32(float a) {
+// CHECK-LABEL: log_f32
+// CHECK-MASS-FAST: __xl_logf_finite
+// CHECK-MASS-AFN: __xl_logf
+// CHECK-NOMASS-FAST-NOT: __xl_logf_finite
+// CHECK-NOMASS-AFN-NOT: __xl_logf
+// CHECK: blr
+  return logf(a);
+}
+
+float log10_f32(float a) {
+// CHECK-LABEL: log10_f32
+// CHECK-MASS-FAST: __xl_log10f_finite
+// CHECK-MASS-AFN: __xl_log10f
+// CHECK-NOMASS-FAST-NOT: __xl_log10f_finite
+// CHECK-NOMASS-AFN-NOT: __xl_log10f
+// CHECK: blr
+  return log10f(a);
+}
+
+float exp_f32(float a) {
+// CHECK-LABEL: exp_f32
+// CHECK-MASS-FAST: __xl_expf_finite
+// CHECK-MASS-AFN: __xl_expf
+// CHECK-NOMASS-FAST-NOT: __xl_expf_finite
+// CHECK-NOMASS-AFN-NOT: __xl_expf
+// CHECK: blr
+  return expf(a);
+}

llvm/lib/Target/PowerPC/PPCISelLowering.h

private:
     SDValue LowerATOMIC_CMP_SWAP(SDValue Op, SelectionDAG &DAG) const;
     SDValue lowerToLibCall(const char *LibCallName, SDValue Op,
                            SelectionDAG &DAG) const;
     SDValue lowerLibCallBasedOnType(const char *LibCallFloatName,
                                     const char *LibCallDoubleName, SDValue Op,
                                     SelectionDAG &DAG) const;
     bool isLowringToMASSFiniteSafe(SDValue Op) const;
     bool isLowringToMASSSafe(SDValue Op) const;
+    bool isScalarMASSConversionEnabled() const;
     SDValue lowerLibCallBase(const char *LibCallDoubleName,
                              const char *LibCallFloatName,
                              const char *LibCallDoubleNameFinite,
                              const char *LibCallFloatNameFinite, SDValue Op,
                              SelectionDAG &DAG) const;
     SDValue lowerPow(SDValue Op, SelectionDAG &DAG) const;
     SDValue lowerSin(SDValue Op, SelectionDAG &DAG) const;
     SDValue lowerCos(SDValue Op, SelectionDAG &DAG) const;

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

PPCTargetLowering::PPCTargetLowering(const PPCTargetMachine &TM,
   setOperationAction(ISD::FSIN , MVT::f32, Expand);
   setOperationAction(ISD::FCOS , MVT::f32, Expand);
   setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
   setOperationAction(ISD::FREM , MVT::f32, Expand);
   setOperationAction(ISD::FPOW , MVT::f32, Expand);
 
   // MASS transformation for LLVM intrinsics with replicating fast-math flag
   // to be consistent to PPCGenScalarMASSEntries pass
-  if (TM.getOptLevel() == CodeGenOpt::Aggressive &&
-      TM.Options.PPCGenScalarMASSEntries) {
+  if (TM.getOptLevel() == CodeGenOpt::Aggressive) {
     setOperationAction(ISD::FSIN , MVT::f64, Custom);
     setOperationAction(ISD::FCOS , MVT::f64, Custom);
     setOperationAction(ISD::FPOW , MVT::f64, Custom);
     setOperationAction(ISD::FLOG, MVT::f64, Custom);
     setOperationAction(ISD::FLOG10, MVT::f64, Custom);
     setOperationAction(ISD::FEXP, MVT::f64, Custom);
     setOperationAction(ISD::FSIN , MVT::f32, Custom);
     setOperationAction(ISD::FCOS , MVT::f32, Custom);
bool PPCTargetLowering::isLowringToMASSFiniteSafe(SDValue Op) const {
   return isLowringToMASSSafe(Op) && Flags.hasNoSignedZeros() &&
          Flags.hasNoNaNs() && Flags.hasNoInfs();
 }
 
 bool PPCTargetLowering::isLowringToMASSSafe(SDValue Op) const {
   return Op.getNode()->getFlags().hasApproximateFuncs();
 }
 
+bool PPCTargetLowering::isScalarMASSConversionEnabled() const {
+  return getTargetMachine().Options.PPCGenScalarMASSEntries;
+}
+
 SDValue PPCTargetLowering::lowerLibCallBase(const char *LibCallDoubleName,
                                             const char *LibCallFloatName,
                                             const char *LibCallDoubleNameFinite,
                                             const char *LibCallFloatNameFinite,
                                             SDValue Op,
                                             SelectionDAG &DAG) const {
-  if (!isLowringToMASSSafe(Op))
+  if (!isScalarMASSConversionEnabled() || !isLowringToMASSSafe(Op))
     return SDValue();
 
   if (!isLowringToMASSFiniteSafe(Op))
     return lowerLibCallBasedOnType(LibCallFloatName, LibCallDoubleName, Op,
                                    DAG);
 
   return lowerLibCallBasedOnType(LibCallFloatNameFinite,
                                  LibCallDoubleNameFinite, Op, DAG);