[DAG] NFC: Add getBitcasedExtOrTrunc

[jrbyrnes]

Summary

Simple function which scalarizes Ops then ExtOrTruncs them according to function parameters

[arsenm]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

1464–1467

Is this just getExtOrTrunc plus a bitcast (plus support for any_extend?) a get*ExtOrTrunc with the extension type as an argument would be more general

[jrbyrnes]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

1464–1467

It sounds like you are suggesting getAnyExtOrTrunc getZExtOrTrunc etc ? These already exist, so then I should just abandon this.

Or did you perhaps mean getScalarizeZExtOrTrunc getScalarizeAnyExtOrTrunc which does the above but first converts potential vector VT to scalar ?

[arsenm]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

1464–1467

No, there's still a gap to be filled here. There isn't one that handles sext zext and anyext. Not quite sure if bitcast should be worked into it

[jrbyrnes]

Add getExtOrTrunc for Any/Z/S.

Separate out getScalarizedExtOrTrunc into individual getScalarizedZext / getScalarizedAny ..

[arsenm]

llvm/include/llvm/CodeGen/SelectionDAG.h

952

Instead of isAny / isSigned, I'de expect it to take the extend opcode

968

I'm not sure scalarized is the right name, you aren't unrolling a vector operation

[jrbyrnes]

Naming + function API

[arsenm]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

1461–1462

Redundant with check in getBitcast

1476–1477

Redundant with check in getBitcast

1491–1492

Redundant with check in getBitcast

[jrbyrnes]

Clean up getBitcasted* implementations

[arsenm]

Should fix title before submit

llvm/include/llvm/CodeGen/SelectionDAG.h

#endif
   /// Convert Op, which must be of integer type, to the
   /// integer type VT, by either sign-extending or truncating it.
   SDValue getSExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
 
   /// Convert Op, which must be of integer type, to the
   /// integer type VT, by either zero-extending or truncating it.
   SDValue getZExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
 
+  /// Convert Op, which must have scalar of integer type, to the
+  /// scalar integer type VT. First, convert a vector to a
+  /// correspondingly sized integer type, then either extend or
+  /// truncate it. The priority of extension types is:
+  /// ANY_EXTEND, SIGN_EXTEND, then ZERO_EXTEND depending on
+  /// whether or not \p isAny or \p isSigned is set.
+  SDValue getScalarizeExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT,
+                                 bool IsAny = false, bool IsSigned = false);
+
   /// Convert Op, which must be of integer type, to the
   /// integer type VT, by either sign/zero-extending (depending on IsSigned) or
   /// truncating it.
   SDValue getExtOrTrunc(bool IsSigned, SDValue Op, const SDLoc &DL, EVT VT) {
     return IsSigned ? getSExtOrTrunc(Op, DL, VT) : getZExtOrTrunc(Op, DL, VT);
   }
 
   /// Return the expression required to zero extend the Op
   /// value assuming it was the smaller SrcTy value.
   SDValue getZeroExtendInReg(SDValue Op, const SDLoc &DL, EVT VT);
 
   /// Convert Op, which must be of integer type, to the integer type VT, by
   /// either truncating it or performing either zero or sign extension as
   /// appropriate extension for the pointer's semantics.
   SDValue getPtrExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
 
   /// Return the expression required to extend the Op as a pointer value
   /// assuming it was the smaller SrcTy value. This may be either a zero extend
   /// or a sign extend.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 }
 
 SDValue SelectionDAG::getZExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT) {
   return VT.bitsGT(Op.getValueType()) ?
     getNode(ISD::ZERO_EXTEND, DL, VT, Op) :
     getNode(ISD::TRUNCATE, DL, VT, Op);
 }
 
