[DebugInfo][InstrRef][NFC] Represent DbgValues with multiple ops in LDV

[StephenTozer]

Summary

In preparation for allowing InstrRefBasedLDV to handle DBG_VALUE_LIST, this patch updates the internal representation that it uses to represent debug values to store a list of values. This is one of the more significant changes in terms of line count, but is fairly simple and should not affect the output of this pass.

[Orlando]

LGTM with some minor comments. I'd feel more confident if someone else (/ @jmorse ) took a quick look too, but given this is NFC and conceptually straightforward, I'm happy to approve it.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

219

has this been clang-formated (IIRC we don't usually indent for the namespace scope)?

282

It looks like you use this union for type punning. IIRC this is UB in C++ but I am unsure. Is this a case that is permitted for some reason, do you know?

373

IIRC there is at least one other place in the compiler where there's a limit for number of debug operands (SCEV or salvaging or both?). Have you considered using a single value for all the limits? Or, if not, that then maybe updating the other limits if they're greater than 8.

[StephenTozer]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

282

I don't know actually - but this file was already using this type of behaviour beforehand in ValueIDNum. All the same, it shouldn't be difficult to do this without type punning - I'd be interest in getting a solid answer on whether it should be outright banned or not (I think in C++ it's still a relatively common pattern?).

373

I agree, having a global limit would be mostly good - it would also be good to have some good benchmarks for testing different expression lengths, so that we can have an objective indication of what's optimal.

[StephenTozer]

Apply clang-format!

[Orlando]

I'm happy to approve it.

And yet I did not. Fixed!

[StephenTozer]

Update unit tests. The changes are all trivial; the changes were performed primarily by regex substitution, and simply update DbgValue constructors in the tests to use a DbgOpID instead of a ValueIDNum, creating the former in most cases with a test function addValueDbgOp that creates an ID for a Value in the standard way. For the vlocJoin tests, there was no need to create the underlying value, as vlocJoin does not actually need to view it - it only checks equality and const-ness, which can be done entirely from the ID.

[StephenTozer]

Added an extra unit test.

[Orlando]

Still LGTM!

[aeubanks]

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

1811

this patch seems to have added a lot of unused variables that some bots are complaining about, e.g. https://buildkite.com/llvm-project/upstream-bazel/builds/37703#0182c6bb-7631-491a-8b71-3ed8ae1ef7d6

could you take a look?

[kazu]

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

1811

I just landed 58ad7555f564fbcd63d8d782f4fb7f6f2d432fe9.

[StephenTozer]

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

1811

Thanks for catching that, was just reverting - I'll take a look at the unused variable warnings now.

[StephenTozer]

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

1811

I see you've caught those as well - sorry about that!

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

 class TransferTracker;
 
 // Forward dec of unit test class, so that we can peer into the LDV object.
 class InstrRefLDVTest;
 
 namespace LiveDebugValues {
 
 class MLocTracker;
+class DbgOpIDMap;
 
 using namespace llvm;
 
 /// Handle-class for a particular "location". This value-type uniquely
 /// symbolises a register or stack location, allowing manipulation of locations
 /// without concern for where that location is. Practically, this allows us to
 /// treat the state of the machine at a particular point as an array of values,
 /// rather than a map of values.
return Twine("Value{bb: ")
                                             .concat(Twine("}")))))
         .str();
   }
 
   static ValueIDNum EmptyValue;
   static ValueIDNum TombstoneValue;
 };
 
