[Power9]Legalize and emit code for truncate and convert Quad-Precision to Double-Word

[lei]

Summary

Legalize and emit code for:

• xscvqpsdz : VSX Scalar truncate & Convert Quad-Precision to Signed Dword
• xscvqpudz : VSX Scalar truncate & Convert Quad-Precision to Unsigned Dword

[inouehrs]

lib/Target/PowerPC/PPCISelLowering.cpp

9418

I feel it is better to do this check in LowerFP_TO_INT for ease of reading.

[lei]

update as per review comment.

[nemanjai]

lib/Target/PowerPC/PPCISelLowering.cpp

6934

This sentence makes it sound like this is legal in a judicial sense. Perhaps:
// FP to INT conversions are legal for f128.

lib/Target/PowerPC/PPCInstrVSX.td

3170

Don't forget periods on comments.

3171

This seems very wrong. The STXSD will need a reg and an immediate and xoaddr will force it to use reg+reg. We should have two versions here (xaddr -> STXSDX and ixaddr -> STXSD). And we should also have test cases for both store instructions.

test/CodeGen/PowerPC/f128-truncateNconv.ll

3

Don't forget -verify-machineinstrs in test cases. We want to make sure we don't introduce new machine verifier failures (which I think this patch does).

[lei]

address review comments.

[lei]

Rebased on patch: https://reviews.llvm.org/D46102

[nemanjai]

LGTM. Of course, after the dependent patch lands.

lib/Target/PowerPC/PPCISelLowering.cpp

