[PowerPC] Support test data class intrinsic of 128-bit float

[qiucf]

Summary

We've exploited test data class instructions for f32 f64 v2f64` and v4f32. This patch unifies the LLVM intrinsic into the same ppc_test_data_class and add support for 128-bit precision float values using xststdcqp.

Vector versions of the intrinsic can't be unified because they return vector int instead of int.

[shchenz]

The error message needs to be updated too:

def err_ppc_invalid_test_data_class_type : Error<
  "expected a 'float' or 'double' for the first argument">;

And can we add a test case for ibm float128 in the clang?

[qiucf]

Change error message regarding __float128.

[shchenz]

LGTM. Thanks.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_ppc_builtin_requires_vsx : Error<
   "this builtin requires VSX to be enabled">;
 def err_ppc_builtin_requires_htm : Error<
   "this builtin requires HTM to be enabled">;
 def err_ppc_builtin_requires_abi : Error<
   "this builtin requires ABI -mabi=%0">;
 def err_ppc_invalid_use_mma_type : Error<
   "invalid use of PPC MMA type">;
 def err_ppc_invalid_test_data_class_type : Error<
-  "expected a 'float' or 'double' for the first argument">;
+  "expected a 'float', 'double' or '__float128' for the first argument">;
 def err_x86_builtin_invalid_rounding : Error<
   "invalid rounding argument">;
 def err_x86_builtin_invalid_scale : Error<
   "scale argument must be 1, 2, 4, or 8">;
 def err_x86_builtin_tile_arg_duplicate : Error<
   "tile arguments must refer to different tiles">;
 
 def err_builtin_target_unsupported : Error<

clang/lib/CodeGen/CGBuiltin.cpp

#include "clang/Basic/BuiltinsPPC.def"
   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: {
     Value *Op0 = EmitScalarExpr(E->getArg(0));
     Value *Op1 = EmitScalarExpr(E->getArg(1));
-    llvm::Type *ArgType = Op0->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), {Op0, Op1},
-                              "test_data_class");
+    return Builder.CreateCall(
+        CGM.getIntrinsic(Intrinsic::ppc_test_data_class, Op0->getType()),
+        {Op0, Op1}, "test_data_class");
   }
   case PPC::BI__builtin_ppc_maxfe: {
     Value *Op0 = EmitScalarExpr(E->getArg(0));
     Value *Op1 = EmitScalarExpr(E->getArg(1));
     Value *Op2 = EmitScalarExpr(E->getArg(2));
     Value *Op3 = EmitScalarExpr(E->getArg(3));
     return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::ppc_maxfe),
                               {Op0, Op1, Op2, Op3});

clang/lib/Sema/SemaChecking.cpp

bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
   case PPC::BI__builtin_ppc_compare_exp_gt:
   case PPC::BI__builtin_ppc_compare_exp_eq:
     return SemaFeatureCheck(*this, TheCall, "isa-v30-instructions",
                             diag::err_ppc_builtin_only_on_arch, "9") ||
            SemaFeatureCheck(*this, TheCall, "vsx",
                             diag::err_ppc_builtin_requires_vsx);
   case PPC::BI__builtin_ppc_test_data_class: {
     // Check if the first argument of the __builtin_ppc_test_data_class call is
-    // valid. The argument must be either a 'float' or a 'double'.
+    // valid. The argument must be 'float' or 'double' or '__float128'.
     QualType ArgType = TheCall->getArg(0)->getType();
     if (ArgType != QualType(Context.FloatTy) &&
-        ArgType != QualType(Context.DoubleTy))
+        ArgType != QualType(Context.DoubleTy) &&
+        ArgType != QualType(Context.Float128Ty))
       return Diag(TheCall->getBeginLoc(),
                   diag::err_ppc_invalid_test_data_class_type);
     return SemaFeatureCheck(*this, TheCall, "isa-v30-instructions",
                             diag::err_ppc_builtin_only_on_arch, "9") ||
            SemaFeatureCheck(*this, TheCall, "vsx",
                             diag::err_ppc_builtin_requires_vsx) ||
            SemaBuiltinConstantArgRange(TheCall, 1, 0, 127);
   }

clang/test/CodeGen/PowerPC/builtins-ppc-p9-f128.c

 }
 
 unsigned long long int extract_exp(void) {
   return __builtin_vsx_scalar_extract_expq(A);
 // CHECK: @llvm.ppc.scalar.extract.expq(fp128
 // CHECK-NEXT: ret i64
 }
 
+int test_data_class_f128(__float128 q) {
+  return __builtin_ppc_test_data_class(q, 0);
+// CHECK-LABEL: @test_data_class_f128
+// CHECK: [[TMP:%.*]] = call i32 @llvm.ppc.test.data.class.f128(fp128 %0, i32 0)
+// CHECK-NEXT: ret i32 [[TMP]]
+}

clang/test/CodeGen/PowerPC/builtins-ppc-xlcompat-pwr9-error.c

