diff --git a/llvm/include/llvm/ADT/SmallVector.h b/llvm/include/llvm/ADT/SmallVector.h
--- a/llvm/include/llvm/ADT/SmallVector.h
+++ b/llvm/include/llvm/ADT/SmallVector.h
@@ -1274,6 +1274,10 @@
     typename std::remove_const<typename std::remove_reference<
         decltype(*std::begin(std::declval<RangeType &>()))>::type>::type;
 
+template <class RangeType>
+using InlineSize = CalculateSmallVectorDefaultInlinedElements<
+    ValueTypeFromRangeType<RangeType>>;
+
 /// Given a range of type R, iterate the entire range and return a
 /// SmallVector with elements of the vector.  This is useful, for example,
 /// when you want to iterate a range and then sort the results.
@@ -1281,14 +1285,23 @@
 SmallVector<ValueTypeFromRangeType<R>, Size> to_vector(R &&Range) {
   return {std::begin(Range), std::end(Range)};
 }
+
 template <typename R>
-SmallVector<ValueTypeFromRangeType<R>,
-            CalculateSmallVectorDefaultInlinedElements<
-                ValueTypeFromRangeType<R>>::value>
+SmallVector<ValueTypeFromRangeType<R>, InlineSize<R>::value>
 to_vector(R &&Range) {
   return {std::begin(Range), std::end(Range)};
 }
 
+template <typename Out, unsigned Size, typename R>
+SmallVector<Out, Size> to_vector_of(R &&Range) {
+  return {std::begin(Range), std::end(Range)};
+}
+
+template <typename Out, typename R>
+SmallVector<Out, InlineSize<R>::value> to_vector_of(R &&Range) {
+  return {std::begin(Range), std::end(Range)};
+}
+
 } // end namespace llvm
 
 namespace std {
diff --git a/llvm/include/llvm/IR/Metadata.h b/llvm/include/llvm/IR/Metadata.h
--- a/llvm/include/llvm/IR/Metadata.h
+++ b/llvm/include/llvm/IR/Metadata.h
@@ -1345,9 +1345,8 @@
                           StorageType Storage, bool ShouldCreate = true);
 
   TempMDTuple cloneImpl() const {
-    ArrayRef<MDOperand> Operands = operands();
-    return getTemporary(getContext(), SmallVector<Metadata *, 4>(
-                                          Operands.begin(), Operands.end()));
+    return getTemporary(getContext(),
+                        llvm::to_vector_of<Metadata *, 4>(operands()));
   }
 
 public:
diff --git a/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp b/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp
--- a/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp
+++ b/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp
@@ -811,8 +811,7 @@
     return nullptr;
 
   // Otherwise, create TBAA with the new Len
-  ArrayRef<MDOperand> MDOperands = MD->operands();
-  SmallVector<Metadata *, 4> NextNodes(MDOperands.begin(), MDOperands.end());
+  auto NextNodes = llvm::to_vector_of<Metadata *, 4>(MD->operands());
   ConstantInt *PreviousSize = mdconst::extract<ConstantInt>(NextNodes[3]);
 
   // Don't create a new MDNode if it is the same length.
diff --git a/llvm/lib/Linker/IRMover.cpp b/llvm/lib/Linker/IRMover.cpp
--- a/llvm/lib/Linker/IRMover.cpp
+++ b/llvm/lib/Linker/IRMover.cpp
@@ -1362,10 +1362,9 @@
              "Expected MDTuple when appending module flags");
       if (DstValue->isDistinct())
         return dyn_cast<MDTuple>(DstValue);
-      ArrayRef<MDOperand> DstOperands = DstValue->operands();
       MDTuple *New = MDTuple::getDistinct(
           DstM.getContext(),
-          SmallVector<Metadata *, 4>(DstOperands.begin(), DstOperands.end()));
+          llvm::to_vector_of<Metadata *, 4>(DstValue->operands()));
       Metadata *FlagOps[] = {DstOp->getOperand(0), ID, New};
       MDNode *Flag = MDTuple::getDistinct(DstM.getContext(), FlagOps);
       DstModFlags->setOperand(DstIndex, Flag);
diff --git a/llvm/tools/llvm-rc/ResourceScriptStmt.h b/llvm/tools/llvm-rc/ResourceScriptStmt.h
--- a/llvm/tools/llvm-rc/ResourceScriptStmt.h
+++ b/llvm/tools/llvm-rc/ResourceScriptStmt.h
@@ -817,7 +817,7 @@
     VersionInfoFixed() : IsTypePresent(FtNumTypes, false) {}
 
     void setValue(VersionInfoFixedType Type, ArrayRef<uint32_t> Value) {
-      FixedInfo[Type] = SmallVector<uint32_t, 4>(Value.begin(), Value.end());
+      FixedInfo[Type] = llvm::to_vector_of<uint32_t, 4>(Value);
       IsTypePresent[Type] = true;
     }
 
diff --git a/llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp b/llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp
--- a/llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp
+++ b/llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp
@@ -125,7 +125,7 @@
     return {};
   ArrayRef<uint8_t> BuildID(reinterpret_cast<const uint8_t *>(Bytes.data()),
                             Bytes.size());