+} // End namespace LiveDebugValues
+
+namespace llvm {
+using namespace LiveDebugValues;
+
+template <> struct DenseMapInfo<LocIdx> {
+  static inline LocIdx getEmptyKey() { return LocIdx::MakeIllegalLoc(); }
+  static inline LocIdx getTombstoneKey() { return LocIdx::MakeTombstoneLoc(); }
+
+  static unsigned getHashValue(const LocIdx &Loc) { return Loc.asU64(); }
+
+  static bool isEqual(const LocIdx &A, const LocIdx &B) { return A == B; }
+};
+
+template <> struct DenseMapInfo<ValueIDNum> {
+  static inline ValueIDNum getEmptyKey() { return ValueIDNum::EmptyValue; }
+  static inline ValueIDNum getTombstoneKey() {
+    return ValueIDNum::TombstoneValue;
+  }
+
+  static unsigned getHashValue(const ValueIDNum &Val) {
+    return hash_value(Val.asU64());
+  }
+
+  static bool isEqual(const ValueIDNum &A, const ValueIDNum &B) {
+    return A == B;
+  }
+};
+
+} // end namespace llvm
+
+namespace LiveDebugValues {
+using namespace llvm;
+
 /// Type for a table of values in a block.
 using ValueTable = std::unique_ptr<ValueIDNum[]>;
 
 /// Type for a table-of-table-of-values, i.e., the collection of either
 /// live-in or live-out values for each block in the function.
 using FuncValueTable = std::unique_ptr<ValueTable[]>;
 
 /// Thin wrapper around an integer -- designed to give more type safety to
 /// spill location numbers.
 class SpillLocationNo {
 public:
   explicit SpillLocationNo(unsigned SpillNo) : SpillNo(SpillNo) {}
   unsigned SpillNo;
   unsigned id() const { return SpillNo; }
 
   bool operator<(const SpillLocationNo &Other) const {
     return SpillNo < Other.SpillNo;
   }
 
   bool operator==(const SpillLocationNo &Other) const {
     return SpillNo == Other.SpillNo;
   }
unsigned getLocationOpCount() const {
     return IsVariadic ? DIExpr->getNumLocationOperands() : 1;
   }
 
   const DIExpression *DIExpr;
   bool Indirect;
   bool IsVariadic;
 };
 
-/// Class recording the (high level) _value_ of a variable. Identifies either
-/// the value of the variable as a ValueIDNum, or a constant MachineOperand.
+/// TODO: Might pack better if we changed this to a Struct of Arrays, since
+/// MachineOperand is width 32, making this struct width 33. We could also
+/// potentially avoid storing the whole MachineOperand (sizeof=32), instead
+/// choosing to store just the contents portion (sizeof=8) and a Kind enum,
+/// since we already know it is some type of immediate value.
+/// Stores a single debug operand, which can either be a MachineOperand for
+/// directly storing immediate values, or a ValueIDNum representing some value
+/// computed at some point in the program. IsConst is used as a discriminator.
+struct DbgOp {
+  union {
+    ValueIDNum ID;
+    MachineOperand MO;
+  };
+  bool IsConst;
+
+  DbgOp() : ID(ValueIDNum::EmptyValue), IsConst(false) {}
+  DbgOp(ValueIDNum ID) : ID(ID), IsConst(false) {}
+  DbgOp(MachineOperand MO) : MO(MO), IsConst(true) {}
+
+  bool isUndef() const { return !IsConst && ID == ValueIDNum::EmptyValue; }
+
+#ifndef NDEBUG
+  void dump(const MLocTracker *MTrack) const;
+#endif
+};
+
+/// A DbgOp whose ID (if any) has resolved to an actual location, LocIdx. Used
+/// when working with concrete debug values, i.e. when joining MLocs and VLocs
+/// in the TransferTracker or emitting DBG_VALUE/DBG_VALUE_LIST instructions in
+/// the MLocTracker.
+struct ResolvedDbgOp {
+  union {
+    LocIdx Loc;
+    MachineOperand MO;
+  };
+  bool IsConst;
+
+  ResolvedDbgOp(LocIdx Loc) : Loc(Loc), IsConst(false) {}
+  ResolvedDbgOp(MachineOperand MO) : MO(MO), IsConst(true) {}
+
+  bool operator==(const ResolvedDbgOp &Other) const {
+    if (IsConst != Other.IsConst)
+      return false;
+    if (IsConst)
+      return MO.isIdenticalTo(Other.MO);
+    return Loc == Other.Loc;
+  }
+
+#ifndef NDEBUG
+  void dump(const MLocTracker *MTrack) const;
+#endif
+};
+
+/// An ID used in the DbgOpIDMap (below) to lookup a stored DbgOp. This is used
+/// in place of actual DbgOps inside of a DbgValue to reduce its size, as
+/// DbgValue is very frequently used and passed around, and the actual DbgOp is
+/// over 8x larger than this class, due to storing a MachineOperand. This ID
+/// should be equal for all equal DbgOps, and also encodes whether the mapped
+/// DbgOp is a constant, meaning that for simple equality or const-ness checks
+/// it is not necessary to lookup this ID.
+struct DbgOpID {
+  union {
+    struct {
+      uint32_t IsConst : 1;
+      uint32_t Index : 31;
+    } ID;
+    uint32_t RawID;
+  };
+
+  DbgOpID() : RawID(UndefID.RawID) {
+    static_assert(sizeof(DbgOpID) == 4, "DbgOpID should fit within 4 bytes.");
+  }
+  DbgOpID(uint32_t RawID) : RawID(RawID) {}
+  DbgOpID(bool IsConst, uint32_t Index) : ID({IsConst, Index}) {}
+
+  static DbgOpID UndefID;
+
+  bool operator==(const DbgOpID &Other) const { return RawID == Other.RawID; }
+  bool operator!=(const DbgOpID &Other) const { return !(*this == Other); }
+
+  uint32_t asU32() const { return RawID; }
+
+  bool isUndef() const { return *this == UndefID; }
+  bool isConst() const { return ID.IsConst && !isUndef(); }
+  uint32_t getIndex() const { return ID.Index; }
+
+#ifndef NDEBUG
+  void dump(const MLocTracker *MTrack, const DbgOpIDMap *OpStore) const;
+#endif
+};
+
+/// Class storing the complete set of values that are observed by DbgValues
+/// within the current function. Allows 2-way lookup, with `find` returning the
+/// Op for a given ID and `insert` returning the ID for a given Op (creating one
+/// if none exists).
+class DbgOpIDMap {
+
+  SmallVector<ValueIDNum, 0> ValueOps;
+  SmallVector<MachineOperand, 0> ConstOps;
+
+  DenseMap<ValueIDNum, DbgOpID> ValueOpToID;
+  DenseMap<MachineOperand, DbgOpID> ConstOpToID;
+
+public:
+  /// If \p Op does not already exist in this map, it is inserted and the
+  /// corresponding DbgOpID is returned. If Op already exists in this map, then
+  /// no change is made and the existing ID for Op is returned.
+  /// Calling this with the undef DbgOp will always return DbgOpID::UndefID.
+  DbgOpID insert(DbgOp Op) {
+    if (Op.isUndef())
+      return DbgOpID::UndefID;
+    if (Op.IsConst)
+      return insertConstOp(Op.MO);
+    return insertValueOp(Op.ID);
+  }
+  /// Returns the DbgOp associated with \p ID. Should only be used for IDs
+  /// returned from calling `insert` from this map or DbgOpID::UndefID.
+  DbgOp find(DbgOpID ID) const {
+    if (ID == DbgOpID::UndefID)
+      return DbgOp();
+    if (ID.isConst())
+      return DbgOp(ConstOps[ID.getIndex()]);
+    return DbgOp(ValueOps[ID.getIndex()]);
+  }
+
+  void clear() {
+    ValueOps.clear();
+    ConstOps.clear();
+    ValueOpToID.clear();
+    ConstOpToID.clear();
+  }
+
+private:
+  DbgOpID insertConstOp(MachineOperand &MO) {
+    auto ExistingIt = ConstOpToID.find(MO);
+    if (ExistingIt != ConstOpToID.end())
+      return ExistingIt->second;
+    DbgOpID ID(true, ConstOps.size());
+    ConstOpToID.insert(std::make_pair(MO, ID));
+    ConstOps.push_back(MO);
+    return ID;
+  }
+  DbgOpID insertValueOp(ValueIDNum VID) {
+    auto ExistingIt = ValueOpToID.find(VID);
+    if (ExistingIt != ValueOpToID.end())
+      return ExistingIt->second;
+    DbgOpID ID(false, ValueOps.size());
+    ValueOpToID.insert(std::make_pair(VID, ID));
+    ValueOps.push_back(VID);
+    return ID;
+  }
+};
+
+// We set the maximum number of operands that we will handle to keep DbgValue
+// within a reasonable size (64 bytes), as we store and pass a lot of them
+// around.
+#define MAX_DBG_OPS 8
+
+/// Class recording the (high level) _value_ of a variable. Identifies the value
+/// of the variable as a list of ValueIDNums and constant MachineOperands, or as
+/// an empty list for undef debug values or VPHI values which we have not found
+/// valid locations for.
 /// This class also stores meta-information about how the value is qualified.
 /// Used to reason about variable values when performing the second
 /// (DebugVariable specific) dataflow analysis.
 class DbgValue {
+private:
+  /// If Kind is Def or VPHI, the set of IDs corresponding to the DbgOps that
+  /// are used. VPHIs set every ID to EmptyID when we have not found a valid
+  /// machine-value for every operand, and sets them to the corresponding
+  /// machine-values when we have found all of them.
+  DbgOpID DbgOps[MAX_DBG_OPS];
+  unsigned OpCount;
+
 public:
-  /// If Kind is Def, the value number that this value is based on. VPHIs set
-  /// this field to EmptyValue if there is no machine-value for this VPHI, or
-  /// the corresponding machine-value if there is one.
-  ValueIDNum ID;
-  /// If Kind is Const, the MachineOperand defining this value.
-  Optional<MachineOperand> MO;
   /// For a NoVal or VPHI DbgValue, which block it was generated in.
   int BlockNo;
 
   /// Qualifiers for the ValueIDNum above.
   DbgValueProperties Properties;
 
   typedef enum {
     Undef, // Represents a DBG_VALUE $noreg in the transfer function only.
-    Def,   // This value is defined by an inst, or is a PHI value.
-    Const, // A constant value contained in the MachineOperand field.
+    Def,   // This value is defined by some combination of constants,
+           // instructions, or PHI values.
     VPHI,  // Incoming values to BlockNo differ, those values must be joined by
            // a PHI in this block.
     NoVal, // Empty DbgValue indicating an unknown value. Used as initializer,
            // before dominating blocks values are propagated in.
   } KindT;
   /// Discriminator for whether this is a constant or an in-program value.
   KindT Kind;
 
-  DbgValue(const ValueIDNum &Val, const DbgValueProperties &Prop, KindT Kind)
-      : ID(Val), MO(None), BlockNo(0), Properties(Prop), Kind(Kind) {
-    assert(Kind == Def);
+  DbgValue(ArrayRef<DbgOpID> DbgOps, const DbgValueProperties &Prop)
+      : OpCount(DbgOps.size()), BlockNo(0), Properties(Prop), Kind(Def) {
+    static_assert(sizeof(DbgValue) <= 64,
+                  "DbgValue should fit within 64 bytes.");
+    assert(DbgOps.size() == Prop.getLocationOpCount());
+    if (DbgOps.size() > MAX_DBG_OPS ||
+        any_of(DbgOps, [](DbgOpID ID) { return ID.isUndef(); })) {
+      Kind = Undef;
+      OpCount = 0;
+#define DEBUG_TYPE "LiveDebugValues"
+      if (DbgOps.size() > MAX_DBG_OPS) {
+        LLVM_DEBUG(dbgs() << "Found DbgValue with more than maximum allowed "
+                             "operands.\n");
+      }
+#undef DEBUG_TYPE
+    } else {
+      for (unsigned Idx = 0; Idx < DbgOps.size(); ++Idx)
+        this->DbgOps[Idx] = DbgOps[Idx];
+    }
   }
 
   DbgValue(unsigned BlockNo, const DbgValueProperties &Prop, KindT Kind)
-      : ID(ValueIDNum::EmptyValue), MO(None), BlockNo(BlockNo),
-        Properties(Prop), Kind(Kind) {
+      : OpCount(0), BlockNo(BlockNo), Properties(Prop), Kind(Kind) {
     assert(Kind == NoVal || Kind == VPHI);
   }
 
-  DbgValue(const MachineOperand &MO, const DbgValueProperties &Prop, KindT Kind)
-      : ID(ValueIDNum::EmptyValue), MO(MO), BlockNo(0), Properties(Prop),
-        Kind(Kind) {
-    assert(Kind == Const);
-  }
-
   DbgValue(const DbgValueProperties &Prop, KindT Kind)
-    : ID(ValueIDNum::EmptyValue), MO(None), BlockNo(0), Properties(Prop),
-      Kind(Kind) {
+      : OpCount(0), BlockNo(0), Properties(Prop), Kind(Kind) {
     assert(Kind == Undef &&
            "Empty DbgValue constructor must pass in Undef kind");
   }
 
 #ifndef NDEBUG
-  void dump(const MLocTracker *MTrack) const;
+  void dump(const MLocTracker *MTrack = nullptr,
+            const DbgOpIDMap *OpStore = nullptr) const;
 #endif
 
   bool operator==(const DbgValue &Other) const {
     if (std::tie(Kind, Properties) != std::tie(Other.Kind, Other.Properties))
       return false;
-    else if (Kind == Def && ID != Other.ID)
+    else if (Kind == Def && !equal(getDbgOpIDs(), Other.getDbgOpIDs()))
       return false;
     else if (Kind == NoVal && BlockNo != Other.BlockNo)
       return false;
-    else if (Kind == Const)
-      return MO->isIdenticalTo(*Other.MO);
     else if (Kind == VPHI && BlockNo != Other.BlockNo)
       return false;
-    else if (Kind == VPHI && ID != Other.ID)
+    else if (Kind == VPHI && !equal(getDbgOpIDs(), Other.getDbgOpIDs()))
       return false;
 
     return true;
   }
 
   bool operator!=(const DbgValue &Other) const { return !(*this == Other); }
+
+  // Returns an array of all the machine values used to calculate this variable
+  // value, or an empty list for an Undef or unjoined VPHI.
+  ArrayRef<DbgOpID> getDbgOpIDs() const { return {DbgOps, OpCount}; }
+
+  // Returns either DbgOps[Index] if this DbgValue has Debug Operands, or
+  // the ID for ValueIDNum::EmptyValue otherwise (i.e. if this is an Undef,
+  // NoVal, or an unjoined VPHI).
+  DbgOpID getDbgOpID(unsigned Index) const {
+    if (!OpCount)
+      return DbgOpID::UndefID;
+    assert(Index < OpCount);
+    return DbgOps[Index];
+  }
+  // Replaces this DbgValue's existing DbgOpIDs (if any) with the contents of
+  // \p NewIDs. The number of DbgOpIDs passed must be equal to the number of
+  // arguments expected by this DbgValue's properties (the return value of
+  // `getLocationOpCount()`).
+  void setDbgOpIDs(ArrayRef<DbgOpID> NewIDs) {
+    // We can go from no ops to some ops, but not from some ops to no ops.
+    assert(NewIDs.size() == getLocationOpCount() &&
+           "Incorrect number of Debug Operands for this DbgValue.");
+    OpCount = NewIDs.size();
+    for (unsigned Idx = 0; Idx < NewIDs.size(); ++Idx)
+      DbgOps[Idx] = NewIDs[Idx];
+  }
+
+  // The number of debug operands expected by this DbgValue's expression.
+  // getDbgOpIDs() should return an array of this length, unless this is an
+  // Undef or an unjoined VPHI.
+  unsigned getLocationOpCount() const {
+    return Properties.getLocationOpCount();
+  }
+
+  // Returns true if this or Other are unjoined PHIs, which do not have defined
+  // Loc Ops, or if the `n`th Loc Op for this has a different constness to the
+  // `n`th Loc Op for Other.
+  bool hasJoinableLocOps(const DbgValue &Other) const {
+    if (isUnjoinedPHI() || Other.isUnjoinedPHI())
+      return true;
+    for (unsigned Idx = 0; Idx < getLocationOpCount(); ++Idx) {
+      if (getDbgOpID(Idx).isConst() != Other.getDbgOpID(Idx).isConst())
+        return false;
+    }
+    return true;
+  }
+
+  bool isUnjoinedPHI() const { return Kind == VPHI && OpCount == 0; }
+
+  bool hasIdenticalValidLocOps(const DbgValue &Other) const {
+    if (!OpCount)
+      return false;
+    return equal(getDbgOpIDs(), Other.getDbgOpIDs());
+  }
 };
 
 class LocIdxToIndexFunctor {
 public:
   using argument_type = LocIdx;
   unsigned operator()(const LocIdx &L) const { return L.asU64(); }
 };
 
public:
   const OverlapMap &OverlappingFragments;
   DbgValueProperties EmptyProperties;
 
 public:
   VLocTracker(const OverlapMap &O, const DIExpression *EmptyExpr)
       : OverlappingFragments(O), EmptyProperties(EmptyExpr, false, false) {}
 
   void defVar(const MachineInstr &MI, const DbgValueProperties &Properties,
-              Optional<ValueIDNum> ID) {
+              const SmallVectorImpl<DbgOpID> &DebugOps) {
     assert(MI.isDebugValue() || MI.isDebugRef());
+    assert(DebugOps.size() <= 1);
     DebugVariable Var(MI.getDebugVariable(), MI.getDebugExpression(),
                       MI.getDebugLoc()->getInlinedAt());
-    DbgValue Rec = (ID) ? DbgValue(*ID, Properties, DbgValue::Def)
-                        : DbgValue(Properties, DbgValue::Undef);
+    DbgValue Rec = (DebugOps.size() > 0)
+                       ? DbgValue(DebugOps, Properties)
 
     // Attempt insertion; overwrite if it's already mapped.
     auto Result = Vars.insert(std::make_pair(Var, Rec));
     if (!Result.second)
       Result.first->second = Rec;
     Scopes[Var] = MI.getDebugLoc().get();
 
     considerOverlaps(Var, MI.getDebugLoc().get());
   }
 
-  void defVar(const MachineInstr &MI, const MachineOperand &MO) {
-    // Only DBG_VALUEs can define constant-valued variables.
-    assert(MI.isDebugValue());
-    DebugVariable Var(MI.getDebugVariable(), MI.getDebugExpression(),
-                      MI.getDebugLoc()->getInlinedAt());
-    DbgValueProperties Properties(MI);
-    DbgValue Rec = DbgValue(MO, Properties, DbgValue::Const);
-
-    // Attempt insertion; overwrite if it's already mapped.
-    auto Result = Vars.insert(std::make_pair(Var, Rec));
-    if (!Result.second)
-      Result.first->second = Rec;
-    Scopes[Var] = MI.getDebugLoc().get();
-
-    considerOverlaps(Var, MI.getDebugLoc().get());
-  }
-
   void considerOverlaps(const DebugVariable &Var, const DILocation *Loc) {
     auto Overlaps = OverlappingFragments.find(
         {Var.getVariable(), Var.getFragmentOrDefault()});
     if (Overlaps == OverlappingFragments.end())
       return;
 
     // Otherwise: terminate any overlapped variable locations.
     for (auto FragmentInfo : Overlaps->second) {
private:
   VarToFragments SeenFragments;
 
   /// Mapping of DBG_INSTR_REF instructions to their values, for those
   /// DBG_INSTR_REFs that call resolveDbgPHIs. These variable references solve
   /// a mini SSA problem caused by DBG_PHIs being cloned, this collection caches
   /// the result.
   DenseMap<MachineInstr *, Optional<ValueIDNum>> SeenDbgPHIs;
 
+  DbgOpIDMap DbgOpStore;
+
   /// True if we need to examine call instructions for stack clobbers. We
   /// normally assume that they don't clobber SP, but stack probes on Windows
   /// do.
   bool AdjustsStackInCalls = false;
 
   /// If AdjustsStackInCalls is true, this holds the name of the target's stack
   /// probe function, which is the function we expect will alter the stack
   /// pointer.
return MemOperand->isStore() &&
            && !MemOperand->getPseudoValue()->isAliased(MFI);
   }
 
   Optional<LocIdx> findLocationForMemOperand(const MachineInstr &MI);
 };
 
 } // namespace LiveDebugValues
 
-namespace llvm {
-using namespace LiveDebugValues;
-
-template <> struct DenseMapInfo<LocIdx> {
-  static inline LocIdx getEmptyKey() { return LocIdx::MakeIllegalLoc(); }
-  static inline LocIdx getTombstoneKey() { return LocIdx::MakeTombstoneLoc(); }
-
-  static unsigned getHashValue(const LocIdx &Loc) { return Loc.asU64(); }
-
-  static bool isEqual(const LocIdx &A, const LocIdx &B) { return A == B; }
-};
-
-template <> struct DenseMapInfo<ValueIDNum> {
-  static inline ValueIDNum getEmptyKey() { return ValueIDNum::EmptyValue; }
-  static inline ValueIDNum getTombstoneKey() {
-    return ValueIDNum::TombstoneValue;
-  }
-
-  static unsigned getHashValue(const ValueIDNum &Val) {
-    return hash_value(Val.asU64());
-  }
-
-  static bool isEqual(const ValueIDNum &A, const ValueIDNum &B) {
-    return A == B;
-  }
-};
-
-} // end namespace llvm
-
 #endif /* LLVM_LIB_CODEGEN_LIVEDEBUGVALUES_INSTRREFBASEDLDV_H */

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

 // carefully thinking about -- instead, they probably autogenerated the code.
 // When this happens, gracefully stop tracking excess spill slots, rather than
 // consuming all the developer's memory.
 static cl::opt<unsigned>
     StackWorkingSetLimit("livedebugvalues-max-stack-slots", cl::Hidden,
                          cl::desc("livedebugvalues-stack-ws-limit"),
                          cl::init(250));
 
+DbgOpID DbgOpID::UndefID = DbgOpID(0xffffffff);
+
 /// Tracker for converting machine value locations and variable values into
 /// variable locations (the output of LiveDebugValues), recorded as DBG_VALUEs
 /// specifying block live-in locations and transfers within blocks.
 ///
 /// Operating on a per-block basis, this class takes a (pre-loaded) MLocTracker
 /// and must be initialized with the set of variable values that are live-in to
 /// the block. The caller then repeatedly calls process(). TransferTracker picks
 /// out variable locations for the live-in variable values (if there _is_ a
public:
 
   /// Load object with live-in variable values. \p mlocs contains the live-in
   /// values in each machine location, while \p vlocs the live-in variable
   /// values. This method picks variable locations for the live-in variables,
   /// creates DBG_VALUEs and puts them in #Transfers, then prepares the other
   /// object fields to track variable locations as we step through the block.
   /// FIXME: could just examine mloctracker instead of passing in \p mlocs?
   void
-  loadInlocs(MachineBasicBlock &MBB, ValueTable &MLocs,
+  loadInlocs(MachineBasicBlock &MBB, ValueTable &MLocs, DbgOpIDMap &DbgOpStore,
              const SmallVectorImpl<std::pair<DebugVariable, DbgValue>> &VLocs,
              unsigned NumLocs) {
     ActiveMLocs.clear();
     ActiveVLocs.clear();
     VarLocs.clear();
     VarLocs.reserve(NumLocs);
     UseBeforeDefs.clear();
     UseBeforeDefVariables.clear();
 
     auto isCalleeSaved = [&](LocIdx L) {
       unsigned Reg = MTracker->LocIdxToLocID[L];
       if (Reg >= MTracker->NumRegs)
         return false;
       for (MCRegAliasIterator RAI(Reg, &TRI, true); RAI.isValid(); ++RAI)
         if (CalleeSavedRegs.test(*RAI))
           return true;
       return false;
     };
 
     // Map of the preferred location for each value.
     DenseMap<ValueIDNum, LocIdx> ValueToLoc;
 
     // Initialized the preferred-location map with illegal locations, to be
     // filled in later.
-    for (const auto &VLoc : VLocs)
-      if (VLoc.second.Kind == DbgValue::Def)
-        ValueToLoc.insert({VLoc.second.ID, LocIdx::MakeIllegalLoc()});
+    for (const auto &VLoc : VLocs) {
+      if (VLoc.second.Kind == DbgValue::Def &&
+          !VLoc.second.getDbgOpID(0).isConst()) {
+        ValueToLoc.insert({DbgOpStore.find(VLoc.second.getDbgOpID(0)).ID,
+                           LocIdx::MakeIllegalLoc()});
+      }
+    }
 
     ActiveMLocs.reserve(VLocs.size());
     ActiveVLocs.reserve(VLocs.size());
 
     // Produce a map of value numbers to the current machine locs they live
     // in. When emulating VarLocBasedImpl, there should only be one
     // location; when not, we get to pick.
     for (auto Location : MTracker->locations()) {
for (auto Location : MTracker->locations()) {
           (!isCalleeSaved(CurLoc) && isCalleeSaved(Idx.asU64()))) {
         // Insert, or overwrite if insertion failed.
         VIt->second = Idx;
       }
     }
 
     // Now map variables to their picked LocIdxes.
     for (const auto &Var : VLocs) {
-      if (Var.second.Kind == DbgValue::Const) {
+      DbgOpID OpID = Var.second.getDbgOpID(0);
+      DbgOp Op = DbgOpStore.find(OpID);
+      if (Var.second.Kind == DbgValue::Def && OpID.isConst()) {
         PendingDbgValues.push_back(
-            emitMOLoc(*Var.second.MO, Var.first, Var.second.Properties));
+            emitMOLoc(Op.MO, Var.first, Var.second.Properties));
         continue;
       }
 
       // If the value has no location, we can't make a variable location.
-      const ValueIDNum &Num = Var.second.ID;
+      const ValueIDNum &Num = Op.ID;
       auto ValuesPreferredLoc = ValueToLoc.find(Num);
       if (ValuesPreferredLoc->second.isIllegal()) {
         // If it's a def that occurs in this block, register it as a
         // use-before-def to be resolved as we step through the block.
         if (Num.getBlock() == (unsigned)MBB.getNumber() && !Num.isPHI())
           addUseBeforeDef(Var.first, Var.second.Properties, Num);
         else
           recoverAsEntryValue(Var.first, Var.second.Properties, Num);

 //===----------------------------------------------------------------------===//
 //            Implementation
 //===----------------------------------------------------------------------===//
 
 ValueIDNum ValueIDNum::EmptyValue = {UINT_MAX, UINT_MAX, UINT_MAX};
 ValueIDNum ValueIDNum::TombstoneValue = {UINT_MAX, UINT_MAX, UINT_MAX - 1};
 
 #ifndef NDEBUG
-void DbgValue::dump(const MLocTracker *MTrack) const {
-  if (Kind == Const) {
-    MO->dump();
-  } else if (Kind == NoVal) {
-    dbgs() << "NoVal(" << BlockNo << ")";
-  } else if (Kind == VPHI) {
-    dbgs() << "VPHI(" << BlockNo << "," << MTrack->IDAsString(ID) << ")";
+void ResolvedDbgOp::dump(const MLocTracker *MTrack) const {
+  if (IsConst) {
+    dbgs() << MO;
   } else {
-    assert(Kind == Def);
+    dbgs() << MTrack->LocIdxToName(Loc);
+  }
+}
+void DbgOp::dump(const MLocTracker *MTrack) const {
+  if (IsConst) {
+    dbgs() << MO;
+  } else if (!isUndef()) {
     dbgs() << MTrack->IDAsString(ID);
   }
+}
+void DbgOpID::dump(const MLocTracker *MTrack, const DbgOpIDMap *OpStore) const {
+  if (!OpStore) {
+    dbgs() << "ID(" << asU32() << ")";
+  } else {
+    OpStore->find(*this).dump(MTrack);
+  }
+}
+void DbgValue::dump(const MLocTracker *MTrack,
+                    const DbgOpIDMap *OpStore) const {
+  if (Kind == NoVal) {
+    dbgs() << "NoVal(" << BlockNo << ")";
+  } else if (Kind == VPHI || Kind == Def) {
+    if (Kind == VPHI)
+      dbgs() << "VPHI(" << BlockNo << ",";
+    else
+      dbgs() << "Def(";
+    for (unsigned Idx = 0; Idx < getDbgOpIDs().size(); ++Idx) {
+      getDbgOpID(Idx).dump(MTrack, OpStore);
+      if (Idx != 0)
+        dbgs() << ",";
+    }
+    dbgs() << ")";
+  }
   if (Properties.Indirect)
     dbgs() << " indir";
   if (Properties.DIExpr)
     dbgs() << " " << *Properties.DIExpr;
 }
 #endif
 
 MLocTracker::MLocTracker(MachineFunction &MF, const TargetInstrInfo &TII,
bool InstrRefBasedLDV::transferDebugValue(const MachineInstr &MI) {
   auto *Scope = LS.findLexicalScope(MI.getDebugLoc().get());
   if (Scope == nullptr)
     return true; // handled it; by doing nothing
 
   // For now, ignore DBG_VALUE_LISTs when extending ranges. Allow it to
   // contribute to locations in this block, but don't propagate further.
   // Interpret it like a DBG_VALUE $noreg.
   if (MI.isDebugValueList()) {
+    SmallVector<DbgOpID> EmptyDebugOps;
     if (VTracker)
-      VTracker->defVar(MI, Properties, None);
+      VTracker->defVar(MI, Properties, EmptyDebugOps);
     if (TTracker)
       TTracker->redefVar(MI, Properties, None);
     return true;
   }
 
   const MachineOperand &MO = MI.getDebugOperand(0);
 
   // MLocTracker needs to know that this register is read, even if it's only
   // read by a debug inst.
   if (MO.isReg() && MO.getReg() != 0)
     (void)MTracker->readReg(MO.getReg());
 
   // If we're preparing for the second analysis (variables), the machine value
   // locations are already solved, and we report this DBG_VALUE and the value
   // it refers to to VLocTracker.
   if (VTracker) {
+    SmallVector<DbgOpID> DebugOps;
+    // Feed defVar the new variable location, or if this is a DBG_VALUE $noreg,
+    // feed defVar None.
+    if (!MI.isUndefDebugValue()) {
+      // There should be no undef registers here, as we've screened for undef
+      // debug values.
       if (MO.isReg()) {
-      // Feed defVar the new variable location, or if this is a
-      // DBG_VALUE $noreg, feed defVar None.
-      if (MO.getReg())
-        VTracker->defVar(MI, Properties, MTracker->readReg(MO.getReg()));
-      else
-        VTracker->defVar(MI, Properties, None);
+        DebugOps.push_back(DbgOpStore.insert(MTracker->readReg(MO.getReg())));
       } else if (MO.isImm() || MO.isFPImm() || MO.isCImm()) {
-      VTracker->defVar(MI, MO);
+        DebugOps.push_back(DbgOpStore.insert(MO));
+      } else {
+        llvm_unreachable("Unexpected debug operand type.");
       }
     }
+    VTracker->defVar(MI, Properties, DebugOps);
+  }
 
   // If performing final tracking of transfers, report this variable definition
   // to the TransferTracker too.
   if (TTracker)
     TTracker->redefVar(MI);
   return true;
 }
 
if (NewID && !SeenSubregs.empty()) {
     }
   }
 
   // We, we have a value number or None. Tell the variable value tracker about
   // it. The rest of this LiveDebugValues implementation acts exactly the same
   // for DBG_INSTR_REFs as DBG_VALUEs (just, the former can refer to values that
   // aren't immediately available).
   DbgValueProperties Properties(Expr, false, false);
+  SmallVector<DbgOpID> DbgOpIDs;
+  if (NewID)
+    DbgOpIDs.push_back(DbgOpStore.insert(*NewID));
   if (VTracker)
-    VTracker->defVar(MI, Properties, NewID);
+    VTracker->defVar(MI, Properties, DbgOpIDs);
 
   // If we're on the final pass through the function, decompose this INSTR_REF
   // into a plain DBG_VALUE.
   if (!TTracker)
     return true;
 
   // Pick a location for the machine value number, if such a location exists.
   // (This information could be stored in TransferTracker to make it faster).
if (!FoundLoc && NewID && NewID->getBlock() == CurBB &&
     TTracker->addUseBeforeDef(V, {MI.getDebugExpression(), false, false},
                               *NewID);
 
   // Produce a DBG_VALUE representing what this DBG_INSTR_REF meant.
   // This DBG_VALUE is potentially a $noreg / undefined location, if
   // FoundLoc is None.
   // (XXX -- could morph the DBG_INSTR_REF in the future).
   MachineInstr *DbgMI = MTracker->emitLoc(FoundLoc, V, Properties);
+
   TTracker->PendingDbgValues.push_back(DbgMI);
   TTracker->flushDbgValues(MI.getIterator(), nullptr);
   return true;
 }
 
 bool InstrRefBasedLDV::transferDebugPHI(MachineInstr &MI) {
   if (!MI.isDebugPHI())
     return false;
Optional<ValueIDNum> InstrRefBasedLDV::pickVPHILoc(
   for (const auto *p : BlockOrders) {
     unsigned ThisBBNum = p->getNumber();
     auto OutValIt = LiveOuts.find(p);
     if (OutValIt == LiveOuts.end())
       // If we have a predecessor not in scope, we'll never find a PHI position.
       return None;
     const DbgValue &OutVal = *OutValIt->second;
 
-    if (OutVal.Kind == DbgValue::Const || OutVal.Kind == DbgValue::NoVal)
+    if (OutVal.getDbgOpID(0).isConst() || OutVal.Kind == DbgValue::NoVal)
       // Consts and no-values cannot have locations we can join on.
       return None;
 
     Properties.push_back(&OutVal.Properties);
 
     // Create new empty vector of locations.
     Locs.resize(Locs.size() + 1);
 
     // If the live-in value is a def, find the locations where that value is
     // present. Do the same for VPHIs where we know the VPHI value.
     if (OutVal.Kind == DbgValue::Def ||
         (OutVal.Kind == DbgValue::VPHI && OutVal.BlockNo != MBB.getNumber() &&
-         OutVal.ID != ValueIDNum::EmptyValue)) {
-      ValueIDNum ValToLookFor = OutVal.ID;
+         !OutVal.getDbgOpID(0).isUndef())) {
+      ValueIDNum ValToLookFor = DbgOpStore.find(OutVal.getDbgOpID(0)).ID;
       // Search the live-outs of the predecessor for the specified value.
       for (unsigned int I = 0; I < NumLocs; ++I) {
         if (MOutLocs[ThisBBNum][I] == ValToLookFor)
           Locs.back().push_back(LocIdx(I));
       }
     } else {
       assert(OutVal.Kind == DbgValue::VPHI);
       // For VPHIs where we don't know the location, we definitely can't find
bool InstrRefBasedLDV::vlocJoin(
   // Scan for variable values that can never be resolved: if they have
   // different DIExpressions, different indirectness, or are mixed constants /
   // non-constants.
   for (auto &V : Values) {
     if (V.second->Properties != FirstVal.Properties)
       return false;
     if (V.second->Kind == DbgValue::NoVal)
       return false;
-    if (V.second->Kind == DbgValue::Const && FirstVal.Kind != DbgValue::Const)
+    if (!V.second->hasJoinableLocOps(FirstVal))
       return false;
   }
 
   // Try to eliminate this PHI. Do the incoming values all agree?
   bool Disagree = false;
   for (auto &V : Values) {
     if (*V.second == FirstVal)
       continue; // No disagreement.
 
     // If both values are not equal but have equal non-empty IDs then they refer
     // to the same value from different sources (e.g. one is VPHI and the other
     // is Def), which does not cause disagreement.
-    if (V.second->ID != ValueIDNum::EmptyValue && V.second->ID == FirstVal.ID)
+    if (V.second->hasIdenticalValidLocOps(FirstVal))
       continue;
 
     // Eliminate if a backedge feeds a VPHI back into itself.
     if (V.second->Kind == DbgValue::VPHI &&
         V.second->BlockNo == MBB.getNumber() &&
         // Is this a backedge?
         std::distance(Values.begin(), &V) >= BackEdgesStart)
       continue;
while (!Worklist.empty() || !Pending.empty()) {
           // There's a small possibility that on a preceeding path, a VPHI is
           // eliminated and transitions from VPHI-with-location to
           // live-through-value. As a result, the selected location of any VPHI
           // might change, so we need to re-compute it on each iteration.
           Optional<ValueIDNum> ValueNum =
               pickVPHILoc(*MBB, Var, LiveOutIdx, MOutLocs, Preds);
 
           if (ValueNum) {
-            InLocsChanged |= LiveIn->ID != *ValueNum;
-            LiveIn->ID = *ValueNum;
+            DbgOpID ValueID = DbgOpStore.insert(*ValueNum);
+            InLocsChanged |= LiveIn->getDbgOpID(0) != ValueID;
+            LiveIn->setDbgOpIDs(ValueID);
           }
         }
 
         if (!InLocsChanged && !FirstTrip)
           continue;
 
         DbgValue *LiveOut = LiveOutIdx[MBB];
         bool OLChanged = false;
for (const auto &Var : VarsWeCareAbout) {
 
     // Save live-ins to output vector. Ignore any that are still marked as being
     // VPHIs with no location -- those are variables that we know the value of,
     // but are not actually available in the register file.
     for (auto *MBB : BlockOrders) {
       DbgValue *BlockLiveIn = LiveInIdx[MBB];
       if (BlockLiveIn->Kind == DbgValue::NoVal)
         continue;
-      if (BlockLiveIn->Kind == DbgValue::VPHI &&
-          BlockLiveIn->ID == ValueIDNum::EmptyValue)
+      if (BlockLiveIn->isUnjoinedPHI())
         continue;
       if (BlockLiveIn->Kind == DbgValue::VPHI)
         BlockLiveIn->Kind = DbgValue::Def;
       assert(BlockLiveIn->Properties.DIExpr->getFragmentInfo() ==
              Var.getFragment() && "Fragment info missing during value prop");
       Output[MBB->getNumber()].push_back(std::make_pair(Var, *BlockLiveIn));
     }
   } // Per-variable loop.
bool InstrRefBasedLDV::depthFirstVLocAndEmit(
   auto EjectBlock = [&](MachineBasicBlock &MBB) -> void {
     unsigned BBNum = MBB.getNumber();
     AllTheVLocs[BBNum].clear();
 
     // Prime the transfer-tracker, and then step through all the block
     // instructions, installing transfers.
     MTracker->reset();
     MTracker->loadFromArray(MInLocs[BBNum], BBNum);
-    TTracker->loadInlocs(MBB, MInLocs[BBNum], Output[BBNum], NumLocs);
+    TTracker->loadInlocs(MBB, MInLocs[BBNum], DbgOpStore, Output[BBNum],
+                         NumLocs);
 
     CurBB = BBNum;
     CurInst = 1;
     for (auto &MI : MBB) {
       process(MI, MOutLocs.get(), MInLocs.get());
       TTracker->checkInstForNewValues(CurInst, MI.getIterator());
       ++CurInst;
     }
bool InstrRefBasedLDV::ExtendRanges(MachineFunction &MF,
   OrderToBB.clear();
   BBToOrder.clear();
   BBNumToRPO.clear();
   DebugInstrNumToInstr.clear();
   DebugPHINumToValue.clear();
   OverlapFragments.clear();
   SeenFragments.clear();
   SeenDbgPHIs.clear();
+  DbgOpStore.clear();
 
   return Changed;
 }
 
 LDVImpl *llvm::makeInstrRefBasedLiveDebugValues() {
   return new InstrRefBasedLDV();
 }
 

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

public:
   }
 
   void addVTracker() {
     ASSERT_TRUE(LDV);
     VTracker = std::make_unique<VLocTracker>(Overlaps, EmptyExpr);
     LDV->VTracker = &*VTracker;
   }
 
+  DbgOpID addValueDbgOp(ValueIDNum V) {
+    return LDV->DbgOpStore.insert(DbgOp(V));
+  }
+  DbgOpID addConstDbgOp(MachineOperand MO) {
+    return LDV->DbgOpStore.insert(DbgOp(MO));
+  }
+
   // Some routines for bouncing into LDV,
   void buildMLocValueMap(FuncValueTable &MInLocs, FuncValueTable &MOutLocs,
                          SmallVectorImpl<MLocTransferMap> &MLocTransfer) {
     LDV->buildMLocValueMap(*MF, MInLocs, MOutLocs, MLocTransfer);
   }
 
   void placeMLocPHIs(MachineFunction &MF,
                      SmallPtrSetImpl<MachineBasicBlock *> &AllBlocks,
TEST_F(InstrRefLDVTest, pickVPHILocDiamond) {
   initValueArray(MOutLocs, 4, 2);
 
   unsigned EntryBlk = 0, Br2Blk = 2, RetBlk = 3;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk2(Br2Blk, 0, RspLoc);
   ValueIDNum RspPHIInBlk3(RetBlk, 0, RspLoc);
+  DbgOpID LiveInRspID = addValueDbgOp(LiveInRsp);
+  DbgOpID LiveInRaxID = addValueDbgOp(LiveInRax);
+  DbgOpID RspPHIInBlk2ID = addValueDbgOp(RspPHIInBlk2);
+  DbgOpID RspPHIInBlk3ID = addValueDbgOp(RspPHIInBlk3);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
   SmallVector<DbgValue, 32> VLiveOuts;
   VLiveOuts.resize(4, DbgValue(EmptyProps, DbgValue::Undef));
   InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
   VLiveOutIdx[MBB2] = &VLiveOuts[2];
   VLiveOutIdx[MBB3] = &VLiveOuts[3];
 
   SmallVector<const MachineBasicBlock *, 2> Preds;
   for (const auto *Pred : MBB3->predecessors())
     Preds.push_back(Pred);
 
   // Specify the live-outs around the joining block.
   MOutLocs[1][0] = LiveInRsp;
   MOutLocs[2][0] = LiveInRax;
 
   Optional<ValueIDNum> Result;
 
   // Simple case: join two distinct values on entry to the block.
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRaxID, EmptyProps);
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   // Should have picked a PHI in $rsp in block 3.
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk3);
   }
 
   // If the incoming values are swapped between blocks, we should not
   // successfully join. The CFG merge would select the right values, but in
   // the wrong conditions.
   std::swap(VLiveOuts[1], VLiveOuts[2]);
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Swap back,
   std::swap(VLiveOuts[1], VLiveOuts[2]);
   // Setting one of these to being a constant should prohibit merging.
-  VLiveOuts[1].Kind = DbgValue::Const;
-  VLiveOuts[1].MO = MachineOperand::CreateImm(0);
+  VLiveOuts[1].setDbgOpIDs(addConstDbgOp(MachineOperand::CreateImm(0)));
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Seeing both to being a constant -> still prohibit, it shouldn't become
   // a value in the register file anywhere.
   VLiveOuts[2] = VLiveOuts[1];
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // NoVals shouldn't join with anything else.
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::NoVal);
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // We might merge in another VPHI in such a join. Present pickVPHILoc with
   // such a scenario: first, where one incoming edge has a VPHI with no known
   // value. This represents an edge where there was a PHI value that can't be
   // found in the register file -- we can't subsequently find a PHI here.
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::VPHI);
-  EXPECT_EQ(VLiveOuts[2].ID, ValueIDNum::EmptyValue);
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // However, if we know the value of the incoming VPHI, we can search for its
   // location. Use a PHI machine-value for doing this, as VPHIs should always
   // have PHI values, or they should have been eliminated.
   MOutLocs[2][0] = RspPHIInBlk2;
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::VPHI);
-  VLiveOuts[2].ID = RspPHIInBlk2; // Set location where PHI happens.
+  VLiveOuts[2].setDbgOpIDs(RspPHIInBlk2ID); // Set location where PHI happens.
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk3);
   }
 
   // If that value isn't available from that block, don't join.
   MOutLocs[2][0] = LiveInRsp;
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Check that we don't pick values when the properties disagree, for example
   // different indirectness or DIExpression.
   DIExpression *NewExpr =
       DIExpression::prepend(EmptyExpr, DIExpression::ApplyOffset, 4);
   DbgValueProperties PropsWithExpr(NewExpr, false, false);
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRsp, PropsWithExpr, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRspID, PropsWithExpr);
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   DbgValueProperties PropsWithIndirect(EmptyExpr, true, false);
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRsp, PropsWithIndirect, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRspID, PropsWithIndirect);
   Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 }
 
 TEST_F(InstrRefLDVTest, pickVPHILocLoops) {
   setupSimpleLoop();
   //    entry
   //     |
TEST_F(InstrRefLDVTest, pickVPHILocLoops) {
   initValueArray(MOutLocs, 3, 2);
 
   unsigned EntryBlk = 0, LoopBlk = 1;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk1(LoopBlk, 0, RspLoc);
   ValueIDNum RaxPHIInBlk1(LoopBlk, 0, RaxLoc);
+  DbgOpID LiveInRspID = addValueDbgOp(LiveInRsp);
+  DbgOpID LiveInRaxID = addValueDbgOp(LiveInRax);
+  DbgOpID RspPHIInBlk1ID = addValueDbgOp(RspPHIInBlk1);
+  DbgOpID RaxPHIInBlk1ID = addValueDbgOp(RaxPHIInBlk1);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
   SmallVector<DbgValue, 32> VLiveOuts;
   VLiveOuts.resize(3, DbgValue(EmptyProps, DbgValue::Undef));
   InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
   VLiveOutIdx[MBB2] = &VLiveOuts[2];
 
   SmallVector<const MachineBasicBlock *, 2> Preds;
   for (const auto *Pred : MBB1->predecessors())
     Preds.push_back(Pred);
 
   // Specify the live-outs around the joining block.
   MOutLocs[0][0] = LiveInRsp;
   MOutLocs[1][0] = LiveInRax;
 
   Optional<ValueIDNum> Result;
 
   // See that we can merge as normal on a backedge.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[1] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[1] = DbgValue(LiveInRaxID, EmptyProps);
   Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   // Should have picked a PHI in $rsp in block 1.
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk1);
   }
 
   // And that, if the desired values aren't available, we don't merge.
   MOutLocs[1][0] = LiveInRsp;
   Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Test the backedge behaviour: PHIs that feed back into themselves can
   // carry this variables value. Feed in LiveInRsp in both $rsp and $rax
   // from the entry block, but only put an appropriate backedge PHI in $rax.
   // Only the $rax location can form the correct PHI.
   MOutLocs[0][0] = LiveInRsp;
   MOutLocs[0][1] = LiveInRsp;
   MOutLocs[1][0] = RaxPHIInBlk1;
   MOutLocs[1][1] = RaxPHIInBlk1;
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   // Crucially, a VPHI originating in this block:
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RaxPHIInBlk1);
   }
 
   // Merging should not be permitted if there's a usable PHI on the backedge,
   // but it's in the wrong place. (Overwrite $rax).
   MOutLocs[1][1] = LiveInRax;
   Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Additionally, if the VPHI coming back on the loop backedge isn't from
   // this block (block 1), we can't merge it.
   MOutLocs[1][1] = RaxPHIInBlk1;
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(0, EmptyProps, DbgValue::VPHI);
   Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 }
 
 TEST_F(InstrRefLDVTest, pickVPHILocBadlyNestedLoops) {
   // Run some tests similar to pickVPHILocLoops, with more than one backedge,
   // and check that we merge correctly over many candidate locations.
TEST_F(InstrRefLDVTest, pickVPHILocBadlyNestedLoops) {
   unsigned EntryBlk = 0, Loop1Blk = 1;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum LiveInRbx(EntryBlk, 0, RbxLoc);
   ValueIDNum RspPHIInBlk1(Loop1Blk, 0, RspLoc);
   ValueIDNum RaxPHIInBlk1(Loop1Blk, 0, RaxLoc);
   ValueIDNum RbxPHIInBlk1(Loop1Blk, 0, RbxLoc);
+  DbgOpID LiveInRspID = addValueDbgOp(LiveInRsp);
+  DbgOpID LiveInRaxID = addValueDbgOp(LiveInRax);
+  DbgOpID LiveInRbxID = addValueDbgOp(LiveInRbx);
+  DbgOpID RspPHIInBlk1ID = addValueDbgOp(RspPHIInBlk1);
+  DbgOpID RaxPHIInBlk1ID = addValueDbgOp(RaxPHIInBlk1);
+  DbgOpID RbxPHIInBlk1ID = addValueDbgOp(RbxPHIInBlk1);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
   SmallVector<DbgValue, 32> VLiveOuts;
   VLiveOuts.resize(5, DbgValue(EmptyProps, DbgValue::Undef));
   InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
TEST_F(InstrRefLDVTest, pickVPHILocBadlyNestedLoops) {
   // entry block, self, and loop2.
   MOutLocs[0][0] = LiveInRsp;
   MOutLocs[1][0] = LiveInRax;
   MOutLocs[2][0] = LiveInRbx;
 
   Optional<ValueIDNum> Result;
 
   // See that we can merge as normal on a backedge.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[1] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRbx, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[1] = DbgValue(LiveInRaxID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRbxID, EmptyProps);
   Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   // Should have picked a PHI in $rsp in block 1.
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk1);
   }
 
   // Check too that permuting the live-out locations prevents merging
TEST_F(InstrRefLDVTest, pickVPHILocBadlyNestedLoops) {
   // Feeding a PHI back on one backedge shouldn't merge (block 1 self backedge
   // wants LiveInRax).
   MOutLocs[1][0] = RspPHIInBlk1;
   Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // If the variables value on that edge is a VPHI feeding into itself, that's
   // fine.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
-  VLiveOuts[2] = DbgValue(LiveInRbx, EmptyProps, DbgValue::Def);
+  VLiveOuts[2] = DbgValue(LiveInRbxID, EmptyProps);
   Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk1);
   }
 
   // Likewise: the other backedge being a VPHI from block 1 should be accepted.
   MOutLocs[2][0] = RspPHIInBlk1;
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   VLiveOuts[2] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk1);
   }
 
TEST_F(InstrRefLDVTest, vlocJoinDiamond) {
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
   unsigned EntryBlk = 0, Br2Blk = 2, RetBlk = 3;
 
-  ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
-  ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
-  ValueIDNum RspPHIInBlkBr2Blk(Br2Blk, 0, RspLoc);
-  ValueIDNum RspPHIInBlkRetBlk(RetBlk, 0, RspLoc);
+  DbgOpID LiveInRspID = DbgOpID(false, 0);
+  DbgOpID LiveInRaxID = DbgOpID(false, 1);
+  DbgOpID RspPHIInBlkBr2BlkID = DbgOpID(false, 2);
+  DbgOpID RspPHIInBlkRetBlkID = DbgOpID(false, 3);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
   SmallVector<DbgValue, 32> VLiveOuts;
   VLiveOuts.resize(4, DbgValue(EmptyProps, DbgValue::Undef));
   InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
for (const auto *Pred : MBB3->predecessors())
     Preds.push_back(Pred);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   // vlocJoin is here to propagate incoming values, and eliminate PHIs. Start
   // off by propagating a value into the merging block, number 3.
   DbgValue JoinedLoc = DbgValue(3, EmptyProps, DbgValue::NoVal);
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRspID, EmptyProps);
   bool Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result); // Output locs should have changed.
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::Def);
-  EXPECT_EQ(JoinedLoc.ID, LiveInRsp);
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), LiveInRspID);
 
   // And if we did it a second time, leaving the live-ins as it was, then
   // we should report no change.
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_FALSE(Result);
 
   // If the live-in variable values are different, but there's no PHI placed
   // in this block, then just pick a location. It should be the first (in RPO)
   // predecessor to avoid being a backedge.
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRaxID, EmptyProps);
   JoinedLoc = DbgValue(3, EmptyProps, DbgValue::NoVal);
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::Def);
   // RPO is blocks 0 2 1 3, so LiveInRax is picked as the first predecessor
   // of this join.
