diff --git a/llvm/include/llvm/IR/Intrinsics.h b/llvm/include/llvm/IR/Intrinsics.h
--- a/llvm/include/llvm/IR/Intrinsics.h
+++ b/llvm/include/llvm/IR/Intrinsics.h
@@ -161,21 +161,37 @@
       AK_MatchType = 7
     };
 
+    /// Returns true if type of this argument or return value depends on the
+    /// type of other argument.
+    bool hasBoundType() const {
+      switch (Kind) {
+      case Argument:
+      case ExtendArgument:
+      case TruncArgument:
+      case HalfVecArgument:
+      case SameVecWidthArgument:
+      case PtrToArgument:
+      case PtrToElt:
+      case VecOfAnyPtrsToElt:
+      case VecElementArgument:
+      case Subdivide2Argument:
+      case Subdivide4Argument:
+      case VecOfBitcastsToInt:
+        return true;
+      default:
+        return false;
+      }
+      llvm_unreachable("unhandled");
+    }
+
     unsigned getArgumentNumber() const {
-      assert(Kind == Argument || Kind == ExtendArgument ||
-             Kind == TruncArgument || Kind == HalfVecArgument ||
-             Kind == SameVecWidthArgument || Kind == PtrToArgument ||
-             Kind == PtrToElt || Kind == VecElementArgument ||
-             Kind == Subdivide2Argument || Kind == Subdivide4Argument ||
-             Kind == VecOfBitcastsToInt);
+      assert(hasBoundType() && Kind != VecOfAnyPtrsToElt &&
+             "This descriptor does not have argument number");
       return Argument_Info >> 3;
     }
     ArgKind getArgumentKind() const {
-      assert(Kind == Argument || Kind == ExtendArgument ||
-             Kind == TruncArgument || Kind == HalfVecArgument ||
-             Kind == SameVecWidthArgument || Kind == PtrToArgument ||
-             Kind == VecElementArgument || Kind == Subdivide2Argument ||
-             Kind == Subdivide4Argument || Kind == VecOfBitcastsToInt);
+      assert(hasBoundType() && Kind != VecOfAnyPtrsToElt &&
+             "This descriptor does not have argument kind");
       return (ArgKind)(Argument_Info & 7);
     }
 
@@ -213,6 +229,13 @@
   /// of IITDescriptors.
   void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl<IITDescriptor> &T);
 
+  /// Given the IIT table descriptor skips the descriptors corresponding to one
+  /// type element (either return value or an argument).
+  ///
+  /// The function is used to iterate through intrinsic description without
+  /// building types.
+  void popFirstElement(ArrayRef<Intrinsic::IITDescriptor> &Infos);
+
   enum MatchIntrinsicTypesResult {
     MatchIntrinsicTypes_Match = 0,
     MatchIntrinsicTypes_NoMatchRet = 1,
diff --git a/llvm/lib/IR/Function.cpp b/llvm/lib/IR/Function.cpp
--- a/llvm/lib/IR/Function.cpp
+++ b/llvm/lib/IR/Function.cpp
@@ -1231,6 +1231,49 @@
     DecodeIITType(NextElt, IITEntries, IIT_Done, T);
 }
 
