[NFC][AsmPrinter] Expose std::variant-ness of DbgVariable

[fdeazeve]

Really like the code deletions here :)

llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h

private:
   }
 };
 
 /// Builder for DebugLocStream lists.
 class DebugLocStream::ListBuilder {
   DebugLocStream &Locs;
   AsmPrinter &Asm;
   DbgVariable &V;
-  const MachineInstr &MI;
   size_t ListIndex;
   std::optional<uint8_t> TagOffset;
 
 public:
   ListBuilder(DebugLocStream &Locs, DwarfCompileUnit &CU, AsmPrinter &Asm,
-              DbgVariable &V, const MachineInstr &MI)
-      : Locs(Locs), Asm(Asm), V(V), MI(MI), ListIndex(Locs.startList(&CU)),
+              DbgVariable &V)
+      : Locs(Locs), Asm(Asm), V(V), ListIndex(Locs.startList(&CU)),
         TagOffset(std::nullopt) {}
 
   void setTagOffset(uint8_t TO) {
     TagOffset = TO;
   }
 
   /// Finalize the list.
   ///

llvm/lib/CodeGen/AsmPrinter/DebugLocStream.cpp

void DebugLocStream::finalizeEntry() {
 
   assert(Lists.back().EntryOffset <= Entries.size() &&
          "Popped off more entries than are in the list");
 }
 
 DebugLocStream::ListBuilder::~ListBuilder() {
   if (!Locs.finalizeList(Asm))
     return;
-  V.initializeDbgValue(&MI);
-  V.setDebugLocListIndex(ListIndex);
-  if (TagOffset)
-    V.setDebugLocListTagOffset(*TagOffset);
+  V.emplace<Loc::Multi>(ListIndex, TagOffset);
 }

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

public:
   /// Add an address attribute to a die based on the location provided.
   void addAddress(DIE &Die, dwarf::Attribute Attribute,
                   const MachineLocation &Location);
 
   /// Start with the address based on the location provided, and generate the
   /// DWARF information necessary to find the actual variable (navigating the
   /// extra location information encoded in the type) based on the starting
   /// location.  Add the DWARF information to the die.
-  void addComplexAddress(const DbgVariable &DV, DIE &Die,
+  void addComplexAddress(const DIExpression *DIExpr, DIE &Die,
                          dwarf::Attribute Attribute,
                          const MachineLocation &Location);
 
   /// Add a Dwarf loclistptr attribute data and value.
   void addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index);
   void applyVariableAttributes(const DbgVariable &Var, DIE &VariableDie);
 
   /// Add a Dwarf expression attribute data and value.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
 
   if (Abstract) {
     applyVariableAttributes(DV, *VariableDie);
     return VariableDie;
   }
 
   // Add variable address.
 
-  unsigned Index = DV.getDebugLocListIndex();
-  if (Index != ~0U) {
-    addLocationList(*VariableDie, dwarf::DW_AT_location, Index);
-    auto TagOffset = DV.getDebugLocListTagOffset();
+  if (auto *Multi = std::get_if<Loc::Multi>(&DV)) {
+    addLocationList(*VariableDie, dwarf::DW_AT_location,
+                    Multi->getDebugLocListIndex());
+    auto TagOffset = Multi->getDebugLocListTagOffset();
     if (TagOffset)
       addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
               *TagOffset);
     return VariableDie;
   }
 
   // Check if variable has a single location description.