-  EXPECT_EQ(JoinedLoc.ID, LiveInRax);
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), LiveInRaxID);
 
   // No tests for whether vlocJoin will pass-through a variable with differing
   // expressions / properties. Those can only come about due to assignments; and
   // for any assignment at all, a PHI should have been placed at the dominance
   // frontier. We rely on the IDF calculator being accurate (which is OK,
   // because so does the rest of LLVM).
 
   // Try placing a PHI. With differing input values (LiveInRsp, LiveInRax),
   // this PHI should not be eliminated.
   JoinedLoc = DbgValue(3, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   // Expect no change.
   EXPECT_FALSE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
   // This should not have been assigned a fixed value.
-  EXPECT_EQ(JoinedLoc.ID, ValueIDNum::EmptyValue);
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), DbgOpID::UndefID);
   EXPECT_EQ(JoinedLoc.BlockNo, 3);
 
   // Try a simple PHI elimination. Put a PHI in block 3, but LiveInRsp on both
   // incoming edges. Re-load in and out-locs with unrelated values; they're
   // irrelevant.
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRspID, EmptyProps);
   JoinedLoc = DbgValue(3, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::Def);
-  EXPECT_EQ(JoinedLoc.ID, LiveInRsp);
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), LiveInRspID);
 
   // Try the same PHI elimination but with one incoming value being a VPHI
   // referring to the same value.
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::VPHI);
-  VLiveOuts[2].ID = LiveInRsp;
+  VLiveOuts[2].setDbgOpIDs(LiveInRspID);
   JoinedLoc = DbgValue(3, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
-  EXPECT_EQ(JoinedLoc.ID, LiveInRsp);
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), LiveInRspID);
 
   // If the "current" live-in is a VPHI, but not a VPHI generated in the current
   // block, then it's the remains of an earlier value propagation. We should
   // value propagate through this merge. Even if the current incoming values
   // disagree, because we've previously determined any VPHI here is redundant.
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRaxID, EmptyProps);
   JoinedLoc = DbgValue(2, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::Def);