+void Intrinsic::popFirstElement(ArrayRef<Intrinsic::IITDescriptor> &Infos) {
+  assert(!Infos.empty() && "Descriptor array must not be empty");
+
+  IITDescriptor D = Infos.front();
+  Infos = Infos.slice(1);
+  switch (D.Kind) {
+  case IITDescriptor::Void:
+  case IITDescriptor::VarArg:
+  case IITDescriptor::MMX:
+  case IITDescriptor::AMX:
+  case IITDescriptor::Token:
+  case IITDescriptor::Metadata:
+  case IITDescriptor::Half:
+  case IITDescriptor::BFloat:
+  case IITDescriptor::Float:
+  case IITDescriptor::Double:
+  case IITDescriptor::Quad:
+  case IITDescriptor::Integer:
+  case IITDescriptor::Argument:
+  case IITDescriptor::ExtendArgument:
+  case IITDescriptor::TruncArgument:
+  case IITDescriptor::Subdivide2Argument:
+  case IITDescriptor::Subdivide4Argument:
+  case IITDescriptor::HalfVecArgument:
+  case IITDescriptor::PtrToArgument:
+  case IITDescriptor::PtrToElt:
+  case IITDescriptor::VecElementArgument:
+  case IITDescriptor::VecOfBitcastsToInt:
+  case IITDescriptor::VecOfAnyPtrsToElt:
+    return;
+  case IITDescriptor::Vector:
+  case IITDescriptor::Pointer:
+  case IITDescriptor::SameVecWidthArgument:
+    popFirstElement(Infos);
+    return;
+  case IITDescriptor::Struct:
+    for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
+      popFirstElement(Infos);
+    return;
+  }
+  llvm_unreachable("Unhandled argument descriptor");
+}
+
 static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos,
                              ArrayRef<Type*> Tys, LLVMContext &Context) {
   using namespace Intrinsic;
diff --git a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
--- a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
+++ b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
@@ -5532,21 +5532,52 @@
       bool UseIntrinsic = ID != Intrinsic::not_intrinsic &&
                           VecCallCosts.first <= VecCallCosts.second;
 
+      SmallVector<Intrinsic::IITDescriptor, 8> Table;
+      ArrayRef<Intrinsic::IITDescriptor> TableRef;
+      if (UseIntrinsic) {
+        getIntrinsicInfoTableEntries(ID, Table);
+        TableRef = Table;
+      }
+      SmallVector<Type *, 2> TysForDecl;
+
+      const auto UpdateTysForDecl = [&](Value *V, bool IsScalar) {
+        if (!UseIntrinsic)
+          return;
+        const Intrinsic::IITDescriptor &Item = TableRef.front();
+        switch (Item.Kind) {
+        case Intrinsic::IITDescriptor::Argument:
+          if (Item.getArgumentNumber() >= TysForDecl.size()) {
+            if (IsScalar)
+              TysForDecl.push_back(V->getType());
+            else
+              TysForDecl.push_back(
+                  FixedVectorType::get(V->getType(), E->Scalars.size()));
+          }
+          break;
+        case Intrinsic::IITDescriptor::SameVecWidthArgument:
+          break;
+        default:
+          assert(!Item.hasBoundType());
+        }
+        popFirstElement(TableRef);
+      };
+
+      UpdateTysForDecl(CI, false);
       Value *ScalarArg = nullptr;
       std::vector<Value *> OpVecs;
-      SmallVector<Type *, 2> TysForDecl =
-          {FixedVectorType::get(CI->getType(), E->Scalars.size())};
       for (int j = 0, e = CI->getNumArgOperands(); j < e; ++j) {
-        ValueList OpVL;
-        // Some intrinsics have scalar arguments. This argument should not be
-        // vectorized.
-        if (UseIntrinsic && hasVectorInstrinsicScalarOpd(IID, j)) {
-          CallInst *CEI = cast<CallInst>(VL0);
-          ScalarArg = CEI->getArgOperand(j);
-          OpVecs.push_back(CEI->getArgOperand(j));
-          if (hasVectorInstrinsicOverloadedScalarOpd(IID, j))
-            TysForDecl.push_back(ScalarArg->getType());
-          continue;
+        if (UseIntrinsic) {
+          // Some intrinsics have scalar arguments. This argument should not be
+          // vectorized.
+          bool IsScalar = hasVectorInstrinsicScalarOpd(IID, j);
+          if (IsScalar) {
+            CallInst *CEI = cast<CallInst>(VL0);
+            ScalarArg = CEI->getArgOperand(j);
+            OpVecs.push_back(CEI->getArgOperand(j));
+          }
+          UpdateTysForDecl(CI->getArgOperand(j), IsScalar);
+          if (IsScalar)
+            continue;
         }
 
         Value *OpVec = vectorizeTree(E->getOperand(j));