[PowerPC] Generate Power9 extswsli extend sign and shift immediate instruction

[RolandF]

Summary

Add a DAG combine for the PowerPC code generator to generate the Power9 extswsli extend sign and shift immediate instruction.

[inouehrs]

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

14113

Do you have any reason to use isConstOrConstSplat instead of more common isa<ConstantSDNode>(N1)?

14120

You don't need to use a variable N000 since it is used only once. N000 and N00 seem confusing for me.

[RolandF]

Updated to incorporate review comments.

[nemanjai]

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

14113

The use of isa followed by cast is discouraged. Please use dyn_cast. Then this can be turned into an early exit if any of the conditions are not met and the body of this block doesn't need to be nested in an if.

[RolandF]

Update to access constant shift amount by dynamic cast and to reverse if from block form to early exit.

[nemanjai]

LGTM aside from the minor nit.

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

14142

Nit: please change CN1 == NULL to either !CN1 or CN1 == nullptr. Feel free to do this on the commit - no new review required.

[RolandF]

Changed == NULL to == nullptr.

[RolandF]

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

14142

Sorry, I don't have commit access, so I have updated the diff.

llvm/lib/Target/PowerPC/PPCISelLowering.h

enum NodeType : unsigned {
       ///
       /// For scalar types, only the last `n + 1` bits of the shift amounts
       /// are used, where n is log2(sizeof(element) * 8). See sld/slw, etc.
       /// for exact behaviors.
       ///
       /// For vector types, only the last n bits are used. See vsld.
       SRL, SRA, SHL,
 
+      /// EXTSWSLI = The PPC extswsli instruction, which does an extend-sign
+      /// word and shift left immediate.
+      EXTSWSLI,
+
       /// The combination of sra[wd]i and addze used to implemented signed
       /// integer division by a power of 2. The first operand is the dividend,
       /// and the second is the constant shift amount (representing the
       /// divisor).
       SRA_ADDZE,
 
