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
@@ -7793,12 +7793,11 @@
               RecipeBuilder.tryToCreateWidenRecipe(Instr, Range, Plan)) {
         // Check if the recipe can be converted to a VPValue. We need the extra
         // down-casting step until VPRecipeBase inherits from VPValue.
-        VPValue *MaybeVPValue = Recipe->toVPValue();
-        if (!Instr->getType()->isVoidTy() && MaybeVPValue) {
+        if (!Instr->getType()->isVoidTy() && !Recipe->isVirtual()) {
           if (NeedDef.contains(Instr))
-            Plan->addOrReplaceVPValue(Instr, MaybeVPValue);
+            Plan->addOrReplaceVPValue(Instr, Recipe);
           else
-            Plan->addVPValue(Instr, MaybeVPValue);
+            Plan->addVPValue(Instr, Recipe);
         }
 
         RecipeBuilder.setRecipe(Instr, Recipe);
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
@@ -607,7 +607,7 @@
 /// VPRecipeBase is a base class modeling a sequence of one or more output IR
 /// instructions.
 class VPRecipeBase : public ilist_node_with_parent<VPRecipeBase, VPBasicBlock>,
-                     public VPValue {
+                     public VPUser {
   friend VPBasicBlock;
   friend class VPBlockUtils;
 
@@ -615,7 +615,14 @@
   VPBasicBlock *Parent = nullptr;
 
 public:
-  VPRecipeBase(const unsigned char SC, Value *V = nullptr) : VPValue(SC, V) {}
+  VPRecipeBase(const unsigned char SC, ArrayRef<VPValue *> Operands,
+               Value *V = nullptr)
+      : VPUser(SC, Operands, V) {}
+
+  template <typename IterT>
+  VPRecipeBase(const unsigned char SC, iterator_range<IterT> Operands,
+               Value *V = nullptr)
+      : VPUser(SC, Operands, V) {}
   virtual ~VPRecipeBase() = default;
 
   /// \return the VPBasicBlock which this VPRecipe belongs to.
@@ -653,34 +660,13 @@
   ///
   /// \returns an iterator pointing to the element after the erased one
   iplist<VPRecipeBase>::iterator eraseFromParent();
-
-  /// Returns a pointer to a VPUser, if the recipe inherits from VPUser or
-  /// nullptr otherwise.
-  VPUser *toVPUser();
-
-  /// Returns a pointer to a VPValue, if the recipe inherits from VPValue or
-  /// nullptr otherwise.
-  VPValue *toVPValue();
 };
 
-inline bool VPUser::classof(const VPRecipeBase *Recipe) {
-  return Recipe->getVPValueID() == VPRecipeBase::VPInstructionSC ||
-         Recipe->getVPValueID() == VPRecipeBase::VPWidenSC ||
-         Recipe->getVPValueID() == VPRecipeBase::VPWidenCallSC ||
-         Recipe->getVPValueID() == VPRecipeBase::VPWidenSelectSC ||
-         Recipe->getVPValueID() == VPRecipeBase::VPWidenGEPSC ||
-         Recipe->getVPValueID() == VPRecipeBase::VPBlendSC ||
-         Recipe->getVPValueID() == VPRecipeBase::VPInterleaveSC ||
-         Recipe->getVPValueID() == VPRecipeBase::VPReplicateSC ||
-         Recipe->getVPValueID() == VPRecipeBase::VPBranchOnMaskSC ||
-         Recipe->getVPValueID() == VPRecipeBase::VPWidenMemoryInstructionSC;
-}
-
 /// This is a concrete Recipe that models a single VPlan-level instruction.
 /// While as any Recipe it may generate a sequence of IR instructions when
 /// executed, these instructions would always form a single-def expression as
 /// the VPInstruction is also a single def-use vertex.
-class VPInstruction : public VPUser, public VPRecipeBase {
+class VPInstruction : public VPRecipeBase {
   friend class VPlanSlp;
 
 public:
@@ -710,8 +696,7 @@
 
 public:
   VPInstruction(unsigned Opcode, ArrayRef<VPValue *> Operands)
-      : VPUser(Operands), VPRecipeBase(VPValue::VPInstructionSC),
-        Opcode(Opcode) {}
+      : VPRecipeBase(VPValue::VPInstructionSC, Operands), Opcode(Opcode) {}
 
   VPInstruction(unsigned Opcode, std::initializer_list<VPValue *> Operands)
       : VPInstruction(Opcode, ArrayRef<VPValue *>(Operands)) {}
@@ -773,14 +758,14 @@
 /// VPWidenRecipe is a recipe for producing a copy of vector type its
 /// ingredient. This recipe covers most of the traditional vectorization cases
 /// where each ingredient transforms into a vectorized version of itself.
-class VPWidenRecipe : public VPRecipeBase, public VPUser {
+class VPWidenRecipe : public VPRecipeBase {
   /// Hold the instruction to be widened.
   Instruction &Ingredient;
 
 public:
   template <typename IterT>
   VPWidenRecipe(Instruction &I, iterator_range<IterT> Operands)
-      : VPRecipeBase(VPWidenSC), VPUser(Operands), Ingredient(I) {}
+      : VPRecipeBase(VPWidenSC, Operands, &I), Ingredient(I) {}
 
   ~VPWidenRecipe() override = default;
 
@@ -798,12 +783,12 @@
 };
 
 /// A recipe for widening Call instructions.
-class VPWidenCallRecipe : public VPRecipeBase, public VPUser {
+class VPWidenCallRecipe : public VPRecipeBase {
 
 public:
   template <typename IterT>
   VPWidenCallRecipe(CallInst &I, iterator_range<IterT> CallArguments)
-      : VPRecipeBase(VPWidenCallSC, &I), VPUser(CallArguments) {}
+      : VPRecipeBase(VPWidenCallSC, CallArguments, &I) {}
 
   ~VPWidenCallRecipe() override = default;
 
@@ -826,7 +811,7 @@
 };
 
 /// A recipe for widening select instructions.
-class VPWidenSelectRecipe : public VPRecipeBase, public VPUser {
+class VPWidenSelectRecipe : public VPRecipeBase {
 
   /// Is the condition of the select loop invariant?
   bool InvariantCond;
@@ -835,7 +820,7 @@
   template <typename IterT>
   VPWidenSelectRecipe(SelectInst &I, iterator_range<IterT> Operands,
                       bool InvariantCond)
-      : VPRecipeBase(VPValue::VPWidenSelectSC, &I), VPUser(Operands),
+      : VPRecipeBase(VPValue::VPWidenSelectSC, Operands, &I),
         InvariantCond(InvariantCond) {}
 
   ~VPWidenSelectRecipe() override = default;
@@ -858,7 +843,7 @@
 };
 
 /// A recipe for handling GEP instructions.
-class VPWidenGEPRecipe : public VPRecipeBase, public VPUser {
+class VPWidenGEPRecipe : public VPRecipeBase {
   GetElementPtrInst *GEP;
 
   bool IsPtrLoopInvariant;
@@ -867,13 +852,13 @@
 public:
   template <typename IterT>
   VPWidenGEPRecipe(GetElementPtrInst *GEP, iterator_range<IterT> Operands)
-      : VPRecipeBase(VPWidenGEPSC), VPUser(Operands), GEP(GEP),
+      : VPRecipeBase(VPWidenGEPSC, Operands, GEP), GEP(GEP),
         IsIndexLoopInvariant(GEP->getNumIndices(), false) {}
 
   template <typename IterT>
   VPWidenGEPRecipe(GetElementPtrInst *GEP, iterator_range<IterT> Operands,
                    Loop *OrigLoop)
-      : VPRecipeBase(VPValue::VPWidenGEPSC, GEP), VPUser(Operands),
+      : VPRecipeBase(VPValue::VPWidenGEPSC, Operands, GEP),
         IsIndexLoopInvariant(GEP->getNumIndices(), false) {
     IsPtrLoopInvariant = OrigLoop->isLoopInvariant(GEP->getPointerOperand());
     for (auto Index : enumerate(GEP->indices()))
@@ -910,7 +895,7 @@
 
 public:
   VPWidenIntOrFpInductionRecipe(PHINode *IV, TruncInst *Trunc = nullptr)
-      : VPRecipeBase(VPWidenIntOrFpInductionSC), IV(IV), Trunc(Trunc) {}
+      : VPRecipeBase(VPWidenIntOrFpInductionSC, {}, IV), IV(IV), Trunc(Trunc) {}
   ~VPWidenIntOrFpInductionRecipe() override = default;
 
   /// Method to support type inquiry through isa, cast, and dyn_cast.
@@ -932,7 +917,8 @@
   PHINode *Phi;
 
 public:
-  VPWidenPHIRecipe(PHINode *Phi) : VPRecipeBase(VPWidenPHISC), Phi(Phi) {}
+  VPWidenPHIRecipe(PHINode *Phi)
+      : VPRecipeBase(VPWidenPHISC, {}, Phi), Phi(Phi) {}
   ~VPWidenPHIRecipe() override = default;
 
   /// Method to support type inquiry through isa, cast, and dyn_cast.
@@ -950,7 +936,7 @@
 
 /// A recipe for vectorizing a phi-node as a sequence of mask-based select
 /// instructions.
-class VPBlendRecipe : public VPRecipeBase, public VPUser {
+class VPBlendRecipe : public VPRecipeBase {
   PHINode *Phi;
 
 public:
@@ -958,7 +944,7 @@
   /// respective masks, ordered [I0, M0, I1, M1, ...]. Note that a single value
   /// might be incoming with a full mask for which there is no VPValue.
   VPBlendRecipe(PHINode *Phi, ArrayRef<VPValue *> Operands)
-      : VPRecipeBase(VPBlendSC), VPUser(Operands), Phi(Phi) {
+      : VPRecipeBase(VPBlendSC, Operands, Phi), Phi(Phi) {
     assert(Operands.size() > 0 &&
            ((Operands.size() == 1) || (Operands.size() % 2 == 0)) &&
            "Expected either a single incoming value or a positive even number "
@@ -990,7 +976,7 @@
 
 /// VPInterleaveRecipe is a recipe for transforming an interleave group of load
 /// or stores into one wide load/store and shuffles.
-class VPInterleaveRecipe : public VPRecipeBase, public VPUser {
+class VPInterleaveRecipe : public VPRecipeBase {
   const InterleaveGroup<Instruction> *IG;
 
 public:
@@ -998,7 +984,7 @@
 
   VPInterleaveRecipe(const InterleaveGroup<Instruction> *IG, VPValue *Addr,
                      VPValue *Mask)
-      : VPRecipeBase(VPValue::VPInterleaveSC), VPUser({Addr}), IG(IG) {
+      : VPRecipeBase(VPValue::VPInterleaveSC, {Addr}), IG(IG) {
     if (Mask)
       addOperand(Mask);
     for (unsigned i = 0; i < IG->getNumMembers(); i++)
@@ -1055,7 +1041,7 @@
 public:
   VPReductionRecipe(RecurrenceDescriptor *R, Instruction *I, VPValue *ChainOp,
                     VPValue *VecOp, bool NoNaN, const TargetTransformInfo *TTI)
-      : VPRecipeBase(VPReductionSC), RdxDesc(R), I(I), VecOp(VecOp),
+      : VPRecipeBase(VPReductionSC, {}, I), RdxDesc(R), I(I), VecOp(VecOp),
         ChainOp(ChainOp), NoNaN(NoNaN), TTI(TTI) {}
 
   ~VPReductionRecipe() override = default;
@@ -1077,7 +1063,7 @@
 /// copies of the original scalar type, one per lane, instead of producing a
 /// single copy of widened type for all lanes. If the instruction is known to be
 /// uniform only one copy, per lane zero, will be generated.
-class VPReplicateRecipe : public VPRecipeBase, public VPUser {
+class VPReplicateRecipe : public VPRecipeBase {
   /// The instruction being replicated.
   Instruction *Ingredient;
 
@@ -1094,7 +1080,7 @@
   template <typename IterT>
   VPReplicateRecipe(Instruction *I, iterator_range<IterT> Operands,
                     bool IsUniform, bool IsPredicated = false)
-      : VPRecipeBase(VPReplicateSC), VPUser(Operands), Ingredient(I),
+      : VPRecipeBase(VPReplicateSC, Operands, I), Ingredient(I),
         IsUniform(IsUniform), IsPredicated(IsPredicated) {
     // Retain the previous behavior of predicateInstructions(), where an
     // insert-element of a predicated instruction got hoisted into the
@@ -1124,9 +1110,10 @@
 };
 
 /// A recipe for generating conditional branches on the bits of a mask.
-class VPBranchOnMaskRecipe : public VPRecipeBase, public VPUser {
+class VPBranchOnMaskRecipe : public VPRecipeBase {
 public:
-  VPBranchOnMaskRecipe(VPValue *BlockInMask) : VPRecipeBase(VPBranchOnMaskSC) {
+  VPBranchOnMaskRecipe(VPValue *BlockInMask)
+      : VPRecipeBase(VPBranchOnMaskSC, {}) {
     if (BlockInMask) // nullptr means all-one mask.
       addOperand(BlockInMask);
   }
@@ -1172,7 +1159,7 @@
   /// Construct a VPPredInstPHIRecipe given \p PredInst whose value needs a phi
   /// nodes after merging back from a Branch-on-Mask.
   VPPredInstPHIRecipe(Instruction *PredInst)
-      : VPRecipeBase(VPPredInstPHISC), PredInst(PredInst) {}
+      : VPRecipeBase(VPPredInstPHISC, {}, PredInst), PredInst(PredInst) {}
   ~VPPredInstPHIRecipe() override = default;
 
   /// Method to support type inquiry through isa, cast, and dyn_cast.
@@ -1194,7 +1181,7 @@
 /// - For store: Address, stored value, optional mask
 /// TODO: We currently execute only per-part unless a specific instance is
 /// provided.
-class VPWidenMemoryInstructionRecipe : public VPRecipeBase, public VPUser {
+class VPWidenMemoryInstructionRecipe : public VPRecipeBase {
 
   void setMask(VPValue *Mask) {
     if (!Mask)
@@ -1209,14 +1196,13 @@
 
 public:
   VPWidenMemoryInstructionRecipe(LoadInst &Load, VPValue *Addr, VPValue *Mask)
-      : VPRecipeBase(VPWidenMemoryInstructionSC, &Load), VPUser({Addr}) {
+      : VPRecipeBase(VPWidenMemoryInstructionSC, Addr, &Load) {
     setMask(Mask);
   }
 
   VPWidenMemoryInstructionRecipe(StoreInst &Store, VPValue *Addr,
                                  VPValue *StoredValue, VPValue *Mask)
-      : VPRecipeBase(VPWidenMemoryInstructionSC, &Store),
-        VPUser({Addr, StoredValue}) {
+      : VPRecipeBase(VPWidenMemoryInstructionSC, {Addr, StoredValue}, &Store) {
     setMask(Mask);
   }
 
@@ -1265,7 +1251,7 @@
   VPValue Val;
 
 public:
-  VPWidenCanonicalIVRecipe() : VPRecipeBase(VPWidenCanonicalIVSC) {}
+  VPWidenCanonicalIVRecipe() : VPRecipeBase(VPWidenCanonicalIVSC, {}) {}
   ~VPWidenCanonicalIVRecipe() override = default;
 
   /// Return the VPValue representing the canonical vector induction variable of
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.cpp b/llvm/lib/Transforms/Vectorize/VPlan.cpp
--- a/llvm/lib/Transforms/Vectorize/VPlan.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlan.cpp
@@ -77,43 +77,6 @@
   dbgs() << "\n";
 }
 
-VPUser *VPRecipeBase::toVPUser() {
-  if (auto *U = dyn_cast<VPInstruction>(this))
-    return U;
-  if (auto *U = dyn_cast<VPWidenRecipe>(this))
-    return U;
-  if (auto *U = dyn_cast<VPWidenCallRecipe>(this))
-    return U;
-  if (auto *U = dyn_cast<VPWidenSelectRecipe>(this))
-    return U;
-  if (auto *U = dyn_cast<VPWidenGEPRecipe>(this))
-    return U;
-  if (auto *U = dyn_cast<VPBlendRecipe>(this))
-    return U;
-  if (auto *U = dyn_cast<VPInterleaveRecipe>(this))
-    return U;
-  if (auto *U = dyn_cast<VPReplicateRecipe>(this))
-    return U;
-  if (auto *U = dyn_cast<VPBranchOnMaskRecipe>(this))
-    return U;
-  if (auto *U = dyn_cast<VPWidenMemoryInstructionRecipe>(this))
-    return U;
-  return nullptr;
-}
-
-VPValue *VPRecipeBase::toVPValue() {
-  if (auto *Widen = dyn_cast<VPInstruction>(this))
-    return Widen;
-  if (auto *Widen = dyn_cast<VPWidenMemoryInstructionRecipe>(this))
-    return Widen;
-  if (auto *V = dyn_cast<VPWidenCallRecipe>(this))
-    return V;
-  if (auto *V = dyn_cast<VPWidenSelectRecipe>(this))
-    return V;
-  if (auto *V = dyn_cast<VPWidenGEPRecipe>(this))
-    return V;
-  return nullptr;
-}
 // Get the top-most entry block of \p Start. This is the entry block of the
 // containing VPlan. This function is templated to support both const and non-const blocks
 template <typename T> static T *getPlanEntry(T *Start) {
@@ -327,12 +290,9 @@
 
 void VPBasicBlock::dropAllReferences(VPValue *NewValue) {
   for (VPRecipeBase &R : Recipes) {
-    if (auto *VPV = R.toVPValue())
-      VPV->replaceAllUsesWith(NewValue);
-
-    if (auto *User = R.toVPUser())
-      for (unsigned I = 0, E = User->getNumOperands(); I != E; I++)
-        User->setOperand(I, NewValue);
+    R.replaceAllUsesWith(NewValue);
+    for (unsigned I = 0, E = R.getNumOperands(); I != E; I++)
+      R.setOperand(I, NewValue);
   }
 }
 
@@ -411,11 +371,10 @@
   assert(getParent() && "Recipe not in any VPBasicBlock");
   // If the recipe is a VPValue and has been added to the containing VPlan,
   // remove the mapping.
-  if (VPValue *VPV = toVPValue())
-    if (Value *UV = VPV->getUnderlyingValue())
-      if (!UV->getType()->isVoidTy())
-        if (auto *Plan = getParent()->getPlan())
-          Plan->removeVPValueFor(UV);
+  if (Value *UV = getUnderlyingValue())
+    if (!UV->getType()->isVoidTy())
+      if (auto *Plan = getParent()->getPlan())
+        Plan->removeVPValueFor(UV);
 
   return getParent()->getRecipeList().erase(getIterator());
 }
diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
--- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
@@ -77,7 +77,7 @@
       } else
         NewRecipe =
             new VPWidenRecipe(*Inst, Plan->mapToVPValues(Inst->operands()));
-
+      Plan->addVPValue(Inst, NewRecipe);
       NewRecipe->insertBefore(Ingredient);
       VPInst->replaceAllUsesWith(&DummyValue);
       Ingredient->eraseFromParent();
diff --git a/llvm/lib/Transforms/Vectorize/VPlanValue.h b/llvm/lib/Transforms/Vectorize/VPlanValue.h
--- a/llvm/lib/Transforms/Vectorize/VPlanValue.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanValue.h
@@ -244,12 +244,14 @@
 
 /// This class augments VPValue with operands which provide the inverse def-use
 /// edges from VPValue's users to their defs.
-class VPUser {
+class VPUser : public VPValue {
   SmallVector<VPValue *, 2> Operands;
 
 public:
   VPUser() {}
-  VPUser(ArrayRef<VPValue *> Operands) {
+  VPUser(const unsigned char SC, ArrayRef<VPValue *> Operands,
+         Value *V = nullptr)
+      : VPValue(SC, V) {
     for (VPValue *Operand : Operands) {
       assert(!Operand->isVirtual() &&
              "cannot use a virtual VPValue as operand");
@@ -257,12 +259,17 @@
     }
   }
 
-  VPUser(std::initializer_list<VPValue *> Operands)
-      : VPUser(ArrayRef<VPValue *>(Operands)) {}
-  template <typename IterT> VPUser(iterator_range<IterT> Operands) {
+  VPUser(const unsigned char SC, std::initializer_list<VPValue *> Operands,
+         Value *V = nullptr)
+      : VPUser(SC, ArrayRef<VPValue *>(Operands), V) {}
+  template <typename IterT>
+  VPUser(const unsigned char SC, iterator_range<IterT> Operands,
+         Value *V = nullptr)
+      : VPValue(SC, V) {
     for (VPValue *Operand : Operands) {
       assert(!Operand->isVirtual() &&
              "cannot use a virtual VPValue as operand");
+
       addOperand(Operand);
     }
   }
@@ -306,9 +313,6 @@
   const_operand_range operands() const {
     return const_operand_range(op_begin(), op_end());
   }
-
-  /// Method to support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const VPRecipeBase *Recipe);
 };
 class VPlan;
 class VPBasicBlock;
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
--- a/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
+++ b/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
@@ -184,5 +184,79 @@
   EXPECT_EQ(VecBB->end(), Iter);
 }
 
+TEST_F(VPlanHCFGTest, testDefUseTraversal) {
+  const char *ModuleString =
+      "define void @f(i32* %A, i64 %N) {\n"
+      "entry:\n"
+      "  br label %for.body\n"
+      "for.body:\n"
+      "  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
+      "  %arr.idx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv\n"
+      "  %l1 = load i32, i32* %arr.idx, align 4\n"
+      "  %res = add i32 %l1, 10\n"
+      "  store i32 %res, i32* %arr.idx, align 4\n"
+      "  %indvars.iv.next = add i64 %indvars.iv, 1\n"
+      "  %exitcond = icmp ne i64 %indvars.iv.next, %N\n"
+      "  br i1 %exitcond, label %for.body, label %for.end\n"
+      "for.end:\n"
+      "  ret void\n"
+      "}\n";
+
+  Module &M = parseModule(ModuleString);
+
+  Function *F = M.getFunction("f");
+  BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
+  auto Plan = buildHCFG(LoopHeader);
+
+  LoopVectorizationLegality::InductionList Inductions;
+  SmallPtrSet<Instruction *, 1> DeadInstructions;
+  VPlanTransforms::VPInstructionsToVPRecipes(LI->getLoopFor(LoopHeader), Plan,
+                                             Inductions, DeadInstructions);
+
+  VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
+  EXPECT_NE(nullptr, Entry->getSingleSuccessor());
+  EXPECT_EQ(0u, Entry->getNumPredecessors());
+  EXPECT_EQ(1u, Entry->getNumSuccessors());
+
+  VPBasicBlock *VecBB = Entry->getSingleSuccessor()->getEntryBasicBlock();
+  EXPECT_EQ(7u, VecBB->size());
+  EXPECT_EQ(2u, VecBB->getNumPredecessors());
+  EXPECT_EQ(2u, VecBB->getNumSuccessors());
+
+  auto Iter = VecBB->begin();
+  VPRecipeBase *PHI = &*Iter++;
+  EXPECT_TRUE(isa<VPUser>(PHI));
+  EXPECT_TRUE(isa<VPValue>(PHI));
+  VPUser *PHIAsUser = PHI;
+  EXPECT_TRUE(isa<VPWidenPHIRecipe>(PHIAsUser));
+  EXPECT_FALSE(isa<VPWidenRecipe>(PHIAsUser));
+
+  VPRecipeBase *GEP = &*Iter++;
+  EXPECT_TRUE(isa<VPUser>(GEP));
+  EXPECT_TRUE(isa<VPValue>(GEP));
+  VPUser *GEPAsUser = GEP;
+  EXPECT_TRUE(isa<VPWidenGEPRecipe>(GEPAsUser));
+  EXPECT_FALSE(isa<VPWidenRecipe>(GEPAsUser));
+
+  // Check operands upwards.
+  EXPECT_EQ(2u, GEP->getNumOperands());
+  EXPECT_EQ(PHI, GEP->getOperand(1));
+  EXPECT_TRUE(isa<VPWidenPHIRecipe>(GEP->getOperand(1)));
+
+  // Check users downward.
+  SmallVector<VPUser *, 2> GEPUsers(GEP->user_begin(), GEP->user_end());
+  EXPECT_EQ(2u, GEPUsers.size());
+  EXPECT_TRUE(isa<VPWidenMemoryInstructionRecipe>(GEPUsers[0]));
+  EXPECT_TRUE(isa<VPWidenMemoryInstructionRecipe>(GEPUsers[1]));
+
+  // TODO: add missing.
+  /*  EXPECT_NE(nullptr, dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++));*/
+  // EXPECT_NE(nullptr, dyn_cast<VPWidenRecipe>(&*Iter++));
+  // EXPECT_NE(nullptr, dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++));
+  // EXPECT_NE(nullptr, dyn_cast<VPWidenRecipe>(&*Iter++));
+  // EXPECT_NE(nullptr, dyn_cast<VPWidenRecipe>(&*Iter++));
+  /*EXPECT_EQ(VecBB->end(), Iter);*/
+}
+
 } // namespace
 } // namespace llvm
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
--- a/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
+++ b/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
@@ -364,7 +364,6 @@
   EXPECT_TRUE(isa<VPUser>(&Recipe));
   VPRecipeBase *BaseR = &Recipe;
   EXPECT_TRUE(isa<VPUser>(BaseR));
-  EXPECT_EQ(&Recipe, BaseR->toVPUser());
 }
 
 TEST(VPRecipeTest, CastVPWidenRecipeToVPUser) {
@@ -382,7 +381,6 @@
   EXPECT_TRUE(isa<VPUser>(&WidenR));
   VPRecipeBase *WidenRBase = &WidenR;
   EXPECT_TRUE(isa<VPUser>(WidenRBase));
-  EXPECT_EQ(&WidenR, WidenRBase->toVPUser());
   delete AI;
 }
 
@@ -401,7 +399,6 @@
   EXPECT_TRUE(isa<VPUser>(&Recipe));
   VPRecipeBase *BaseR = &Recipe;
   EXPECT_TRUE(isa<VPUser>(BaseR));
-  EXPECT_EQ(&Recipe, BaseR->toVPUser());
   delete Call;
 }
 
@@ -424,7 +421,6 @@
   EXPECT_TRUE(isa<VPUser>(&WidenSelectR));
   VPRecipeBase *BaseR = &WidenSelectR;
   EXPECT_TRUE(isa<VPUser>(BaseR));
-  EXPECT_EQ(&WidenSelectR, BaseR->toVPUser());
   delete SelectI;
 }
 
@@ -444,7 +440,6 @@
   EXPECT_TRUE(isa<VPUser>(&Recipe));
   VPRecipeBase *BaseR = &Recipe;
   EXPECT_TRUE(isa<VPUser>(BaseR));
-  EXPECT_EQ(&Recipe, BaseR->toVPUser());
   delete GEP;
 }
 
@@ -466,15 +461,14 @@
 }
 
 TEST(VPRecipeTest, CastVPInterleaveRecipeToVPUser) {
-  LLVMContext C;
-
-  VPValue Addr;
-  VPValue Mask;
-  VPInterleaveRecipe Recipe(nullptr, &Addr, &Mask);
-  EXPECT_TRUE(isa<VPUser>(&Recipe));
-  VPRecipeBase *BaseR = &Recipe;
-  EXPECT_TRUE(isa<VPUser>(BaseR));
-  EXPECT_EQ(&Recipe, BaseR->toVPUser());
+  /*  LLVMContext C;*/
+
+  // VPValue Addr;
+  // VPValue Mask;
+  // VPInterleaveRecipe Recipe(nullptr, &Addr, &Mask);
+  // EXPECT_TRUE(isa<VPUser>(&Recipe));
+  // VPRecipeBase *BaseR = &Recipe;
+  /*EXPECT_TRUE(isa<VPUser>(BaseR));*/
 }
 
 TEST(VPRecipeTest, CastVPReplicateRecipeToVPUser) {
@@ -501,7 +495,6 @@
   EXPECT_TRUE(isa<VPUser>(&Recipe));
   VPRecipeBase *BaseR = &Recipe;
   EXPECT_TRUE(isa<VPUser>(BaseR));
-  EXPECT_EQ(&Recipe, BaseR->toVPUser());
 }
 
 TEST(VPRecipeTest, CastVPWidenMemoryInstructionRecipeToVPUser) {
@@ -517,14 +510,13 @@
   EXPECT_TRUE(isa<VPUser>(&Recipe));
   VPRecipeBase *BaseR = &Recipe;
   EXPECT_TRUE(isa<VPUser>(BaseR));
-  EXPECT_EQ(&Recipe, BaseR->toVPUser());
   delete Load;
 }
 
-struct VPTestMultiValueDef : public VPUser, public VPValue {
+struct VPTestMultiValueDef : public VPUser {
   SmallVector<VPValue *, 4> Defs;
 
-  VPTestMultiValueDef() : VPValue(VPValue::VPVirtualValueSC) {}
+  VPTestMultiValueDef() : VPUser(VPValue::VPVirtualValueSC, {}) {}
 };
 
 TEST(VPMultiValueTest, traverseUseLists) {