case MVT::i64:
     Tmp = DAG.getNode(PPCISD::MFVSR, dl, MVT::i64, Tmp);
     break;
   }
   return Tmp;
 }
 
 SDValue PPCTargetLowering::LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG,
                                           const SDLoc &dl) const {
+
+  // FP to INT conversions are legal for f128.
+  if (EnableQuadPrecision && (Op->getOperand(0).getValueType() == MVT::f128))
+    return Op;
+
   // Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
   // PPC (the libcall is not available).
   if (Op.getOperand(0).getValueType() == MVT::ppcf128) {
     if (Op.getValueType() == MVT::i32) {
       if (Op.getOpcode() == ISD::FP_TO_SINT) {
         SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl,
                                  MVT::f64, Op.getOperand(0),
                                  DAG.getIntPtrConstant(0, dl));
SDValue PPCTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
 
   case ISD::LOAD:               return LowerLOAD(Op, DAG);
   case ISD::STORE:              return LowerSTORE(Op, DAG);
   case ISD::TRUNCATE:           return LowerTRUNCATE(Op, DAG);
   case ISD::SELECT_CC:          return LowerSELECT_CC(Op, DAG);
   case ISD::FP_TO_UINT:
   case ISD::FP_TO_SINT:         return LowerFP_TO_INT(Op, DAG, SDLoc(Op));
   case ISD::UINT_TO_FP:
   case ISD::SINT_TO_FP:         return LowerINT_TO_FP(Op, DAG);
   case ISD::FLT_ROUNDS_:        return LowerFLT_ROUNDS_(Op, DAG);
 
   // Lower 64-bit shifts.
   case ISD::SHL_PARTS:          return LowerSHL_PARTS(Op, DAG);
   case ISD::SRL_PARTS:          return LowerSRL_PARTS(Op, DAG);
   case ISD::SRA_PARTS:          return LowerSRA_PARTS(Op, DAG);
 
   // Vector-related lowering.

lib/Target/PowerPC/PPCInstrVSX.td

let AddedComplexity = 400, Predicates = [HasP9Vector] in {
   def XSCVQPDPO : X_VT5_XO5_VB5_Ro<63, 20, 836, "xscvqpdpo", []>;
 
   // Truncate & Convert QP -> (Un)Signed (D)Word (dword[1] is set to zero)
   def XSCVQPSDZ : X_VT5_XO5_VB5<63, 25, 836, "xscvqpsdz", []>;
   def XSCVQPSWZ : X_VT5_XO5_VB5<63,  9, 836, "xscvqpswz", []>;
   def XSCVQPUDZ : X_VT5_XO5_VB5<63, 17, 836, "xscvqpudz", []>;
   def XSCVQPUWZ : X_VT5_XO5_VB5<63,  1, 836, "xscvqpuwz", []>;
 
-  // Convert (Un)Signed DWord -> QP
+  // Convert (Un)Signed DWord -> QP.
   def XSCVSDQP  : X_VT5_XO5_VB5_TyVB<63, 10, 836, "xscvsdqp", vfrc, []>;
   def : Pat<(f128 (sint_to_fp i64:$src)),
             (f128 (XSCVSDQP (COPY_TO_REGCLASS $src, VFRC)))>;
   def XSCVUDQP  : X_VT5_XO5_VB5_TyVB<63,  2, 836, "xscvudqp", vfrc, []>;
   def : Pat<(f128 (uint_to_fp i64:$src)),
             (f128 (XSCVUDQP (COPY_TO_REGCLASS $src, VFRC)))>;
 
-  // Convert (Un)Signed Word -> QP
+  // Convert (Un)Signed Word -> QP.
   def : Pat<(f128 (sint_to_fp i32:$src)),
             (f128 (XSCVSDQP (MTVSRWA $src)))>;
   def : Pat<(f128 (sint_to_fp (i32 (load xoaddr:$src)))),
             (f128 (XSCVSDQP (LIWAX xoaddr:$src)))>;
   def : Pat<(f128 (uint_to_fp i32:$src)),
             (f128 (XSCVUDQP (MTVSRWZ $src)))>;
   def : Pat<(f128 (uint_to_fp (i32 (load xoaddr:$src)))),
             (f128 (XSCVUDQP (LIWZX xoaddr:$src)))>;
let AddedComplexity = 400, Predicates = [HasP9Vector] in {
   // Convert Unsigned HWord in memory -> QP
   def : Pat<(f128 (uint_to_fp ScalarLoads.ZELi16)),
             (f128 (XSCVUDQP (LXSIHZX xaddr:$src)))>;
 
   // Convert Unsigned Byte in memory -> QP
   def : Pat<(f128 (uint_to_fp ScalarLoads.ZELi8)),
             (f128 (XSCVUDQP (LXSIBZX xoaddr:$src)))>;
 
+  // Truncate & Convert QP -> (Un)Signed (D)Word
+  def : Pat<(i64 (fp_to_sint f128:$src)), (i64 (MFVRD (XSCVQPSDZ $src)))>;
+  def : Pat<(i64 (fp_to_uint f128:$src)), (i64 (MFVRD (XSCVQPUDZ $src)))>;
+
   // Instructions for fptosint (i64,i16,i8) feeding a store.
   def : Pat<(PPCstore_scal_int_from_vsr
+              (f64 (PPCcv_fp_to_sint_in_vsr f128:$src)), xaddr:$dst, 8),
+            (STXSDX (COPY_TO_REGCLASS (XSCVQPSDZ f128:$src), VFRC),
+                    xaddr:$dst)>;
+  def : Pat<(PPCstore_scal_int_from_vsr
+              (f64 (PPCcv_fp_to_sint_in_vsr f128:$src)), ixaddr:$dst, 8),
+            (STXSD (COPY_TO_REGCLASS (XSCVQPSDZ f128:$src), VFRC),
+                   ixaddr:$dst)>;
+  def : Pat<(PPCstore_scal_int_from_vsr
               (f64 (PPCcv_fp_to_sint_in_vsr f64:$src)), xaddr:$dst, 8),
             (STXSDX (XSCVDPSXDS f64:$src), xaddr:$dst)>;
   def : Pat<(PPCstore_scal_int_from_vsr
               (f64 (PPCcv_fp_to_sint_in_vsr f64:$src)), ixaddr:$dst, 8),
             (STXSD (XSCVDPSXDS f64:$src), ixaddr:$dst)>;
   def : Pat<(PPCstore_scal_int_from_vsr
               (f64 (PPCcv_fp_to_sint_in_vsr f64:$src)), xoaddr:$dst, 2),
             (STXSIHX (XSCVDPSXWS f64:$src), xoaddr:$dst)>;
   def : Pat<(PPCstore_scal_int_from_vsr
               (f64 (PPCcv_fp_to_sint_in_vsr f64:$src)), xoaddr:$dst, 1),
             (STXSIBX (XSCVDPSXWS f64:$src), xoaddr:$dst)>;
 
   // Instructions for fptouint (i64,i16,i8) feeding a store.
   def : Pat<(PPCstore_scal_int_from_vsr
+              (f64 (PPCcv_fp_to_uint_in_vsr f128:$src)), xaddr:$dst, 8),
+            (STXSDX (COPY_TO_REGCLASS (XSCVQPUDZ f128:$src), VFRC),
+                    xaddr:$dst)>;
+  def : Pat<(PPCstore_scal_int_from_vsr
+              (f64 (PPCcv_fp_to_uint_in_vsr f128:$src)), ixaddr:$dst, 8),
+            (STXSD (COPY_TO_REGCLASS (XSCVQPUDZ f128:$src), VFRC),
+                   ixaddr:$dst)>;
+  def : Pat<(PPCstore_scal_int_from_vsr
               (f64 (PPCcv_fp_to_uint_in_vsr f64:$src)), xaddr:$dst, 8),
             (STXSDX (XSCVDPUXDS f64:$src), xaddr:$dst)>;
   def : Pat<(PPCstore_scal_int_from_vsr
               (f64 (PPCcv_fp_to_uint_in_vsr f64:$src)), ixaddr:$dst, 8),
             (STXSD (XSCVDPUXDS f64:$src), ixaddr:$dst)>;
   def : Pat<(PPCstore_scal_int_from_vsr
               (f64 (PPCcv_fp_to_uint_in_vsr f64:$src)), xoaddr:$dst, 2),
             (STXSIHX (XSCVDPUXWS f64:$src), xoaddr:$dst)>;

test/CodeGen/PowerPC/f128-truncateNconv.ll

+; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown \
+; RUN:   -verify-machineinstrs -enable-ppc-quad-precision \
+; RUN:   -ppc-vsr-nums-as-vr < %s | FileCheck %s
+
+@f128Array = global [4 x fp128] [fp128 0xL00000000000000004004C00000000000,
+                                 fp128 0xLF000000000000000400808AB851EB851,
+                                 fp128 0xL5000000000000000400E0C26324C8366,
+                                 fp128 0xL8000000000000000400A24E2E147AE14],
+                                align 16
+
+; Function Attrs: norecurse nounwind readonly
+define i64 @qpConv2sdw(fp128* nocapture readonly %a) {
+entry:
+  %0 = load fp128, fp128* %a, align 16
+  %conv = fptosi fp128 %0 to i64
+  ret i64 %conv
+
+; CHECK-LABEL: qpConv2sdw
+; CHECK: lxv [[REG:[0-9]+]], 0(3)
+; CHECK-NEXT: xscvqpsdz [[CONV:[0-9]+]], [[REG]]
+; CHECK-NEXT: mfvsrd 3, [[CONV]]
+; CHECK-NEXT: blr
+}
+
+; Function Attrs: norecurse nounwind
+define void @qpConv2sdw_02(i64* nocapture %res) local_unnamed_addr #1 {
+entry:
+  %0 = load fp128, fp128* getelementptr inbounds
+                            ([4 x fp128], [4 x fp128]* @f128Array, i64 0,
+                             i64 2), align 16
+  %conv = fptosi fp128 %0 to i64
+  store i64 %conv, i64* %res, align 8
+  ret void
+
+; CHECK-LABEL: qpConv2sdw_02
+; CHECK: addis [[REG0:[0-9]+]], 2, .LC0@toc@ha
+; CHECK: ld [[REG0]], .LC0@toc@l([[REG0]])
+; CHECK: lxv [[REG:[0-9]+]], 32([[REG0]])
+; CHECK-NEXT: xscvqpsdz [[CONV:[0-9]+]], [[REG]]
+; CHECK-NEXT: stxsd [[CONV]], 0(3)
+; CHECK-NEXT: blr
+}
+
+; Function Attrs: norecurse nounwind readonly
+define i64 @qpConv2sdw_03(fp128* nocapture readonly %a) {
+entry:
+  %0 = load fp128, fp128* %a, align 16
+  %1 = load fp128, fp128* getelementptr inbounds
+                            ([4 x fp128], [4 x fp128]* @f128Array, i64 0,
+                             i64 1), align 16
+  %add = fadd fp128 %0, %1
+  %conv = fptosi fp128 %add to i64
+  ret i64 %conv
+
+; CHECK-LABEL: qpConv2sdw_03
+; CHECK: addis [[REG0:[0-9]+]], 2, .LC0@toc@ha
+; CHECK-DAG: ld [[REG0]], .LC0@toc@l([[REG0]])
+; CHECK-DAG: lxv [[REG1:[0-9]+]], 16([[REG0]])
+; CHECK-DAG: lxv [[REG:[0-9]+]], 0(3)
+; CHECK: xsaddqp [[REG]], [[REG]], [[REG1]]
+; CHECK-NEXT: xscvqpsdz [[CONV:[0-9]+]], [[REG]]
+; CHECK-NEXT: mfvsrd 3, [[CONV]]
+; CHECK-NEXT: blr
+}
+
+; Function Attrs: norecurse nounwind
+define void @qpConv2sdw_04(fp128* nocapture readonly %a,
+                           fp128* nocapture readonly %b, i64* nocapture %res) {
+entry:
+  %0 = load fp128, fp128* %a, align 16
+  %1 = load fp128, fp128* %b, align 16
+  %add = fadd fp128 %0, %1
+  %conv = fptosi fp128 %add to i64
+  store i64 %conv, i64* %res, align 8
+  ret void
+
+; CHECK-LABEL: qpConv2sdw_04
+; CHECK-DAG: lxv [[REG1:[0-9]+]], 0(4)
+; CHECK-DAG: lxv [[REG:[0-9]+]], 0(3)
+; CHECK: xsaddqp [[REG]], [[REG]], [[REG1]]
+; CHECK-NEXT: xscvqpsdz [[CONV:[0-9]+]], [[REG]]
+; CHECK-NEXT: stxsd [[CONV]], 0(5)
+; CHECK-NEXT: blr
+}
+
+; Function Attrs: norecurse nounwind
+define void @qpConv2sdw_testXForm(i64* nocapture %res, i32 signext %idx) {
+entry:
+  %0 = load fp128, fp128* getelementptr inbounds
+                            ([4 x fp128], [4 x fp128]* @f128Array,
+                             i64 0, i64 2), align 16
+  %conv = fptosi fp128 %0 to i64
+  %idxprom = sext i32 %idx to i64
+  %arrayidx = getelementptr inbounds i64, i64* %res, i64 %idxprom
+  store i64 %conv, i64* %arrayidx, align 8
+  ret void
+
+; CHECK-LABEL: qpConv2sdw_testXForm
+; CHECK: xscvqpsdz [[CONV:[0-9]+]],
+; CHECK-NEXT: stxsdx [[CONV]], 3, 4
+; CHECK-NEXT: blr
+}
+
+; Function Attrs: norecurse nounwind readonly
+define i64 @qpConv2udw(fp128* nocapture readonly %a) {
+entry:
+  %0 = load fp128, fp128* %a, align 16
+  %conv = fptoui fp128 %0 to i64
+  ret i64 %conv
+
+; CHECK-LABEL: qpConv2udw
+; CHECK: lxv [[REG:[0-9]+]], 0(3)
+; CHECK-NEXT: xscvqpudz [[CONV:[0-9]+]], [[REG]]
+; CHECK-NEXT: mfvsrd 3, [[CONV]]
+; CHECK-NEXT: blr
+}
+
+; Function Attrs: norecurse nounwind
+define void @qpConv2udw_02(i64* nocapture %res) {
+entry:
+  %0 = load fp128, fp128* getelementptr inbounds
+                            ([4 x fp128], [4 x fp128]* @f128Array, i64 0,
+                             i64 2), align 16
+  %conv = fptoui fp128 %0 to i64
+  store i64 %conv, i64* %res, align 8
+  ret void
+
+; CHECK-LABEL: qpConv2udw_02
+; CHECK: addis [[REG0:[0-9]+]], 2, .LC0@toc@ha
+; CHECK: ld [[REG0]], .LC0@toc@l([[REG0]])
+; CHECK: lxv [[REG:[0-9]+]], 32([[REG0]])
+; CHECK-NEXT: xscvqpudz [[CONV:[0-9]+]], [[REG]]
+; CHECK-NEXT: stxsd [[CONV]], 0(3)
+; CHECK-NEXT: blr
+}
+
+; Function Attrs: norecurse nounwind readonly
+define i64 @qpConv2udw_03(fp128* nocapture readonly %a) {
+entry:
+  %0 = load fp128, fp128* %a, align 16
+  %1 = load fp128, fp128* getelementptr inbounds
+                            ([4 x fp128], [4 x fp128]* @f128Array, i64 0,
+                             i64 1), align 16
+  %add = fadd fp128 %0, %1
+  %conv = fptoui fp128 %add to i64
+  ret i64 %conv
+
+; CHECK-LABEL: qpConv2udw_03
+; CHECK: addis [[REG0:[0-9]+]], 2, .LC0@toc@ha
+; CHECK-DAG: ld [[REG0]], .LC0@toc@l([[REG0]])
+; CHECK-DAG: lxv [[REG1:[0-9]+]], 16([[REG0]])
+; CHECK-DAG: lxv [[REG:[0-9]+]], 0(3)
+; CHECK: xsaddqp [[REG]], [[REG]], [[REG1]]
+; CHECK-NEXT: xscvqpudz [[CONV:[0-9]+]], [[REG]]
+; CHECK-NEXT: mfvsrd 3, [[CONV]]
+; CHECK-NEXT: blr
+}
+
+; Function Attrs: norecurse nounwind
+define void @qpConv2udw_04(fp128* nocapture readonly %a,
+                           fp128* nocapture readonly %b, i64* nocapture %res) {
+entry:
+  %0 = load fp128, fp128* %a, align 16
+  %1 = load fp128, fp128* %b, align 16
+  %add = fadd fp128 %0, %1
+  %conv = fptoui fp128 %add to i64
+  store i64 %conv, i64* %res, align 8
+  ret void
+
+; CHECK-LABEL: qpConv2udw_04
+; CHECK-DAG: lxv [[REG1:[0-9]+]], 0(4)
+; CHECK-DAG: lxv [[REG:[0-9]+]], 0(3)
+; CHECK: xsaddqp [[REG]], [[REG]], [[REG1]]
+; CHECK-NEXT: xscvqpudz [[CONV:[0-9]+]], [[REG]]
+; CHECK-NEXT: stxsd [[CONV]], 0(5)
+; CHECK-NEXT: blr
+}
+
+; Function Attrs: norecurse nounwind
+define void @qpConv2udw_testXForm(i64* nocapture %res, i32 signext %idx) {
+entry:
+  %0 = load fp128, fp128* getelementptr inbounds
+                            ([4 x fp128], [4 x fp128]* @f128Array,
+                             i64 0, i64 0), align 16
+  %conv = fptoui fp128 %0 to i64
+  %idxprom = sext i32 %idx to i64
+  %arrayidx = getelementptr inbounds i64, i64* %res, i64 %idxprom
+  store i64 %conv, i64* %arrayidx, align 8
+  ret void
+
+; CHECK-LABEL: qpConv2udw_testXForm
+; CHECK: xscvqpudz [[CONV:[0-9]+]],
+; CHECK-NEXT: stxsdx [[CONV]], 3, 4
+; CHECK-NEXT: blr
+}