-  if (auto *DVal = DV.getValueLoc()) {
+  if (const auto *Single = std::get_if<Loc::Single>(&DV)) {
+    const DbgValueLoc *DVal = &Single->getValueLoc();
     if (!DVal->isVariadic()) {
       const DbgValueLocEntry *Entry = DVal->getLocEntries().begin();
       if (Entry->isLocation()) {
         addVariableAddress(DV, *VariableDie, Entry->getLoc());
       } else if (Entry->isInt()) {
-        auto *Expr = DV.getSingleExpression();
+        auto *Expr = Single->getExpr();
         if (Expr && Expr->getNumElements()) {
           DIELoc *Loc = new (DIEValueAllocator) DIELoc;
           DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
           // If there is an expression, emit raw unsigned bytes.
           DwarfExpr.addFragmentOffset(Expr);
           DwarfExpr.addUnsignedConstant(Entry->getInt());
           DwarfExpr.addExpression(Expr);
           addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
if (!DVal->isVariadic()) {
       return VariableDie;
     }
     // If any of the location entries are registers with the value 0, then the
     // location is undefined.
     if (any_of(DVal->getLocEntries(), [](const DbgValueLocEntry &Entry) {
           return Entry.isLocation() && !Entry.getLoc().getReg();
         }))
       return VariableDie;
-    const DIExpression *Expr = DV.getSingleExpression();
+    const DIExpression *Expr = Single->getExpr();
     assert(Expr && "Variadic Debug Value must have an Expression.");
     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
     DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
     DwarfExpr.addFragmentOffset(Expr);
     DIExpressionCursor Cursor(Expr);
     const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
 
     auto AddEntry = [&](const DbgValueLocEntry &Entry,
if (const auto *Single = std::get_if<Loc::Single>(&DV)) {
     addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
     if (DwarfExpr.TagOffset)
       addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
               *DwarfExpr.TagOffset);
 
     return VariableDie;
   }
 
-  if (const std::set<EntryValueInfo> *EntryValues = DV.getEntryValues()) {
+  if (auto *EntryValue = std::get_if<Loc::EntryValue>(&DV)) {
     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
     DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
     // Emit each expression as: EntryValue(Register) <other ops> <Fragment>.
-    for (auto [Register, Expr] : *EntryValues) {
+    for (auto [Register, Expr] : EntryValue->EntryValues) {
       DwarfExpr.addFragmentOffset(&Expr);
       DIExpressionCursor Cursor(Expr.getElements());
       DwarfExpr.beginEntryValueExpression(Cursor);
       DwarfExpr.addMachineRegExpression(
           *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, Register);
       DwarfExpr.addExpression(std::move(Cursor));
     }
     addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
     return VariableDie;
   }
 
   // .. else use frame index.
-  if (!DV.hasFrameIndexExprs())
+  if (!DV.holds<Loc::MMI>())
     return VariableDie;
 
   std::optional<unsigned> NVPTXAddressSpace;
   DIELoc *Loc = new (DIEValueAllocator) DIELoc;
   DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
-  for (const auto &Fragment : DV.getFrameIndexExprs()) {
+  for (const auto &Fragment : DV.get<Loc::MMI>().getFrameIndexExprs()) {
     Register FrameReg;
     const DIExpression *Expr = Fragment.Expr;
     const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
     StackOffset Offset =
         TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
     DwarfExpr.addFragmentOffset(Expr);
 
     auto *TRI = Asm->MF->getSubtarget().getRegisterInfo();
void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty,
   // This way the CU-level type DIE is preferred over the "can't describe this
   // type as a unit offset because it's not really in the CU at all, it's only
   // in a type unit"
   GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie()));
 }
 
 void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
                                           MachineLocation Location) {
-  if (DV.hasComplexAddress())
-    addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
+  auto *Single = std::get_if<Loc::Single>(&DV);
+  if (Single && Single->getExpr())
+    addComplexAddress(Single->getExpr(), Die, dwarf::DW_AT_location, Location);
   else
     addAddress(Die, dwarf::DW_AT_location, Location);
 }
 
 /// Add an address attribute to a die based on the location provided.
 void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
                                   const MachineLocation &Location) {
   DIELoc *Loc = new (DIEValueAllocator) DIELoc;
if (DwarfExpr.TagOffset)
     addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
             *DwarfExpr.TagOffset);
 }
 
 /// Start with the address based on the location provided, and generate the
 /// DWARF information necessary to find the actual variable given the extra
 /// address information encoded in the DbgVariable, starting from the starting
 /// location.  Add the DWARF information to the die.
-void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
+void DwarfCompileUnit::addComplexAddress(const DIExpression *DIExpr, DIE &Die,
                                          dwarf::Attribute Attribute,
                                          const MachineLocation &Location) {
   DIELoc *Loc = new (DIEValueAllocator) DIELoc;
   DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
-  const DIExpression *DIExpr = DV.getSingleExpression();
   DwarfExpr.addFragmentOffset(DIExpr);
   DwarfExpr.setLocation(Location, DIExpr);
 
   DIExpressionCursor Cursor(DIExpr);
 
   if (DIExpr->isEntryValue())
     DwarfExpr.beginEntryValueExpression(Cursor);
 

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

static bool classof(const DbgEntity *N) {
     case DbgVariableKind:
     case DbgLabelKind:
       return true;
     }
     llvm_unreachable("Invalid DbgEntityKind");
   }
 };
 
+class DbgVariable;
+
 /// Proxy for one MMI entry.
 struct FrameIndexExpr {
   int FI;
   const DIExpression *Expr;
 };
 
 /// Represents an entry-value location, or a fragment of one.
 struct EntryValueInfo {
   MCRegister Reg;
   const DIExpression &Expr;
 
   /// Operator enabling sorting based on fragment offset.
   bool operator<(const EntryValueInfo &Other) const {
     return getFragmentOffsetInBits() < Other.getFragmentOffsetInBits();
   }
 
 private:
   uint64_t getFragmentOffsetInBits() const {
     std::optional<DIExpression::FragmentInfo> Fragment = Expr.getFragmentInfo();
     return Fragment ? Fragment->OffsetInBits : 0;
   }
 };
 
-// Namespace for private alternatives of a DbgVariable.
-namespace {
+// Namespace for alternatives of a DbgVariable.
+namespace Loc {
 /// Single value location description.
-struct SingleLoc {
+class Single {
   std::unique_ptr<DbgValueLoc> ValueLoc;
   const DIExpression *Expr;
-  SingleLoc(DbgValueLoc ValueLoc)
-      : ValueLoc(std::make_unique<DbgValueLoc>(ValueLoc)),
-        Expr(ValueLoc.getExpression()) {
-    if (!Expr->getNumElements())
-      Expr = nullptr;
-  }
+
+public:
+  explicit Single(DbgValueLoc ValueLoc);
+  explicit Single(const MachineInstr *DbgValue);
+  const DbgValueLoc &getValueLoc() const { return *ValueLoc; }
+  const DIExpression *getExpr() const { return Expr; }
 };
 /// Multi-value location description.
-struct MultiLoc {
+class Multi {
   /// Index of the entry list in DebugLocs.
-  unsigned DebugLocListIndex = ~0u;
+  unsigned DebugLocListIndex;
   /// DW_OP_LLVM_tag_offset value from DebugLocs.
   std::optional<uint8_t> DebugLocListTagOffset;
+
+public:
+  explicit Multi(unsigned DebugLocListIndex,
+                 std::optional<uint8_t> DebugLocListTagOffset)
+      : DebugLocListIndex(DebugLocListIndex),
+        DebugLocListTagOffset(DebugLocListTagOffset) {}
+  unsigned getDebugLocListIndex() const { return DebugLocListIndex; }
+  std::optional<uint8_t> getDebugLocListTagOffset() const {
+    return DebugLocListTagOffset;
+  }
 };
 /// Single location defined by (potentially multiple) MMI entries.
-struct MMILoc {
+struct MMI {
   mutable SmallVector<FrameIndexExpr, 1> FrameIndexExprs;
+
+public:
+  explicit MMI(const DIExpression *E, int FI) : FrameIndexExprs({{FI, E}}) {
+    assert((!E || E->isValid()) && "Expected valid expression");
+    assert(FI != std::numeric_limits<int>::max() && "Expected valid index");
+  }
+  void addFrameIndexExpr(const DIExpression *Expr, int FI);
+  /// Get the FI entries, sorted by fragment offset.
+  ArrayRef<FrameIndexExpr> getFrameIndexExprs() const;
 };
 /// Single location defined by (potentially multiple) EntryValueInfo.
-struct EntryValueLoc {
+struct EntryValue {
   std::set<EntryValueInfo> EntryValues;
-  EntryValueLoc(MCRegister Reg, const DIExpression &Expr) {
+  explicit EntryValue(MCRegister Reg, const DIExpression &Expr) {
     addExpr(Reg, Expr);
   };
   // Add the pair Reg, Expr to the list of entry values describing the variable.
   // If multiple expressions are added, it is the callers responsibility to
   // ensure they are all non-overlapping fragments.
   void addExpr(MCRegister Reg, const DIExpression &Expr) {
     std::optional<const DIExpression *> NonVariadicExpr =
         DIExpression::convertToNonVariadicExpression(&Expr);
     assert(NonVariadicExpr && *NonVariadicExpr);
 
     EntryValues.insert({Reg, **NonVariadicExpr});
   }
 };
-} // namespace
+} // namespace Loc
 
 //===----------------------------------------------------------------------===//
 /// This class is used to track local variable information.
 ///
 /// Variables that have been optimized out hold the \c monostate alternative.
 /// This is not distinguished from the case of a constructed \c DbgVariable
 /// which has not be initialized yet.
 ///
 /// Variables can be created from allocas, in which case they're generated from
-/// the MMI table. Such variables hold the \c MMILoc alternative which can have
-/// multiple expressions and frame indices.
+/// the MMI table. Such variables hold the \c Loc::MMI alternative which can
+/// have multiple expressions and frame indices.
 ///
 /// Variables can be created from the entry value of registers, in which case
 /// they're generated from the MMI table. Such variables hold the \c
 /// EntryValueLoc alternative which can either have a single expression or
 /// multiple *fragment* expressions.
 ///
 /// Variables can be created from \c DBG_VALUE instructions. Those whose
-/// location changes over time hold a \c MultiLoc alternative which uses \c
+/// location changes over time hold a \c Loc::Multi alternative which uses \c
 /// DebugLocListIndex and (optionally) \c DebugLocListTagOffset, while those
-/// with a single location hold a \c SingleLoc alternative which use \c ValueLoc
-/// and (optionally) a single \c Expr.
+/// with a single location hold a \c Loc::Single alternative which use \c
+/// ValueLoc and (optionally) a single \c Expr.
 class DbgVariable : public DbgEntity,
-                    private std::variant<std::monostate, SingleLoc, MultiLoc,
-                                         MMILoc, EntryValueLoc> {
+                    public std::variant<std::monostate, Loc::Single, Loc::Multi,
+                                        Loc::MMI, Loc::EntryValue> {
 
+public:
   /// Member shorthand for std::holds_alternative
   template <typename T> bool holds() const {
     return std::holds_alternative<T>(*this);
   }
   /// Asserting, noexcept member alternative to std::get
   template <typename T> auto &get() noexcept {
     assert(holds<T>());
     return *std::get_if<T>(this);
   }
   /// Asserting, noexcept member alternative to std::get
   template <typename T> const auto &get() const noexcept {
     assert(holds<T>());
     return *std::get_if<T>(this);
   }
 
-public:
   /// Construct a DbgVariable.
   ///
-  /// Creates a variable without any DW_AT_location.  Call \a initializeMMI()
-  /// for MMI entries, or \a initializeDbgValue() for DBG_VALUE instructions.
+  /// Creates a variable without any DW_AT_location.
   DbgVariable(const DILocalVariable *V, const DILocation *IA)
       : DbgEntity(V, IA, DbgVariableKind) {}
 
-  /// Initialize from the MMI table.
-  void initializeMMI(const DIExpression *E, int FI);
-
-  // Initialize variable's location.
-  void initializeDbgValue(DbgValueLoc Value);
-
-  void initializeEntryValue(MCRegister Reg, const DIExpression &Expr);
-
-  const std::set<EntryValueInfo> *getEntryValues() const {
-    if (const auto *EV = std::get_if<EntryValueLoc>(this))
-      return &EV->EntryValues;
-    return nullptr;
-  }
-  std::set<EntryValueInfo> *getEntryValues() {
-    if (auto *EV = std::get_if<EntryValueLoc>(this))
-      return &EV->EntryValues;
-    return nullptr;
-  }
-  void addEntryValueExpr(MCRegister Reg, const DIExpression &Expr) {
-    get<EntryValueLoc>().addExpr(Reg, Expr);
-  }
-
-  /// Initialize from a DBG_VALUE instruction.
-  void initializeDbgValue(const MachineInstr *DbgValue);
-
   // Accessors.
   const DILocalVariable *getVariable() const {
     return cast<DILocalVariable>(getEntity());
   }
 
-  const DIExpression *getSingleExpression() const {
-    return get<SingleLoc>().Expr;
-  }
-
-  void setDebugLocListIndex(uint8_t O) {
-    if (auto *M = std::get_if<MultiLoc>(this))
-      M->DebugLocListIndex = O;
-    else
-      emplace<MultiLoc>().DebugLocListIndex = O;
-  }
-  unsigned getDebugLocListIndex() const {
-    if (auto *M = std::get_if<MultiLoc>(this))
-      return M->DebugLocListIndex;
-    return ~0U;
-  }
-  void setDebugLocListTagOffset(uint8_t O) {
-    if (auto *M = std::get_if<MultiLoc>(this))
-      M->DebugLocListTagOffset = O;
-    else
-      emplace<MultiLoc>().DebugLocListTagOffset = O;
-  }
-  std::optional<uint8_t> getDebugLocListTagOffset() const {
-    return get<MultiLoc>().DebugLocListTagOffset;
-  }
   StringRef getName() const { return getVariable()->getName(); }
-  const DbgValueLoc *getValueLoc() const {
-    if (auto *M = std::get_if<SingleLoc>(this))
-      return M->ValueLoc.get();
-    return nullptr;
-  }
-  /// Get the FI entries, sorted by fragment offset.
-  ArrayRef<FrameIndexExpr> getFrameIndexExprs() const;
-  bool hasFrameIndexExprs() const { return holds<MMILoc>(); }
-  void addMMIEntry(const DIExpression *Expr, int FI);
 
   // Translate tag to proper Dwarf tag.
   dwarf::Tag getTag() const {
     // FIXME: Why don't we just infer this tag and store it all along?
     if (getVariable()->isParameter())
       return dwarf::DW_TAG_formal_parameter;
 
     return dwarf::DW_TAG_variable;
public:
   bool isObjectPointer() const {
     if (getVariable()->isObjectPointer())
       return true;
     if (getType()->isObjectPointer())
       return true;
     return false;
   }
 
-  bool hasComplexAddress() const { return get<SingleLoc>().Expr; }
-
   const DIType *getType() const;
 
   static bool classof(const DbgEntity *N) {
     return N->getDbgEntityID() == DbgVariableKind;
   }
 };
 
 //===----------------------------------------------------------------------===//

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (const MachineOperand &Op : MI->debug_operands()) {
     else if (Op.isCImm())
       DbgValueLocEntries.push_back(DbgValueLocEntry(Op.getCImm()));
     else
       llvm_unreachable("Unexpected debug operand in DBG_VALUE* instruction!");
   }
   return DbgValueLoc(Expr, DbgValueLocEntries, IsVariadic);
 }
 
-/// Initialize from the MMI table.
-void DbgVariable::initializeMMI(const DIExpression *E, int FI) {
-  assert(holds<std::monostate>() && "Already initialized");
-  assert((!E || E->isValid()) && "Expected valid expression");
-  assert(FI != std::numeric_limits<int>::max() && "Expected valid index");
-  emplace<MMILoc>().FrameIndexExprs.push_back({FI, E});
+Loc::Single::Single(DbgValueLoc ValueLoc)
+    : ValueLoc(std::make_unique<DbgValueLoc>(ValueLoc)),
+      Expr(ValueLoc.getExpression()) {
+  if (!Expr->getNumElements())
+    Expr = nullptr;
 }
 
-void DbgVariable::initializeDbgValue(DbgValueLoc Value) {
-  assert(holds<std::monostate>() && "Already initialized");
-  assert(!Value.getExpression()->isFragment() && "Fragments not supported");
-  emplace<SingleLoc>(Value);
-}
-
-void DbgVariable::initializeDbgValue(const MachineInstr *DbgValue) {
-  assert(holds<std::monostate>() && "Already initialized");
-  assert(getVariable() == DbgValue->getDebugVariable() && "Wrong variable");
-  assert(getInlinedAt() == DbgValue->getDebugLoc()->getInlinedAt() &&
-         "Wrong inlined-at");
-  emplace<SingleLoc>(getDebugLocValue(DbgValue));
-}
-
-void DbgVariable::initializeEntryValue(MCRegister Reg,
-                                       const DIExpression &Expr) {
-  assert(holds<std::monostate>() && "Already initialized?");
-  emplace<EntryValueLoc>(Reg, Expr);
-}
-
-ArrayRef<FrameIndexExpr> DbgVariable::getFrameIndexExprs() const {
-  auto &FrameIndexExprs = get<MMILoc>().FrameIndexExprs;
+Loc::Single::Single(const MachineInstr *DbgValue)
+    : Single(getDebugLocValue(DbgValue)) {}
 
+ArrayRef<FrameIndexExpr> Loc::MMI::getFrameIndexExprs() const {
   if (FrameIndexExprs.size() == 1)
     return FrameIndexExprs;
 
-  assert(llvm::all_of(FrameIndexExprs,
-                      [](const FrameIndexExpr &A) {
-                        return A.Expr->isFragment();
-                      }) &&
+  assert(llvm::all_of(
+             FrameIndexExprs,
+             [](const FrameIndexExpr &A) { return A.Expr->isFragment(); }) &&
          "multiple FI expressions without DW_OP_LLVM_fragment");
   llvm::sort(FrameIndexExprs,
              [](const FrameIndexExpr &A, const FrameIndexExpr &B) -> bool {
                return A.Expr->getFragmentInfo()->OffsetInBits <
                       B.Expr->getFragmentInfo()->OffsetInBits;
              });
 
   return FrameIndexExprs;
 }
 
-void DbgVariable::addMMIEntry(const DIExpression *Expr, int FI) {
-  auto &FrameIndexExprs = get<MMILoc>().FrameIndexExprs;
-
+void Loc::MMI::addFrameIndexExpr(const DIExpression *Expr, int FI) {
   // FIXME: This logic should not be necessary anymore, as we now have proper
   // deduplication. However, without it, we currently run into the assertion
   // below, which means that we are likely dealing with broken input, i.e. two
   // non-fragment entries for the same variable at different frame indices.
   if (FrameIndexExprs.size()) {
     auto *Expr = FrameIndexExprs.back().Expr;
     if (!Expr || !Expr->isFragment())
       return;
if (!Scope) {
       LLVM_DEBUG(dbgs() << "Dropping debug info for " << VI.Var->getName()
                         << ", no variable scope found\n");
       continue;
     }
 
     ensureAbstractEntityIsCreatedIfScoped(TheCU, Var.first, Scope->getScopeNode());
 
     if (DbgVariable *DbgVar = MFVars.lookup(Var)) {
-      if (DbgVar->hasFrameIndexExprs())
-        DbgVar->addMMIEntry(VI.Expr, VI.getStackSlot());
+      if (auto *MMI = std::get_if<Loc::MMI>(DbgVar))
+        MMI->addFrameIndexExpr(VI.Expr, VI.getStackSlot());
       else
-        DbgVar->addEntryValueExpr(VI.getEntryValueRegister(), *VI.Expr);
+        DbgVar->get<Loc::EntryValue>().addExpr(VI.getEntryValueRegister(),
+                                               *VI.Expr);
       continue;
     }
 
     auto RegVar = std::make_unique<DbgVariable>(
                     cast<DILocalVariable>(Var.first), Var.second);
     if (VI.inStackSlot())
-      RegVar->initializeMMI(VI.Expr, VI.getStackSlot());
+      RegVar->emplace<Loc::MMI>(VI.Expr, VI.getStackSlot());
     else
-      RegVar->initializeEntryValue(VI.getEntryValueRegister(), *VI.Expr);
+      RegVar->emplace<Loc::EntryValue>(VI.getEntryValueRegister(), *VI.Expr);
     LLVM_DEBUG(dbgs() << "Created DbgVariable for " << VI.Var->getName()
                       << "\n");
     InfoHolder.addScopeVariable(Scope, RegVar.get());
     MFVars.insert({Var, RegVar.get()});
     ConcreteEntities.push_back(std::move(RegVar));
   }
 }
 
for (const auto &I : DbgValues) {
     // additional entry which clobbers the debug value.
     size_t HistSize = HistoryMapEntries.size();
     bool SingleValueWithClobber =
         HistSize == 2 && HistoryMapEntries[1].isClobber();
     if (HistSize == 1 || SingleValueWithClobber) {
       const auto *End =
           SingleValueWithClobber ? HistoryMapEntries[1].getInstr() : nullptr;
       if (validThroughout(LScopes, MInsn, End, getInstOrdering())) {
-        RegVar->initializeDbgValue(MInsn);
+        RegVar->emplace<Loc::Single>(MInsn);
         continue;
       }
     }
 
     // Do not emit location lists if .debug_loc secton is disabled.
     if (!useLocSection())
       continue;
 
     // Handle multiple DBG_VALUE instructions describing one variable.
-    DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
+    DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar);
 
     // Build the location list for this variable.
     SmallVector<DebugLocEntry, 8> Entries;
     bool isValidSingleLocation = buildLocationList(Entries, HistoryMapEntries);
 
     // Check whether buildLocationList managed to merge all locations to one
     // that is valid throughout the variable's scope. If so, produce single
     // value location.
     if (isValidSingleLocation) {
-      RegVar->initializeDbgValue(Entries[0].getValues()[0]);
+      RegVar->emplace<Loc::Single>(Entries[0].getValues()[0]);
       continue;
     }
 
     // If the variable has a DIBasicType, extract it.  Basic types cannot have
     // unique identifiers, so don't bother resolving the type with the
     // identifier map.
     const DIBasicType *BT = dyn_cast<DIBasicType>(
         static_cast<const Metadata *>(LocalVar->getType()));