[GlobalISel] Refactor CSEMIRBuilder's handling of unary op constant folding. NFC.

[aemerson]

Summary

This allows us to handle more unary ops in future in a simpler way, and G_CTLZ is the first opcode to get this treatment.

[aemerson]

llvm/lib/CodeGen/GlobalISel/CSEMIRBuilder.cpp

226

The plan is to add support for constant folding more unary opcodes (e.g. G_ABS) by just adding more cases here, and then implementing the folding in ConstantFoldUnaryOp()

[foad]

No particular objection from me, though it would be more consistent if ConstantFoldUnaryOp built the G_CONSTANT, just like ConstantFoldVectorUnaryOp builds the G_BUILD_VECTOR.

That then raises the question of how you would call these functions from CombinerHelper match* functions, which don't want to build the IR until you get to the corresponding apply* function.

That then also raises the question of whether we really want to be doing constant folding both in the builder and in combiners.

[arsenm]

In D111777#3066274, @foad wrote:

No particular objection from me, though it would be more consistent if ConstantFoldUnaryOp built the G_CONSTANT, just like ConstantFoldVectorUnaryOp builds the G_BUILD_VECTOR.

That then raises the question of how you would call these functions from CombinerHelper match* functions, which don't want to build the IR until you get to the corresponding apply* function.

That then also raises the question of whether we really want to be doing constant folding both in the builder and in combiners.

I think the answer is yes, but for different reasons. I think constant folding in the builder only makes sense for handful of artifact-like operations, but general constant folding is always going to be needed in the combiners as other operations fold to constants

[aemerson]

In D111777#3071406, @arsenm wrote:

In D111777#3066274, @foad wrote:

No particular objection from me, though it would be more consistent if ConstantFoldUnaryOp built the G_CONSTANT, just like ConstantFoldVectorUnaryOp builds the G_BUILD_VECTOR.

That then raises the question of how you would call these functions from CombinerHelper match* functions, which don't want to build the IR until you get to the corresponding apply* function.

That then also raises the question of whether we really want to be doing constant folding both in the builder and in combiners.

I think the answer is yes, but for different reasons. I think constant folding in the builder only makes sense for handful of artifact-like operations, but general constant folding is always going to be needed in the combiners as other operations fold to constants

I agree, but I think there's also the case where the MIRBuilder may be being used at a point in the pipeline where another combine phase isn't coming to save the day. There could be value in having the builder be proactive about not leaving behind constant-foldable instructions.

[arsenm]

llvm/include/llvm/CodeGen/GlobalISel/Utils.h

283

I'm not the biggest fan of Optional on pointers. It's not really any safer than the raw pointer for C++ and more syntactically awkward

llvm/include/llvm/CodeGen/GlobalISel/Utils.h

 
 /// Modify analysis usage so it preserves passes required for the SelectionDAG
 /// fallback.
 void getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU);
 
 Optional<APInt> ConstantFoldBinOp(unsigned Opcode, const Register Op1,
                                   const Register Op2,
                                   const MachineRegisterInfo &MRI);
+Optional<APInt> ConstantFoldUnaryOp(unsigned Opcode, const Register Op1,
+                                    const MachineRegisterInfo &MRI);
 Optional<APFloat> ConstantFoldFPBinOp(unsigned Opcode, const Register Op1,
                                       const Register Op2,
                                       const MachineRegisterInfo &MRI);
 
 /// Tries to constant fold a vector binop with sources \p Op1 and \p Op2.
 /// If successful, returns the G_BUILD_VECTOR representing the folded vector
 /// constant. \p MIB should have an insertion point already set to create new
 /// G_CONSTANT instructions as needed.
 Optional<MachineInstr *>
 ConstantFoldVectorBinop(unsigned Opcode, const Register Op1, const Register Op2,
                         const MachineRegisterInfo &MRI, MachineIRBuilder &MIB);
+/// Tries to constant fold a vector unary operation with source \p Op.
+/// If successful, returns the G_BUILD_VECTOR representing the folded vector
+/// constant. \p MIB should have an insertion point already set to create new
+/// G_CONSTANT instructions as needed.
+Optional<MachineInstr *>
+ConstantFoldVectorUnaryOp(unsigned Opcode, const Register Op,
+                          const MachineRegisterInfo &MRI,
+                          MachineIRBuilder &MIB);
 
 Optional<APInt> ConstantFoldExtOp(unsigned Opcode, const Register Op1,
                                   uint64_t Imm, const MachineRegisterInfo &MRI);
 
 Optional<APFloat> ConstantFoldIntToFloat(unsigned Opcode, LLT DstTy,
                                          Register Src,
                                          const MachineRegisterInfo &MRI);
 

llvm/lib/CodeGen/GlobalISel/CSEMIRBuilder.cpp

