GlobalISel: Merge different versions of isConstantOrConstantVector

[arsenm]

Summary

This leans towards the newer version which handles opaque and FP
constants, but does not bother using look through (which seems to
impact no tests).

[aemerson]

LGTM.

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

bool isBuildVectorAllZeros(const MachineInstr &MI,
                            bool AllowUndef = false);
 
 /// Return true if the specified instruction is a G_BUILD_VECTOR or
 /// G_BUILD_VECTOR_TRUNC where all of the elements are ~0 or undef.
 bool isBuildVectorAllOnes(const MachineInstr &MI,
                           const MachineRegisterInfo &MRI,
                           bool AllowUndef = false);
 
-/// Return true if the specified instruction is known to be a constant, or a
-/// vector of constants.
-///
-/// If \p AllowFP is true, this will consider G_FCONSTANT in addition to
-/// G_CONSTANT. If \p AllowOpaqueConstants is true, constant-like instructions
-/// such as G_GLOBAL_VALUE will also be considered.
-bool isConstantOrConstantVector(const MachineInstr &MI,
-                                const MachineRegisterInfo &MRI,
-                                bool AllowFP = true,
-                                bool AllowOpaqueConstants = true);
-
 /// Return true if the value is a constant 0 integer or a splatted vector of a
 /// constant 0 integer (with no undefs if \p AllowUndefs is false). This will
 /// handle G_BUILD_VECTOR and G_BUILD_VECTOR TRUNC as truncation is not an issue
 /// for null values.
 bool isNullOrNullSplat(const MachineInstr &MI, const MachineRegisterInfo &MRI,
                        bool AllowUndefs = false);
 
 /// Return true if the value is a constant -1 integer or a splatted vector of a

 ///   %cst = G_CONSTANT iN 4
 ///   %constant_splat = G_BUILD_VECTOR %cst, %cst, ..., %cst
 /// \endcode
 ///
 /// In the above case, this will return a RegOrConstant containing 4.
 Optional<RegOrConstant> getVectorSplat(const MachineInstr &MI,
                                        const MachineRegisterInfo &MRI);
 
-/// Determines if \p MI defines a constant integer or a build vector of
-/// constant integers. Treats undef values as constants.
-bool isConstantOrConstantVector(MachineInstr &MI,
-                                const MachineRegisterInfo &MRI);
+/// Return true if the specified instruction is known to be a constant, or a
+/// vector of constants.
+///
+/// If \p AllowFP is true, this will consider G_FCONSTANT in addition to
+/// G_CONSTANT. If \p AllowOpaqueConstants is true, constant-like instructions
+/// such as G_GLOBAL_VALUE will also be considered.
+bool isConstantOrConstantVector(const MachineInstr &MI,
+                                const MachineRegisterInfo &MRI,
+                                bool AllowFP = true,
+                                bool AllowOpaqueConstants = true);
 
 /// Determines if \p MI defines a constant integer or a splat vector of
 /// constant integers.
 /// \returns the scalar constant or None.
 Optional<APInt> isConstantOrConstantSplatVector(MachineInstr &MI,
                                                 const MachineRegisterInfo &MRI);
 
 /// Attempt to match a unary predicate against a scalar/splat constant or every

llvm/lib/CodeGen/GlobalISel/Utils.cpp

static bool isConstantScalar(const MachineInstr &MI,
   case TargetOpcode::G_BLOCK_ADDR:
   case TargetOpcode::G_JUMP_TABLE:
     return AllowOpaqueConstants;
   default:
     return false;
   }
 }
 
-bool llvm::isConstantOrConstantVector(MachineInstr &MI,
-                                      const MachineRegisterInfo &MRI) {
-  Register Def = MI.getOperand(0).getReg();
-  if (auto C = getIConstantVRegValWithLookThrough(Def, MRI))
-    return true;
-  GBuildVector *BV = dyn_cast<GBuildVector>(&MI);
-  if (!BV)
-    return false;
-  for (unsigned SrcIdx = 0; SrcIdx < BV->getNumSources(); ++SrcIdx) {
-    if (getIConstantVRegValWithLookThrough(BV->getSourceReg(SrcIdx), MRI) ||
-        getOpcodeDef<GImplicitDef>(BV->getSourceReg(SrcIdx), MRI))
-      continue;
-    return false;
-  }
-  return true;
-}
-
 bool llvm::isConstantOrConstantVector(const MachineInstr &MI,
                                       const MachineRegisterInfo &MRI,
                                       bool AllowFP, bool AllowOpaqueConstants) {
   if (isConstantScalar(MI, MRI, AllowFP, AllowOpaqueConstants))
     return true;
 
   if (!isBuildVectorOp(MI.getOpcode()))
     return false;