[ConstantFolding] Use hasVectorInstrinsicScalarOpd. NFC

[bjope]

Summary

Use the hasVectorInstrinsicScalarOpd helper function
in ConstantFoldVectorCall.

[RKSimon]

LGTM

llvm/trunk/lib/Analysis/ConstantFolding.cpp

 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
+#include "llvm/Analysis/VectorUtils.h"
 #include "llvm/Config/config.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
static bool getConstIntOrUndef(Value *Op, const APInt *&C) {
   }
   if (isa<UndefValue>(Op)) {
     C = nullptr;
     return true;
   }
   return false;
 }
 
-static Constant *ConstantFoldScalarCall1(StringRef Name, unsigned IntrinsicID,
+static Constant *ConstantFoldScalarCall1(StringRef Name,
+                                         Intrinsic::ID IntrinsicID,
                                          Type *Ty,
                                          ArrayRef<Constant *> Operands,
                                          const TargetLibraryInfo *TLI,
                                          const CallBase *Call) {
   assert(Operands.size() == 1 && "Wrong number of operands.");
 
   if (IntrinsicID == Intrinsic::is_constant) {
     // We know we have a "Constant" argument. But we want to only
case Intrinsic::x86_sse2_cvttsd2si64:
                                            /*IsSigned*/true);
       break;
     }
   }
 
   return nullptr;
 }
 
-static Constant *ConstantFoldScalarCall2(StringRef Name, unsigned IntrinsicID,
+static Constant *ConstantFoldScalarCall2(StringRef Name,
+                                         Intrinsic::ID IntrinsicID,
                                          Type *Ty,
                                          ArrayRef<Constant *> Operands,
                                          const TargetLibraryInfo *TLI,
                                          const CallBase *Call) {
   assert(Operands.size() == 2 && "Wrong number of operands.");
 
   if (auto *Op1 = dyn_cast<ConstantFP>(Operands[0])) {
     if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy())
case Intrinsic::x86_avx512_cvttsd2usi64:
                                            /*roundTowardZero=*/true, Ty,
                                            /*IsSigned*/false);
       break;
     }
   }
   return nullptr;
 }
 
-static Constant *ConstantFoldScalarCall3(StringRef Name, unsigned IntrinsicID,
+static Constant *ConstantFoldScalarCall3(StringRef Name,
+                                         Intrinsic::ID IntrinsicID,
                                          Type *Ty,
                                          ArrayRef<Constant *> Operands,
                                          const TargetLibraryInfo *TLI,
                                          const CallBase *Call) {
   assert(Operands.size() == 3 && "Wrong number of operands.");
 
   if (const auto *Op1 = dyn_cast<ConstantFP>(Operands[0])) {
     if (const auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
if (IntrinsicID == Intrinsic::fshl || IntrinsicID == Intrinsic::fshr) {
     if (!C1)
       return ConstantInt::get(Ty, C0->shl(ShlAmt));
     return ConstantInt::get(Ty, C0->shl(ShlAmt) | C1->lshr(LshrAmt));
   }
 
   return nullptr;
 }
 
-static Constant *ConstantFoldScalarCall(StringRef Name, unsigned IntrinsicID,
+static Constant *ConstantFoldScalarCall(StringRef Name,
+                                        Intrinsic::ID IntrinsicID,
                                         Type *Ty,
                                         ArrayRef<Constant *> Operands,
                                         const TargetLibraryInfo *TLI,
                                         const CallBase *Call) {
   if (Operands.size() == 1)
     return ConstantFoldScalarCall1(Name, IntrinsicID, Ty, Operands, TLI, Call);
 
   if (Operands.size() == 2)
     return ConstantFoldScalarCall2(Name, IntrinsicID, Ty, Operands, TLI, Call);
 
   if (Operands.size() == 3)
     return ConstantFoldScalarCall3(Name, IntrinsicID, Ty, Operands, TLI, Call);
 
   return nullptr;
 }
 
-static Constant *ConstantFoldVectorCall(StringRef Name, unsigned IntrinsicID,
+static Constant *ConstantFoldVectorCall(StringRef Name,
+                                        Intrinsic::ID IntrinsicID,
                                         VectorType *VTy,
                                         ArrayRef<Constant *> Operands,
                                         const DataLayout &DL,
                                         const TargetLibraryInfo *TLI,
                                         const CallBase *Call) {
   SmallVector<Constant *, 4> Result(VTy->getNumElements());
   SmallVector<Constant *, 4> Lane(Operands.size());
   Type *Ty = VTy->getElementType();
if (IntrinsicID == Intrinsic::masked_load) {
     if (NewElements.size() != VTy->getNumElements())
       return nullptr;
     return ConstantVector::get(NewElements);
   }
 
   for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
     // Gather a column of constants.
     for (unsigned J = 0, JE = Operands.size(); J != JE; ++J) {
-      // These intrinsics use a scalar type for their second argument.
-      if (J == 1 &&
-          (IntrinsicID == Intrinsic::cttz || IntrinsicID == Intrinsic::ctlz ||
-           IntrinsicID == Intrinsic::powi)) {
-        Lane[J] = Operands[J];
-        continue;
-      }
-      // These intrinsics use a scalar type for their third argument.
-      if (J == 2 &&
-          (IntrinsicID == Intrinsic::smul_fix ||
-           IntrinsicID == Intrinsic::smul_fix_sat)) {
+      // Some intrinsics use a scalar type for certain arguments.
+      if (hasVectorInstrinsicScalarOpd(IntrinsicID, J)) {
         Lane[J] = Operands[J];
         continue;
       }
 
       Constant *Agg = Operands[J]->getAggregateElement(I);
       if (!Agg)
         return nullptr;