+SDValue SelectionDAG::getScalarizeExtOrTrunc(SDValue Op, const SDLoc &DL,
+                                             EVT VT, bool IsAny,
+                                             bool IsSigned) {
+  assert(!VT.isVector());
+  auto Type = Op.getValueType();
+  SDValue DestOp;
+  if (Type == VT)
+    return Op;
+  auto Size = Op.getValueSizeInBits();
+  DestOp = getBitcast(MVT::getIntegerVT(Size), Op);
+  if (DestOp.getValueType() == VT)
+    return DestOp;
+
+  return IsAny      ? getAnyExtOrTrunc(DestOp, DL, VT)
+         : IsSigned ? getSExtOrTrunc(DestOp, DL, VT)
+                    : getZExtOrTrunc(DestOp, DL, VT);
+}
+
 SDValue SelectionDAG::getBoolExtOrTrunc(SDValue Op, const SDLoc &SL, EVT VT,
                                         EVT OpVT) {
   if (VT.bitsLE(Op.getValueType()))
     return getNode(ISD::TRUNCATE, SL, VT, Op);
 
   TargetLowering::BooleanContent BType = TLI->getBooleanContents(OpVT);
   return getNode(TLI->getExtendForContent(BType), SL, VT, Op);
 }
 
 SDValue SelectionDAG::getZeroExtendInReg(SDValue Op, const SDLoc &DL, EVT VT) {
   EVT OpVT = Op.getValueType();
   assert(VT.isInteger() && OpVT.isInteger() &&
          "Cannot getZeroExtendInReg FP types");
   assert(VT.isVector() == OpVT.isVector() &&
          "getZeroExtendInReg type should be vector iff the operand "
          "type is vector!");
   assert((!VT.isVector() ||
           VT.getVectorElementCount() == OpVT.getVectorElementCount()) &&
          "Vector element counts must match in getZeroExtendInReg");
   assert(VT.bitsLE(OpVT) && "Not extending!");
   if (OpVT == VT)
     return Op;
   APInt Imm = APInt::getLowBitsSet(OpVT.getScalarSizeInBits(),
                                    VT.getScalarSizeInBits());
   return getNode(ISD::AND, DL, OpVT, Op, getConstant(Imm, DL, OpVT));
 }
 

llvm/lib/Target/AMDGPU/SIISelLowering.cpp

if (LHSMask == ~0u || RHSMask == ~0u) {
           return DAG.getBitcast(MVT::getIntegerVT(32), Op);
       }
 
       if (hasNon16BitAccesses(PermMask, Op, OtherOp)) {
         SDLoc DL(N);
         assert(Op.getValueType().isByteSized() &&
                OtherOp.getValueType().isByteSized());
 
-        // Handle potential vectors
-        Op = DAG.getBitcast(MVT::getIntegerVT(Op.getValueSizeInBits()), Op);
-        OtherOp = DAG.getBitcast(
-              MVT::getIntegerVT(OtherOp.getValueSizeInBits()), OtherOp);
-
-        if (Op.getValueSizeInBits() < 32)
-          // If the ultimate src is less than 32 bits, then we will only be
-          // using bytes 0: Op.getValueSizeInBytes() - 1 in the or.
-          // CalculateByteProvider would not have returned Op as source if we
-          // used a byte that is outside its ValueType. Thus, we are free to
-          // ANY_EXTEND as the extended bits are dont-cares.
-          Op = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, Op);
-
-        if (OtherOp.getValueSizeInBits() < 32)
-          OtherOp = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, OtherOp);
+        Op = DAG.getScalarizeExtOrTrunc(Op, DL, MVT::i32, /*AnyExt=*/true);
+        OtherOp =
+            DAG.getScalarizeExtOrTrunc(OtherOp, DL, MVT::i32, /*AnyExt=*/true);
 
         return DAG.getNode(AMDGPUISD::PERM, DL, MVT::i32, Op, OtherOp,
                            DAG.getConstant(PermMask, DL, MVT::i32));
       }
     }
   }
 
   if (VT != MVT::i64 || DCI.isBeforeLegalizeOps())