-  return SmallVector<uint8_t>(BuildID.begin(), BuildID.end());
+  return llvm::to_vector_of<uint8_t>(BuildID);
 }
 
 static bool parseCommand(StringRef BinaryName, bool IsAddr2Line,
diff --git a/llvm/unittests/ADT/SmallVectorTest.cpp b/llvm/unittests/ADT/SmallVectorTest.cpp
--- a/llvm/unittests/ADT/SmallVectorTest.cpp
+++ b/llvm/unittests/ADT/SmallVectorTest.cpp
@@ -1134,6 +1134,87 @@
   EXPECT_TRUE(makeArrayRef(V2).equals({4, 5, 3, 2}));
 }
 
+TEST(SmallVectorTest, ToVector) {
+  {
+    std::vector<char> v = {'a', 'b', 'c'};
+    auto Vector = to_vector<4>(v);
+    ASSERT_EQ(4u, this->NumBuiltinElts(Vector));
+    ASSERT_EQ(3u, Vector.size());
+    for (size_t I = 0; I < v.size(); ++I) {
+      EXPECT_EQ(v[I], Vector[I]);
+    }
+  }
+  {
+    std::vector<char> v = {'a', 'b', 'c'};
+    auto Vector = to_vector(v);
+    ASSERT_NE(4u, this->NumBuiltinElts(Vector));
+    ASSERT_EQ(3u, Vector.size());
+    for (size_t I = 0; I < v.size(); ++I) {
+      EXPECT_EQ(v[I], Vector[I]);
+    }
+  }
+}
+
+TEST(SmallVectorTest, ToVectorOf) {
+  struct Metadata {
+    int content;
+  };
+
+  class MDOperand {
+  public:
+    MDOperand(int content) : metadata{content} {}
+    operator Metadata *() { return get(); }
+
+  private:
+    Metadata *get() { return &metadata; }
+    Metadata metadata;
+  };
+
+  std::vector<MDOperand> Operands = {MDOperand(1), MDOperand(2), MDOperand(3)};
+  {
+    llvm::SmallVector<Metadata *> Metadatas =
+        llvm::to_vector_of<Metadata *>(Operands);
+
+    ASSERT_EQ(Operands.size(), Metadatas.size());
+    for (size_t I = 0; I < Operands.size(); ++I) {
+      EXPECT_EQ(Operands[I]->get(), Metadatas[I]);
+      EXPECT_EQ(Operands[I], *Metadatas[I]);
+    }
+  }
+  {
+    ArrayRef<MDOperand> ArrayOperands = Operands;
+    llvm::SmallVector<Metadata *> Metadatas =
+        llvm::to_vector_of<Metadata *>(ArrayOperands);
+
+    ASSERT_EQ(ArrayOperands.size(), Metadatas.size());
+    for (size_t I = 0; I < ArrayOperands.size(); ++I) {
+      EXPECT_EQ(ArrayOperands[I]->get(), Metadatas[I]);
+      EXPECT_EQ(ArrayOperands[I], *Metadatas[I]);
+    }
+  }
+  {
+    auto Metadatas = llvm::to_vector_of<Metadata *, 4>(Operands);
+
+    ASSERT_EQ(Operands.size(), Metadatas.size());
+    ASSERT_EQ(4u, this->NumBuiltinElts(Metadatas));
+    for (size_t I = 0; I < Operands.size(); ++I) {
+      EXPECT_EQ(Operands[I]->get(), Metadatas[I]);
+      EXPECT_EQ(Operands[I], *Metadatas[I]);
+    }
+  }
+  {
+    ArrayRef<MDOperand> ArrayOperands = Operands;
+    auto Metadatas = llvm::to_vector_of<Metadata *, 4>(ArrayOperands);
+
+    ASSERT_EQ(ArrayOperands.size(), Metadatas.size());
+    ASSERT_EQ(4u, this->NumBuiltinElts(Metadatas));
+    for (size_t I = 0; I < ArrayOperands.size(); ++I) {
+      EXPECT_EQ(ArrayOperands[I]->get(), Metadatas[I]);
+      EXPECT_EQ(ArrayOperands[I], *Metadatas[I]);
+    }
+  }
+}
+
 template <class VectorT>
 class SmallVectorReferenceInvalidationTest : public SmallVectorTestBase {
 protected:
diff --git a/llvm/unittests/Analysis/VectorUtilsTest.cpp b/llvm/unittests/Analysis/VectorUtilsTest.cpp
--- a/llvm/unittests/Analysis/VectorUtilsTest.cpp
+++ b/llvm/unittests/Analysis/VectorUtilsTest.cpp
@@ -507,8 +507,7 @@
   }
 
   bool validParams(ArrayRef<VFParameter> Parameters) {
-    Shape.Parameters =
-        SmallVector<VFParameter, 8>(Parameters.begin(), Parameters.end());
+    Shape.Parameters = llvm::to_vector_of<VFParameter, 8>(Parameters);
     return Shape.hasValidParameterList();
   }
 };