int test_test_data_class_d() {
   return __test_data_class(d, 128); // expected-error {{argument value 128 is outside the valid range [0, 127]}}
 }
 
 int test_test_data_class_f() {
   return __test_data_class(f, 128); // expected-error {{argument value 128 is outside the valid range [0, 127]}}
 }
 
 int test_test_data_class_type() {
-  return __test_data_class(ui, 0); // expected-error {{expected a 'float' or 'double' for the first argument}}
+  return __test_data_class(ui, 0); // expected-error {{expected a 'float', 'double' or '__float128' for the first argument}}
 }

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

 // CHECK-NEXT:        ret i32 [[TMP]]
 // CHECK-NONPWR9-ERR: error: this builtin is only valid on POWER9 or later CPUs
 // CHECK-NOVSX-ERR: error: this builtin requires VSX to be enabled
   return __builtin_ppc_compare_exp_eq(d, d);
 }
 
 int test_builtin_ppc_test_data_class_d() {
 // CHECK-LABEL:       @test_builtin_ppc_test_data_class_d
-// CHECK:             [[TMP:%.*]] = call i32 @llvm.ppc.test.data.class.d(double %0, i32 0)
+// CHECK:             [[TMP:%.*]] = call i32 @llvm.ppc.test.data.class.f64(double %0, i32 0)
 // CHECK-NEXT:        ret i32 [[TMP]]
 // CHECK-NONPWR9-ERR: error: this builtin is only valid on POWER9 or later CPUs
 // CHECK-NOVSX-ERR: error: this builtin requires VSX to be enabled
   return __builtin_ppc_test_data_class(d, 0);
 }
 
 int test_builtin_ppc_test_data_class_f() {
 // CHECK-LABEL:       @test_builtin_ppc_test_data_class_f
-// CHECK:             [[TMP:%.*]] = call i32 @llvm.ppc.test.data.class.f(float %0, i32 0)
+// CHECK:             [[TMP:%.*]] = call i32 @llvm.ppc.test.data.class.f32(float %0, i32 0)
 // CHECK-NEXT:        ret i32 [[TMP]]
 // CHECK-NONPWR9-ERR: error: this builtin is only valid on POWER9 or later CPUs
 // CHECK-NOVSX-ERR: error: this builtin requires VSX to be enabled
   return __builtin_ppc_test_data_class(f, 0);
 }
 
 int test_compare_exp_uo() {
 // CHECK-LABEL:       @test_compare_exp_uo

 // CHECK-NEXT:        ret i32 [[TMP]]
 // CHECK-NONPWR9-ERR: error: this builtin is only valid on POWER9 or later CPUs
 // CHECK-NOVSX-ERR: error: this builtin requires VSX to be enabled
   return __compare_exp_eq(d, d);
 }
 
 int test_test_data_class_d() {
 // CHECK-LABEL:       @test_test_data_class_d
-// CHECK:             [[TMP:%.*]] = call i32 @llvm.ppc.test.data.class.d(double %0, i32 127)
+// CHECK:             [[TMP:%.*]] = call i32 @llvm.ppc.test.data.class.f64(double %0, i32 127)
 // CHECK-NEXT:        ret i32 [[TMP]]
 // CHECK-NONPWR9-ERR: error: this builtin is only valid on POWER9 or later CPUs
 // CHECK-NOVSX-ERR: error: this builtin requires VSX to be enabled
   return __test_data_class(d, 127);
 }
 
 int test_test_data_class_f() {
 // CHECK-LABEL:       @test_test_data_class_f
-// CHECK:             [[TMP:%.*]] = call i32 @llvm.ppc.test.data.class.f(float %0, i32 127)
+// CHECK:             [[TMP:%.*]] = call i32 @llvm.ppc.test.data.class.f32(float %0, i32 127)
 // CHECK-NEXT:        ret i32 [[TMP]]
 // CHECK-NONPWR9-ERR: error: this builtin is only valid on POWER9 or later CPUs
 // CHECK-NOVSX-ERR: error: this builtin requires VSX to be enabled
   return __test_data_class(f, 127);
 }

llvm/include/llvm/IR/IntrinsicsPowerPC.td