case TargetOpcode::G_UITOFP: {
     // Try to constant fold these.
     assert(SrcOps.size() == 1 && "Invalid sources");
     assert(DstOps.size() == 1 && "Invalid dsts");
     if (Optional<APFloat> Cst = ConstantFoldIntToFloat(
             Opc, DstOps[0].getLLTTy(*getMRI()), SrcOps[0].getReg(), *getMRI()))
       return buildFConstant(DstOps[0], *Cst);
     break;
   }
   case TargetOpcode::G_CTLZ: {
     assert(SrcOps.size() == 1 && "Expected one source");
     assert(DstOps.size() == 1 && "Expected one dest");
-    auto MaybeCsts = ConstantFoldCTLZ(SrcOps[0].getReg(), *getMRI());
-    if (!MaybeCsts)
-      break;
-    if (MaybeCsts->size() == 1)
-      return buildConstant(DstOps[0], (*MaybeCsts)[0]);
-    // This was a vector constant. Build a G_BUILD_VECTOR for them.
-    SmallVector<Register> ConstantRegs;
-    LLT VecTy = DstOps[0].getLLTTy(*getMRI());
-    for (unsigned Cst : *MaybeCsts)
-      ConstantRegs.emplace_back(
-          buildConstant(VecTy.getScalarType(), Cst).getReg(0));
-    return buildBuildVector(DstOps[0], ConstantRegs);
+    if (SrcOps[0].getLLTTy(*getMRI()).isVector()) {
+      // Try to constant fold vector constants.
+      auto VecCst =
+          ConstantFoldVectorUnaryOp(Opc, SrcOps[0].getReg(), *getMRI(), *this);
+      if (VecCst)
+        return MachineInstrBuilder(getMF(), *VecCst);
+      break;
+    }
+    if (Optional<APInt> Cst =
+            ConstantFoldUnaryOp(Opc, SrcOps[0].getReg(), *getMRI()))
+      return buildConstant(DstOps[0], *Cst);
   }
   }
   bool CanCopy = checkCopyToDefsPossible(DstOps);
   if (!canPerformCSEForOpc(Opc))
     return MachineIRBuilder::buildInstr(Opc, DstOps, SrcOps, Flag);
   // If we can CSE this instruction, but involves generating copies to multiple
   // regs, give up. This frequently happens to UNMERGEs.
   if (!CanCopy) {

llvm/lib/CodeGen/GlobalISel/Utils.cpp

case TargetOpcode::G_SREM:
     if (!C2.getBoolValue())
       break;
     return C1.srem(C2);
   }
 
   return None;
 }
 
+Optional<APInt> llvm::ConstantFoldUnaryOp(unsigned Opcode, const Register Op1,
+
+                                          const MachineRegisterInfo &MRI) {
+  Optional<APInt> MaybeCst = getIConstantVRegVal(Op1, MRI);
+  if (!MaybeCst)
+    return None;
+
+  APInt &C = *MaybeCst;
+  switch (Opcode) {
+  default:
+    return None;
+  case TargetOpcode::G_CTLZ:
+    return APInt(C.getBitWidth(), C.countLeadingZeros());
+  }
+}
+
+Optional<MachineInstr *>
+llvm::ConstantFoldVectorUnaryOp(unsigned Opcode, const Register Op,
+                                const MachineRegisterInfo &MRI,
+                                MachineIRBuilder &MIB) {
+  auto *SrcVec = getOpcodeDef<GBuildVector>(Op, MRI);
+  if (!SrcVec)
+    return None;
+
+  const LLT EltTy = MRI.getType(SrcVec->getSourceReg(0));
+
+  SmallVector<Register, 16> FoldedElements;
+  for (unsigned Idx = 0, E = SrcVec->getNumSources(); Idx < E; ++Idx) {
+    auto MaybeCst = ConstantFoldUnaryOp(Opcode, SrcVec->getSourceReg(Idx), MRI);
+    if (!MaybeCst)
+      return None;
+    auto FoldedCstReg = MIB.buildConstant(EltTy, *MaybeCst).getReg(0);
+    FoldedElements.emplace_back(FoldedCstReg);
+  }
+  // Create the new vector constant.
+  auto CstVec =
+      MIB.buildBuildVector(MRI.getType(SrcVec->getReg(0)), FoldedElements);
+  return &*CstVec;
+}
+
 Optional<APFloat> llvm::ConstantFoldFPBinOp(unsigned Opcode, const Register Op1,
                                             const Register Op2,
                                             const MachineRegisterInfo &MRI) {
   const ConstantFP *Op2Cst = getConstantFPVRegVal(Op2, MRI);
   if (!Op2Cst)
     return None;
 
   const ConstantFP *Op1Cst = getConstantFPVRegVal(Op1, MRI);