diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -498,6 +498,9 @@
 
 protected:
   friend class LoopVectorizationPlanner;
+  // Allow VPTransformState to expose a few ILV helper functions during the
+  // transition period.
+  friend struct VPTransformState;
 
   /// A small list of PHINodes.
   using PhiVector = SmallVector<PHINode *, 4>;
@@ -6576,9 +6579,10 @@
   // 1. Create a new empty loop. Unlink the old loop and connect the new one.
   VPCallbackILV CallbackILV(ILV);
 
-  VPTransformState State{BestVF, BestUF,      LI,
-                         DT,     ILV.Builder, ILV.VectorLoopValueMap,
-                         &ILV,   CallbackILV};
+  VPTransformState State{BestVF,       BestUF,      LI,
+                         DT,           TLI,         ILV.PSE,
+                         ILV.OrigLoop, ILV.Builder, ILV.VectorLoopValueMap,
+                         &ILV,         CallbackILV};
   State.CFG.PrevBB = ILV.createVectorizedLoopSkeleton();
   State.TripCount = ILV.getOrCreateTripCount(nullptr);
 
@@ -7353,6 +7357,20 @@
   return ILV.getOrCreateScalarValue(V, Instance);
 }
 
+void LoopVectorizationPlanner::VPCallbackILV::setVectorValue(Value *Key,
+                                                             unsigned Part,
+                                                             Value *Vector) {
+  return ILV.VectorLoopValueMap.setVectorValue(Key, Part, Vector);
+}
+
+void VPTransformState::addMetadata(ArrayRef<Value *> To, Instruction *From) {
+  ILV->addMetadata(To, From);
+}
+
+void VPTransformState::setDebugLocFromInst(IRBuilder<> &B, const Value *Ptr) {
+  ILV->setDebugLocFromInst(B, Ptr);
+}
+
 void VPInterleaveRecipe::print(raw_ostream &O, const Twine &Indent,
                                VPSlotTracker &SlotTracker) const {
   O << " +\n"
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -52,6 +52,7 @@
 class LoopVectorizationCostModel;
 class BasicBlock;
 class DominatorTree;
+class TargetTransformInfo;
 class InnerLoopVectorizer;
 template <class T> class InterleaveGroup;
 class LoopInfo;
@@ -235,10 +236,13 @@
 /// needed for generating the output IR.
 struct VPTransformState {
   VPTransformState(unsigned VF, unsigned UF, LoopInfo *LI, DominatorTree *DT,
-                   IRBuilder<> &Builder, VectorizerValueMap &ValueMap,
-                   InnerLoopVectorizer *ILV, VPCallback &Callback)
-      : VF(VF), UF(UF), Instance(), LI(LI), DT(DT), Builder(Builder),
-        ValueMap(ValueMap), ILV(ILV), Callback(Callback) {}
+                   const TargetLibraryInfo *TLI, PredicatedScalarEvolution &PSE,
+                   Loop *OriginalLoop, IRBuilder<> &Builder,
+                   VectorizerValueMap &ValueMap, InnerLoopVectorizer *ILV,
+                   VPCallback &Callback)
+      : VF(VF), UF(UF), Instance(), LI(LI), DT(DT), TLI(TLI), PSE(PSE),
+        OriginalLoop(OriginalLoop), Builder(Builder), ValueMap(ValueMap),
+        ILV(ILV), Callback(Callback) {}
 
   /// The chosen Vectorization and Unroll Factors of the loop being vectorized.
   unsigned VF;
@@ -287,6 +291,14 @@
     Data.PerPartOutput[Def][Part] = V;
   }
 
+  void addMetadata(ArrayRef<Value *> To, Instruction *From);
+
+  void setDebugLocFromInst(IRBuilder<> &B, const Value *Ptr);
+
+  unsigned getVectorCallCost(CallInst *CI, unsigned VF, bool &NeedToScalarize);
+
+  unsigned getVectorIntrinsicCost(CallInst *CI, unsigned VF);
+
   /// Hold state information used when constructing the CFG of the output IR,
   /// traversing the VPBasicBlocks and generating corresponding IR BasicBlocks.
   struct CFGState {
@@ -318,6 +330,12 @@
   /// Hold a pointer to Dominator Tree to register new basic blocks in the loop.
   DominatorTree *DT;
 
+  const TargetLibraryInfo *TLI;
+
+  PredicatedScalarEvolution &PSE;
+
+  Loop *OriginalLoop;
+
   /// Hold a reference to the IRBuilder used to generate output IR code.
   IRBuilder<> &Builder;