-  EXPECT_EQ(JoinedLoc.ID, LiveInRax); // from block 2
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), LiveInRaxID); // from block 2
 
   // The above test, but test that we will install one value-propagated VPHI
   // over another.
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(0, EmptyProps, DbgValue::VPHI);
   JoinedLoc = DbgValue(2, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
   EXPECT_EQ(JoinedLoc.BlockNo, 0);
 
   // We shouldn't eliminate PHIs when properties disagree.
   DbgValueProperties PropsWithIndirect(EmptyExpr, true, false);
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRsp, PropsWithIndirect, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRspID, PropsWithIndirect);
   JoinedLoc = DbgValue(3, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_FALSE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
   EXPECT_EQ(JoinedLoc.BlockNo, 3);
 
   // Even if properties disagree, we should still value-propagate if there's no
   // PHI to be eliminated. The disagreeing values should work themselves out,
   // seeing how we've determined no PHI is necessary.
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRsp, PropsWithIndirect, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRspID, PropsWithIndirect);
   JoinedLoc = DbgValue(2, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::Def);
-  EXPECT_EQ(JoinedLoc.ID, LiveInRsp);
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), LiveInRspID);
   // Also check properties come from block 2, the first RPO predecessor to block
   // three.
   EXPECT_EQ(JoinedLoc.Properties, PropsWithIndirect);
 
   // Again, disagreeing properties, this time the expr, should cause a PHI to
   // not be eliminated.
   DIExpression *NewExpr =
       DIExpression::prepend(EmptyExpr, DIExpression::ApplyOffset, 4);
   DbgValueProperties PropsWithExpr(NewExpr, false, false);