       /// CALL - A direct function call.
       /// CALL_NOP is a call with the special NOP which follows 64-bit

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

const char *PPCTargetLowering::getTargetNodeName(unsigned Opcode) const {
   case PPCISD::SWAP_NO_CHAIN:   return "PPCISD::SWAP_NO_CHAIN";
   case PPCISD::QVFPERM:         return "PPCISD::QVFPERM";
   case PPCISD::QVGPCI:          return "PPCISD::QVGPCI";
   case PPCISD::QVALIGNI:        return "PPCISD::QVALIGNI";
   case PPCISD::QVESPLATI:       return "PPCISD::QVESPLATI";
   case PPCISD::QBFLT:           return "PPCISD::QBFLT";
   case PPCISD::QVLFSb:          return "PPCISD::QVLFSb";
   case PPCISD::BUILD_FP128:     return "PPCISD::BUILD_FP128";
+  case PPCISD::EXTSWSLI:        return "PPCISD::EXTSWSLI";
   }
   return nullptr;
 }
 
 EVT PPCTargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &C,
                                           EVT VT) const {
   if (!VT.isVector())
     return Subtarget.useCRBits() ? MVT::i1 : MVT::i32;
static SDValue stripModuloOnShift(const TargetLowering &TLI, SDNode *N,
 
   return SDValue();
 }
 
 SDValue PPCTargetLowering::combineSHL(SDNode *N, DAGCombinerInfo &DCI) const {
   if (auto Value = stripModuloOnShift(*this, N, DCI.DAG))
     return Value;
 
+  SDValue N0 = N->getOperand(0);
+  SDValue N1 = N->getOperand(1);
+  if (Subtarget.isISA3_0() &&
+      N0.getOpcode() == ISD::SIGN_EXTEND &&
+      N0.getOperand(0).getValueType() == MVT::i32 &&
+      isConstOrConstSplat(N1)) {
+
+    // We can't save an operation here if the value is already extended, and
+    // the existing shift is easier to combine.
+    SDValue N00 = N0.getOperand(0);
+    if (N00.getOpcode() == ISD::TRUNCATE) {
+      SDValue N000 = N00.getOperand(0);
+      if (N000.getOpcode() == ISD::AssertSext)
+        return SDValue();
+    }  
+
+    SDLoc DL(N0);
+    SDValue ShiftBy = N1;
+    // We want the shift amount to be i32 on the extswli, but the shift could
+    // have an i64.
+    if (ShiftBy.getValueType() == MVT::i64) {
+      int Val = cast<ConstantSDNode>(N1)->getZExtValue();
+      ShiftBy = DCI.DAG.getConstant(Val, DL, MVT::i32);
+    }
+
+    return DCI.DAG.getNode(PPCISD::EXTSWSLI, DL, MVT::i64, N0->getOperand(0),
+                           ShiftBy);
+  }
+
   return SDValue();
 }
 
 SDValue PPCTargetLowering::combineSRA(SDNode *N, DAGCombinerInfo &DCI) const {
   if (auto Value = stripModuloOnShift(*this, N, DCI.DAG))
     return Value;
 
   return SDValue();
 }
 
 SDValue PPCTargetLowering::combineSRL(SDNode *N, DAGCombinerInfo &DCI) const {
   if (auto Value = stripModuloOnShift(*this, N, DCI.DAG))
     return Value;
 

llvm/lib/Target/PowerPC/PPCInstr64Bit.td

 def EXTSW_32 : XForm_11<31, 986, (outs gprc:$rA), (ins gprc:$rS),
                         "extsw $rA, $rS", IIC_IntSimple,
                         []>, isPPC64;
 
 defm SRADI  : XSForm_1rc<31, 413, (outs g8rc:$rA), (ins g8rc:$rS, u6imm:$SH),
                          "sradi", "$rA, $rS, $SH", IIC_IntRotateDI,
                          [(set i64:$rA, (sra i64:$rS, (i32 imm:$SH)))]>, isPPC64;
 
-defm EXTSWSLI : XSForm_1r<31, 445, (outs g8rc:$rA), (ins g8rc:$rS, u6imm:$SH),
+defm EXTSWSLI : XSForm_1r<31, 445, (outs g8rc:$rA), (ins gprc:$rS, u6imm:$SH),
                           "extswsli", "$rA, $rS, $SH", IIC_IntRotateDI,
-                          []>, isPPC64;
+                          [(set i64:$rA, (PPCextswsli i32:$rS, (i32 imm:$SH)))]>,
+                          isPPC64, Requires<[IsISA3_0]>;
 
 // For fast-isel:
 let isCodeGenOnly = 1, Defs = [CARRY] in
 def SRADI_32  : XSForm_1<31, 413, (outs gprc:$rA), (ins gprc:$rS, u6imm:$SH),
                          "sradi $rA, $rS, $SH", IIC_IntRotateDI, []>, isPPC64;
 
 defm CNTLZD : XForm_11r<31,  58, (outs g8rc:$rA), (ins g8rc:$rS),
                         "cntlzd", "$rA, $rS", IIC_IntGeneral,

llvm/lib/Target/PowerPC/PPCInstrInfo.td

 def SDT_PPCqbflt : SDTypeProfile<1, 1, [
   SDTCisVec<0>, SDTCisVec<1>
 ]>;
 
 def SDT_PPCqvlfsb : SDTypeProfile<1, 1, [
   SDTCisVec<0>, SDTCisPtrTy<1>
 ]>;
 
+def SDT_PPCextswsli : SDTypeProfile<1, 2, [  // extswsli
+  SDTCisInt<0>, SDTCisInt<1>, SDTCisOpSmallerThanOp<1, 0>, SDTCisInt<2>
+]>;
+
 //===----------------------------------------------------------------------===//
 // PowerPC specific DAG Nodes.
 //
 
 def PPCfre    : SDNode<"PPCISD::FRE",     SDTFPUnaryOp, []>;
 def PPCfrsqrte: SDNode<"PPCISD::FRSQRTE", SDTFPUnaryOp, []>;
 
 def PPCfcfid  : SDNode<"PPCISD::FCFID",   SDTFPUnaryOp, []>;

 def PPCcmpb     : SDNode<"PPCISD::CMPB", SDTIntBinOp, []>;
 
 // These nodes represent the 32-bit PPC shifts that operate on 6-bit shift
 // amounts.  These nodes are generated by the multi-precision shift code.
 def PPCsrl        : SDNode<"PPCISD::SRL"       , SDTIntShiftOp>;
 def PPCsra        : SDNode<"PPCISD::SRA"       , SDTIntShiftOp>;
 def PPCshl        : SDNode<"PPCISD::SHL"       , SDTIntShiftOp>;
 
+def PPCextswsli : SDNode<"PPCISD::EXTSWSLI" , SDT_PPCextswsli>;
+
 // Move 2 i64 values into a VSX register
 def PPCbuild_fp128: SDNode<"PPCISD::BUILD_FP128",
                            SDTypeProfile<1, 2,
                              [SDTCisFP<0>, SDTCisSameSizeAs<1,2>,
                               SDTCisSameAs<1,2>]>,
                            []>;
 
 // These are target-independent nodes, but have target-specific formats.

llvm/test/CodeGen/PowerPC/extswsli.ll

+; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
+; RUN:     -mcpu=pwr9 -ppc-asm-full-reg-names < %s | FileCheck %s
+
+@z = external local_unnamed_addr global i32*, align 8
+
+; Function Attrs: norecurse nounwind readonly
+define signext i32 @_Z2tcii(i32 signext %x, i32 signext %y) local_unnamed_addr #0 {
+entry:
+  %0 = load i32*, i32** @z, align 8
+  %add = add nsw i32 %y, %x
+  %idxprom = sext i32 %add to i64
+  %arrayidx = getelementptr inbounds i32, i32* %0, i64 %idxprom
+  %1 = load i32, i32* %arrayidx, align 4
+  ret i32 %1
+; CHECK-LABEL: @_Z2tcii
+; CHECK: extswsli {{r[0-9]+}}, {{r[0-9]+}}, 2
+}