let TargetPrefix = "ppc" in {
   def int_ppc_compare_exp_gt : ClangBuiltin<"__builtin_ppc_compare_exp_gt">,
       DefaultAttrsIntrinsic<[llvm_i32_ty],
                             [llvm_double_ty, llvm_double_ty],
                             [IntrNoMem]>;
   def int_ppc_compare_exp_eq : ClangBuiltin<"__builtin_ppc_compare_exp_eq">,
       DefaultAttrsIntrinsic<[llvm_i32_ty], 
                             [llvm_double_ty, llvm_double_ty],
                             [IntrNoMem]>;
-  def int_ppc_test_data_class_d : DefaultAttrsIntrinsic<[llvm_i32_ty],
-                                            [llvm_double_ty, llvm_i32_ty],
-                                            [IntrNoMem, ImmArg<ArgIndex<1>>]>;
-  def int_ppc_test_data_class_f : DefaultAttrsIntrinsic<[llvm_i32_ty],
-                                            [llvm_float_ty, llvm_i32_ty],
-                                            [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+  def int_ppc_test_data_class : Intrinsic<[llvm_i32_ty],
+                                          [llvm_anyfloat_ty, llvm_i32_ty],
   def int_ppc_fnabs
       : ClangBuiltin<"__builtin_ppc_fnabs">,
         DefaultAttrsIntrinsic<[llvm_double_ty], [llvm_double_ty], [IntrNoMem]>;
   def int_ppc_fnabss
       : ClangBuiltin<"__builtin_ppc_fnabss">,
         DefaultAttrsIntrinsic<[llvm_float_ty], [llvm_float_ty], [IntrNoMem]>;
 
   def int_ppc_convert_f128_to_ppcf128

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

return SDValue(
             PPC::SELECT_CC_I4, dl, MVT::i32,
             {SDValue(DAG.getMachineNode(PPC::XSCMPEXPDP, dl, MVT::i32,
                                         Op.getOperand(1), Op.getOperand(2)),
                      0),
              DAG.getConstant(1, dl, MVT::i32), DAG.getConstant(0, dl, MVT::i32),
              DAG.getTargetConstant(Pred, dl, MVT::i32)}),
         0);
   }
-  case Intrinsic::ppc_test_data_class_d:
-  case Intrinsic::ppc_test_data_class_f: {
-    unsigned CmprOpc = PPC::XSTSTDCDP;
-    if (IntrinsicID == Intrinsic::ppc_test_data_class_f)
-      CmprOpc = PPC::XSTSTDCSP;
+  case Intrinsic::ppc_test_data_class: {
+    EVT OpVT = Op.getOperand(1).getValueType();
+    unsigned CmprOpc = OpVT == MVT::f128 ? PPC::XSTSTDCQP
+                                         : (OpVT == MVT::f64 ? PPC::XSTSTDCDP
+                                                             : PPC::XSTSTDCSP);
     return SDValue(
         DAG.getMachineNode(
             PPC::SELECT_CC_I4, dl, MVT::i32,
             {SDValue(DAG.getMachineNode(CmprOpc, dl, MVT::i32, Op.getOperand(2),
                                         Op.getOperand(1)),
                      0),
              DAG.getConstant(1, dl, MVT::i32), DAG.getConstant(0, dl, MVT::i32),
              DAG.getTargetConstant(PPC::PRED_EQ, dl, MVT::i32)}),

llvm/test/CodeGen/PowerPC/builtins-ppc-p9-f128.ll

 ; CHECK: xsxexpqp [[VECOUT:v[0-9]+]], [[VECIN]]
 ; CHECK: mfvsrd r3, [[VECOUT]]
 ; CHECK: blr
 }
 
 ; Function Attrs: nounwind readnone
 declare i64 @llvm.ppc.scalar.extract.expq(fp128)
 
+define i32 @test_data_class_f128(fp128 %d) {
+entry:
+  %test_data_class = tail call i32 @llvm.ppc.test.data.class.f128(fp128 %d, i32 0)
+  ret i32 %test_data_class
+; CHECK-LABEL: test_data_class_f128:
+; CHECK: xststdcqp cr0, v2, 0
+; CHECK-NEXT: li r3, 0
+; CHECK-NEXT: li r4, 1
+; CHECK-NEXT: iseleq r3, r4, r3
+; CHECK-NEXT: blr
+}
+
+declare i32 @llvm.ppc.test.data.class.f128(fp128, i32 immarg)

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-test.ll

 ; CHECK-LABEL: test_builtin_ppc_test_data_class_d:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xststdcdp 0, 1, 0
 ; CHECK-NEXT:    li 3, 0
 ; CHECK-NEXT:    li 4, 1
 ; CHECK-NEXT:    iseleq 3, 4, 3
 ; CHECK-NEXT:    blr
 entry:
-  %test_data_class = tail call i32 @llvm.ppc.test.data.class.d(double %d, i32 0)
+  %test_data_class = tail call i32 @llvm.ppc.test.data.class.f64(double %d, i32 0)
   ret i32 %test_data_class
 }
 
-declare i32 @llvm.ppc.test.data.class.d(double, i32 immarg)
+declare i32 @llvm.ppc.test.data.class.f64(double, i32 immarg)
 
 define i32 @test_builtin_ppc_test_data_class_f(float %f) {
 ; CHECK-LABEL: test_builtin_ppc_test_data_class_f:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xststdcsp 0, 1, 127
 ; CHECK-NEXT:    li 3, 0
 ; CHECK-NEXT:    li 4, 1
 ; CHECK-NEXT:    iseleq 3, 4, 3
 ; CHECK-NEXT:    blr
 entry:
-  %test_data_class = tail call i32 @llvm.ppc.test.data.class.f(float %f, i32 127)
+  %test_data_class = tail call i32 @llvm.ppc.test.data.class.f32(float %f, i32 127)
   ret i32 %test_data_class
 }
 
-declare i32 @llvm.ppc.test.data.class.f(float, i32 immarg)
+declare i32 @llvm.ppc.test.data.class.f32(float, i32 immarg)