-  VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRsp, PropsWithExpr, DbgValue::Def);
+  VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRspID, PropsWithExpr);
   JoinedLoc = DbgValue(3, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_FALSE(Result);
+
+  // Try placing a PHI with variadic debug values. With differing input values
+  // (LiveInRsp, LiveInRax), this PHI should not be eliminated.
+  DIExpression *TwoOpExpr =
+      DIExpression::get(Ctx, {dwarf::DW_OP_LLVM_arg, 0, dwarf::DW_OP_LLVM_arg,
+                              1, dwarf::DW_OP_plus});
+  DbgValueProperties TwoOpProps(TwoOpExpr, false, true);
+  DbgOpID Locs0[] = {LiveInRspID, LiveInRaxID};
+  DbgOpID Locs1[] = {LiveInRaxID, LiveInRspID};
+  JoinedLoc = DbgValue(3, TwoOpProps, DbgValue::VPHI);
+  VLiveOuts[1] = DbgValue(Locs0, TwoOpProps);
+  VLiveOuts[2] = DbgValue(Locs1, TwoOpProps);
+  Result = vlocJoin(*MBB3, VLiveOutIdx, AllBlocks, JoinedLoc);
+  // Expect no change.
+  EXPECT_FALSE(Result);
+  EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
+  // This should not have been assigned a fixed value.
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), DbgOpID::UndefID);
+  EXPECT_EQ(JoinedLoc.BlockNo, 3);
 }
 
 TEST_F(InstrRefLDVTest, vlocJoinLoops) {
   setupSimpleLoop();
   //    entry
   //     |
   //     |/-----\
   //    loopblk |
   //     |\-----/
   //     |
   //     ret
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
   unsigned EntryBlk = 0, LoopBlk = 1;
 
-  ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
-  ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
-  ValueIDNum RspPHIInBlk1(LoopBlk, 0, RspLoc);
+  DbgOpID LiveInRspID = DbgOpID(false, 0);
+  DbgOpID LiveInRaxID = DbgOpID(false, 1);
+  DbgOpID RspPHIInBlk1ID = DbgOpID(false, 2);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
   SmallVector<DbgValue, 32> VLiveOuts;
   VLiveOuts.resize(3, DbgValue(EmptyProps, DbgValue::Undef));
   InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
TEST_F(InstrRefLDVTest, vlocJoinLoops) {
   AllVars.insert(Var);
 
   // Test some back-edge-specific behaviours of vloc join. Mostly: the fact that
   // VPHIs that arrive on backedges can be eliminated, despite having different
   // values to the predecessor.
 
   // First: when there's no VPHI placed already, propagate the live-in value of
   // the first RPO predecessor.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[1] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
-  DbgValue JoinedLoc = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[1] = DbgValue(LiveInRaxID, EmptyProps);
+  DbgValue JoinedLoc = DbgValue(LiveInRaxID, EmptyProps);
   bool Result = vlocJoin(*MBB1, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::Def);
-  EXPECT_EQ(JoinedLoc.ID, LiveInRsp);
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), LiveInRspID);
 
   // If there is a VPHI: don't elimiante it if there are disagreeing values.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[1] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[1] = DbgValue(LiveInRaxID, EmptyProps);
   JoinedLoc = DbgValue(1, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB1, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_FALSE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
   EXPECT_EQ(JoinedLoc.BlockNo, 1);
 
   // If we feed this VPHI back into itself though, we can eliminate it.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   JoinedLoc = DbgValue(1, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB1, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::Def);
-  EXPECT_EQ(JoinedLoc.ID, LiveInRsp);
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), LiveInRspID);
 
   // Don't eliminate backedge VPHIs if the predecessors have different
   // properties.
   DIExpression *NewExpr =
       DIExpression::prepend(EmptyExpr, DIExpression::ApplyOffset, 4);
   DbgValueProperties PropsWithExpr(NewExpr, false, false);
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(1, PropsWithExpr, DbgValue::VPHI);
   JoinedLoc = DbgValue(1, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB1, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_FALSE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
   EXPECT_EQ(JoinedLoc.BlockNo, 1);
 
   // Backedges with VPHIs, but from the wrong block, shouldn't be eliminated.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(0, EmptyProps, DbgValue::VPHI);
   JoinedLoc = DbgValue(1, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB1, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_FALSE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
   EXPECT_EQ(JoinedLoc.BlockNo, 1);
 }
 
TEST_F(InstrRefLDVTest, vlocJoinBadlyNestedLoops) {
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
   Register RBX = getRegByName("RBX");
   LocIdx RbxLoc = MTracker->lookupOrTrackRegister(RBX);
 
   unsigned EntryBlk = 0;
 
-  ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
-  ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
-  ValueIDNum LiveInRbx(EntryBlk, 0, RbxLoc);
+  DbgOpID LiveInRspID = DbgOpID(false, 0);
+  DbgOpID LiveInRaxID = DbgOpID(false, 1);
+  DbgOpID LiveInRbxID = DbgOpID(false, 2);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
   SmallVector<DbgValue, 32> VLiveOuts;
   VLiveOuts.resize(5, DbgValue(EmptyProps, DbgValue::Undef));
   InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
TEST_F(InstrRefLDVTest, vlocJoinBadlyNestedLoops) {
   SmallVector<const MachineBasicBlock *, 3> Preds;
   for (const auto *Pred : MBB1->predecessors())
     Preds.push_back(Pred);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   // Test a normal VPHI isn't eliminated.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
-  VLiveOuts[1] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
-  VLiveOuts[2] = DbgValue(LiveInRbx, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
+  VLiveOuts[1] = DbgValue(LiveInRaxID, EmptyProps);
+  VLiveOuts[2] = DbgValue(LiveInRbxID, EmptyProps);
   DbgValue JoinedLoc = DbgValue(1, EmptyProps, DbgValue::VPHI);
   bool Result = vlocJoin(*MBB1, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_FALSE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
   EXPECT_EQ(JoinedLoc.BlockNo, 1);
 
   // Common VPHIs on backedges should merge.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   VLiveOuts[2] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   JoinedLoc = DbgValue(1, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB1, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_TRUE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::Def);
-  EXPECT_EQ(JoinedLoc.ID, LiveInRsp);
+  EXPECT_EQ(JoinedLoc.getDbgOpID(0), LiveInRspID);
 
   // They shouldn't merge if one of their properties is different.
   DbgValueProperties PropsWithIndirect(EmptyExpr, true, false);
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   VLiveOuts[2] = DbgValue(1, PropsWithIndirect, DbgValue::VPHI);
   JoinedLoc = DbgValue(1, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB1, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_FALSE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
   EXPECT_EQ(JoinedLoc.BlockNo, 1);
 
   // VPHIs from different blocks should not merge.
-  VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::VPHI);
   JoinedLoc = DbgValue(1, EmptyProps, DbgValue::VPHI);
   Result = vlocJoin(*MBB1, VLiveOutIdx, AllBlocks, JoinedLoc);
   EXPECT_FALSE(Result);
   EXPECT_EQ(JoinedLoc.Kind, DbgValue::VPHI);
   EXPECT_EQ(JoinedLoc.BlockNo, 1);
 }
 
 // Above are tests for picking VPHI locations, and eliminating VPHIs. No
 // unit-tests are written for evaluating the transfer function as that's
 // pretty straight forwards, or applying VPHI-location-picking to live-ins.
 // Instead, pre-set some machine locations and apply buildVLocValueMap to the
 // existing CFG patterns.
 TEST_F(InstrRefLDVTest, VLocSingleBlock) {
   setupSingleBlock();
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
 
   FuncValueTable MInLocs, MOutLocs;
   std::tie(MInLocs, MOutLocs) = allocValueTables(1, 2);
 
   ValueIDNum LiveInRsp = ValueIDNum(0, 0, RspLoc);
+  DbgOpID LiveInRspID = addValueDbgOp(LiveInRsp);
   MInLocs[0][0] = MOutLocs[0][0] = LiveInRsp;
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
TEST_F(InstrRefLDVTest, VLocSingleBlock) {
   // Test that, with no assignments at all, no mappings are created for the
   // variable in this function.
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output.size(), 0ul);
 
   // If we put an assignment in the transfer function, that should... well,
   // do nothing, because we don't store the live-outs.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output.size(), 0ul);
 
   // There is pretty much nothing else of interest to test with a single block.
   // It's not relevant to the SSA-construction parts of variable values.
 }
 
TEST_F(InstrRefLDVTest, VLocDiamondBlocks) {
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
   unsigned EntryBlk = 0, RetBlk = 3;
 
   ValueIDNum LiveInRsp = ValueIDNum(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax = ValueIDNum(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk3 = ValueIDNum(RetBlk, 0, RspLoc);
+  DbgOpID LiveInRspID = addValueDbgOp(LiveInRsp);
+  DbgOpID LiveInRaxID = addValueDbgOp(LiveInRax);
+  DbgOpID RspPHIInBlk3ID = addValueDbgOp(RspPHIInBlk3);
 
   FuncValueTable MInLocs, MOutLocs;
   std::tie(MInLocs, MOutLocs) = allocValueTables(4, 2);
 
   initValueArray(MInLocs, 4, 2);
   initValueArray(MOutLocs, 4, 2);
 
   DebugVariable Var(FuncVariable, None, nullptr);
buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
 
   // An assignment in the end block should also not affect other blocks; or
   // produce any live-ins.
-  VLocs[3].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[3].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   ClearOutputs();
 
   // Assignments in either of the side-of-diamond blocks should also not be
   // propagated anywhere.
   VLocs[3].Vars.clear();
-  VLocs[2].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[2].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   VLocs[2].Vars.clear();
   ClearOutputs();
 
-  VLocs[1].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[1].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   VLocs[1].Vars.clear();
   ClearOutputs();
 
   // However: putting an assignment in the first block should propagate variable
   // values through to all other blocks, as it dominates.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[0].Vars.clear();
 
   // Additionally, even if that value isn't available in the register file, it
   // should still be propagated, as buildVLocValueMap shouldn't care about
   // what's in the registers (except for PHIs).
   // values through to all other blocks, as it dominates.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRaxID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRaxID);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), LiveInRaxID);
   ClearOutputs();
   VLocs[0].Vars.clear();
 
   // We should get a live-in to the merging block, if there are two assigns of
   // the same value in either side of the diamond.
-  VLocs[1].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[2].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[1].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[2].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[1].Vars.clear();
   VLocs[2].Vars.clear();
 
   // If we assign a value in the entry block, then 'undef' on a branch, we
   // shouldn't have a live-in in the merge block.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   VLocs[1].Vars.insert({Var, DbgValue(EmptyProps, DbgValue::Undef)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Having different values joining into the merge block should mean we have
   // no live-in in that block. Block ones LiveInRax value doesn't appear as a
   // live-in anywhere, it's block internal.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // But on the other hand, if there's a location in the register file where
   // those two values can be joined, do so.
   MOutLocs[1][0] = LiveInRax;
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, RspPHIInBlk3);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), RspPHIInBlk3ID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 }
 
 TEST_F(InstrRefLDVTest, VLocSimpleLoop) {
   setupSimpleLoop();
   //    entry
TEST_F(InstrRefLDVTest, VLocSimpleLoop) {
 
   unsigned EntryBlk = 0, LoopBlk = 1;
 
   ValueIDNum LiveInRsp = ValueIDNum(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax = ValueIDNum(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk1 = ValueIDNum(LoopBlk, 0, RspLoc);
   ValueIDNum RspDefInBlk1 = ValueIDNum(LoopBlk, 1, RspLoc);
   ValueIDNum RaxPHIInBlk1 = ValueIDNum(LoopBlk, 0, RaxLoc);
+  DbgOpID LiveInRspID = addValueDbgOp(LiveInRsp);
+  DbgOpID LiveInRaxID = addValueDbgOp(LiveInRax);
+  DbgOpID RspPHIInBlk1ID = addValueDbgOp(RspPHIInBlk1);
+  DbgOpID RspDefInBlk1ID = addValueDbgOp(RspDefInBlk1);
+  DbgOpID RaxPHIInBlk1ID = addValueDbgOp(RaxPHIInBlk1);
 
   FuncValueTable MInLocs, MOutLocs;
   std::tie(MInLocs, MOutLocs) = allocValueTables(3, 2);
 
   initValueArray(MInLocs, 3, 2);
   initValueArray(MOutLocs, 3, 2);
 
   DebugVariable Var(FuncVariable, None, nullptr);
TEST_F(InstrRefLDVTest, VLocSimpleLoop) {
 
   auto ClearOutputs = [&]() {
     for (auto &Elem : Output)
       Elem.clear();
   };
   Output.resize(3);
 
   // Easy starter: a dominating assign should propagate to all blocks.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Put an undef assignment in the loop. Should get no live-in value.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   VLocs[1].Vars.insert({Var, DbgValue(EmptyProps, DbgValue::Undef)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Assignment of the same value should naturally join.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Assignment of different values shouldn't join with no machine PHI vals.
   // Will be live-in to exit block as it's dominated.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRaxID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Install a completely unrelated PHI value, that we should not join on. Try
   // with unrelated assign in loop block again.
   MInLocs[1][0] = RspPHIInBlk1;
   MOutLocs[1][0] = RspDefInBlk1;
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRaxID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Now, if we assign RspDefInBlk1 in the loop block, we should be able to
   // find the appropriate PHI.
   MInLocs[1][0] = RspPHIInBlk1;
   MOutLocs[1][0] = RspDefInBlk1;
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(RspDefInBlk1, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(RspDefInBlk1ID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, RspPHIInBlk1);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), RspPHIInBlk1ID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, RspDefInBlk1);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), RspDefInBlk1ID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // If the PHI happens in a different location, the live-in should happen
   // there.
   MInLocs[1][0] = LiveInRsp;
   MOutLocs[1][0] = LiveInRsp;
   MInLocs[1][1] = RaxPHIInBlk1;
   MOutLocs[1][1] = RspDefInBlk1;
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(RspDefInBlk1, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(RspDefInBlk1ID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, RaxPHIInBlk1);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), RaxPHIInBlk1ID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, RspDefInBlk1);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), RspDefInBlk1ID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // The PHI happening in both places should be handled too. Exactly where
   // isn't important, but if the location picked changes, this test will let
   // you know.
   MInLocs[1][0] = RaxPHIInBlk1;
   MOutLocs[1][0] = RspDefInBlk1;
   MInLocs[1][1] = RaxPHIInBlk1;
   MOutLocs[1][1] = RspDefInBlk1;
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(RspDefInBlk1, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(RspDefInBlk1ID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   // Today, the first register is picked.
-  EXPECT_EQ(Output[1][0].second.ID, RspPHIInBlk1);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), RspPHIInBlk1ID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, RspDefInBlk1);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), RspDefInBlk1ID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // If the loop block looked a bit like this:
   //    %0 = PHI %1, %2
   //    [...]
   //    DBG_VALUE %0
   // Then with instr-ref it becomes:
   //    DBG_PHI %0
   //    [...]
   //    DBG_INSTR_REF
   // And we would be feeding a machine PHI-value back around the loop. However:
   // this does not mean we can eliminate the variable value PHI and use the
   // variable value from the entry block: they are distinct values that must be
   // joined at some location by the control flow.
   // [This test input would never occur naturally, the machine-PHI would be
   //  eliminated]
   MInLocs[1][0] = RspPHIInBlk1;
   MOutLocs[1][0] = RspPHIInBlk1;
   MInLocs[1][1] = LiveInRax;
   MOutLocs[1][1] = LiveInRax;
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(RspPHIInBlk1, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(RspPHIInBlk1ID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, RspPHIInBlk1);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), RspPHIInBlk1ID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, RspPHIInBlk1);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), RspPHIInBlk1ID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Test that we can eliminate PHIs. A PHI will be placed at the loop head
   // because there's a def in in.
   MInLocs[1][0] = LiveInRsp;
   MOutLocs[1][0] = LiveInRsp;
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 }
 
 // test phi elimination with the nested situation
 TEST_F(InstrRefLDVTest, VLocNestedLoop) {
   //    entry
TEST_F(InstrRefLDVTest, VLocNestedLoop) {
 
   unsigned EntryBlk = 0, Loop1Blk = 1, Loop2Blk = 2;
 
   ValueIDNum LiveInRsp = ValueIDNum(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax = ValueIDNum(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk1 = ValueIDNum(Loop1Blk, 0, RspLoc);
   ValueIDNum RspPHIInBlk2 = ValueIDNum(Loop2Blk, 0, RspLoc);
   ValueIDNum RspDefInBlk2 = ValueIDNum(Loop2Blk, 1, RspLoc);
+  DbgOpID LiveInRspID = addValueDbgOp(LiveInRsp);
+  DbgOpID LiveInRaxID = addValueDbgOp(LiveInRax);
+  DbgOpID RspPHIInBlk1ID = addValueDbgOp(RspPHIInBlk1);
+  DbgOpID RspPHIInBlk2ID = addValueDbgOp(RspPHIInBlk2);
+  DbgOpID RspDefInBlk2ID = addValueDbgOp(RspDefInBlk2);
 
   FuncValueTable MInLocs, MOutLocs;
   std::tie(MInLocs, MOutLocs) = allocValueTables(5, 2);
 
   initValueArray(MInLocs, 5, 2);
   initValueArray(MOutLocs, 5, 2);
 
   DebugVariable Var(FuncVariable, None, nullptr);
TEST_F(InstrRefLDVTest, VLocNestedLoop) {
 
   auto ClearOutputs = [&]() {
     for (auto &Elem : Output)
       Elem.clear();
   };
   Output.resize(5);
 
   // A dominating assign should propagate to all blocks.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[4][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[4][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[0].Vars.clear();
 
   // Test that an assign in the inner loop causes unresolved PHIs at the heads
   // of both loops, and no output location. Dominated blocks do get values.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[2].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[2].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), LiveInRaxID);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[4][0].second.getDbgOpID(0), LiveInRaxID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[2].Vars.clear();
 
   // Same test, but with no assignment in block 0. We should still get values
   // in dominated blocks.
-  VLocs[2].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[2].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), LiveInRaxID);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[4][0].second.getDbgOpID(0), LiveInRaxID);
   ClearOutputs();
   VLocs[2].Vars.clear();
 
   // Similarly, assignments in the outer loop gives location to dominated
   // blocks, but no PHI locations are found at the outer loop head.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[3].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[3].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[4][0].second.getDbgOpID(0), LiveInRaxID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[3].Vars.clear();
 
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[1].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRaxID);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), LiveInRaxID);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[4][0].second.getDbgOpID(0), LiveInRaxID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // With an assignment of the same value in the inner loop, we should work out
   // that all PHIs can be eliminated and the same value is live-through the
   // whole function.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[2].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[2].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 1ul);
   EXPECT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[4][0].second.ID, LiveInRsp);
+  EXPECT_EQ(Output[4][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[2].Vars.clear();
 
   // If we have an assignment in the inner loop, and a PHI for it at the inner
   // loop head, we could find a live-in location for the inner loop. But because
   // the outer loop has no PHI, we can't find a variable value for outer loop
   // head, so can't have a live-in value for the inner loop head.
   MInLocs[2][0] = RspPHIInBlk2;
   MOutLocs[2][0] = LiveInRax;
   // NB: all other machine locations are LiveInRsp, disallowing a PHI in block
   // one. Even though RspPHIInBlk2 isn't available later in the function, we
   // should still produce a live-in value. The fact it's unavailable is a
   // different concern.
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[2].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[2].Vars.insert({Var, DbgValue(LiveInRaxID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), LiveInRaxID);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
+  EXPECT_EQ(Output[4][0].second.getDbgOpID(0), LiveInRaxID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[2].Vars.clear();
 
   // Have an assignment in inner loop that can have a PHI resolved; and add a
   // machine value PHI to the outer loop head, so that we can find a location
   // all the way through the function.
   MInLocs[1][0] = RspPHIInBlk1;
   MOutLocs[1][0] = RspPHIInBlk1;
   MInLocs[2][0] = RspPHIInBlk2;
   MOutLocs[2][0] = RspDefInBlk2;
   MInLocs[3][0] = RspDefInBlk2;
   MOutLocs[3][0] = RspDefInBlk2;
-  VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLocs[2].Vars.insert({Var, DbgValue(RspDefInBlk2, EmptyProps, DbgValue::Def)});
+  VLocs[0].Vars.insert({Var, DbgValue(LiveInRspID, EmptyProps)});
+  VLocs[2].Vars.insert({Var, DbgValue(RspDefInBlk2ID, EmptyProps)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
                     MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[1][0].second.ID, RspPHIInBlk1);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(0), RspPHIInBlk1ID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[2][0].second.ID, RspPHIInBlk2);
+  EXPECT_EQ(Output[2][0].second.getDbgOpID(0), RspPHIInBlk2ID);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[3][0].second.ID, RspDefInBlk2);
+  EXPECT_EQ(Output[3][0].second.getDbgOpID(0), RspDefInBlk2ID);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
-  EXPECT_EQ(Output[4][0].second.ID, RspDefInBlk2);
+  EXPECT_EQ(Output[4][0].second.getDbgOpID(0), RspDefInBlk2ID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[2].Vars.clear();
 }