[DebugInfo][InstrRef][NFC] Let LDV handle joins for lists of debug ops

[StephenTozer]

Summary

In preparation for adding support for DBG_VALUE_LIST instructions in InstrRefLDV, this patch updates the logic for joining variables at block joins to support joining variables that use multiple debug operands. This is one of the more meaty "logical" changes, although the line count isn't too high - this changes pickVPHILoc to find a valid joined location for every operand, with part of the function being split off into pickValuePHILoc which finds a location for a single operand.

[Orlando]

The additions/changes SGTM but I don't think I'd be able to catch an omission here - imo it's worth @jmorse having a quick look too.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

58–1

is !OutValOp.isUndef() the same as OutValOp.ID != ValueIDNum::EmptyValue?

59

Is Locs.clear() left over from experimental changes? (Looks redundant to me?)

[StephenTozer]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

58–1

Basically, except we're skipping the check for IsConst here (as we assert !IsConst above) - but now that you mention it, might as well keep it the same for consistency's sake and legibility.

[StephenTozer]

Update unit tests, address review comments.

[jmorse]

This looks good -- I've got some comments, but it's a good separation of the two things going on, selecting the location of an operand, and Doing Stuff (TM) for an entire variable value.

Possibly this is in another patch, but: I think this also deserves some straight-forward unit testing of multiple operands, as far as I can see only the single-operand versions are updated? It would be too much testing to have multiple-operand versions of each flavour of control flow, but some higher level testing, like checking values where one operand has different const-ness and the like don't get joined, should catch potential errors in the future.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

0–1

Deleting this makes me twitch a little; and it looks like the code and comment are out of sync, the test is for whether this is a backedge (VPHI defined in the current block feeding back into itself).

I think the way this would fail is where there's an arbitrary, unresolved VPHI feeding into a block: I think without this test, we would then treat it like a live-through value, even if it ends up being something different. There might be some other portion of code that stops such an error being visible.

Does that make sense / is there a positive reason for deleting this?

89

IMO, wants a comment, "If this isn't due to be joined, use the already-agreed value". Seems obvious, but let's affirm future readers understanding.

123

Take reference, avoiding large copy? May or may not have reallocation/invalidation issues.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

8

Could I suggest pickOperandPHILoc -- if we're terming each part of the overall Value an operand, we should make the function names consistent.

8–9

Wording nit -- to me this reads better (clear that we're abstracting over each individual operand, and joining all values of an operand together). This is probably pure taste, how do you feel it reads?

[StephenTozer]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

0–1

Yes - the reason it's deleted here is because the check has been shunted up to pickVPHILoc, before we reach this function; see line 2449:

// For unjoined VPHIs where we don't know the location, we definitely
// can't find a join loc unless the VPHI is a backedge.
if (OutVal.isUnjoinedPHI() && OutVal.BlockNo != MBB.getNumber())
  return false;

[StephenTozer]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

123

Probably sensible - though I think there's a fairly low-hanging fruit optimization to make DbgOp smaller, so it might be better to just fix up that particular thing and make this change unnecessary.

[StephenTozer]

Added some unit tests - I've only added a few, since there's little to test w.r.t. variadic stuff specifically: primarily just that we can join operands for variadic debug values, and that if the join is invalid for at least one operand then the whole thing is invalid; otherwise the function is pretty much just calling the old logic on each element of a list.

Addressed the review comments, with the exception of the const DbgOp & suggestion, because I think it would be better to just make DbgOp smaller (which I'll add separate to this patch).

[StephenTozer]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

123

Actually, beyond just that potential optimization - there's no way to avoid the copy in this case, because DbgOpIDMap.find() creates a new DbgOp to return anyway, so there's no reference to take. The only resolution would be to have DbgOp itself contain a pointer/reference, which would be a more significant change.

[StephenTozer]

Add unit tests.

[Orlando]

It looks like @jmorse's comments have now been addressed - tentative LGTM

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

125

Please clang-format your patch before you land it.

[aeubanks]

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

1972

again, an unused variable, please figure out how to get this warning firing locally

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

 //===- InstrRefBasedImpl.h - Tracking Debug Value MIs ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_CODEGEN_LIVEDEBUGVALUES_INSTRREFBASEDLDV_H
 #define LLVM_LIB_CODEGEN_LIVEDEBUGVALUES_INSTRREFBASEDLDV_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/UniqueVector.h"
 #include "llvm/CodeGen/LexicalScopes.h"
private:
   /// PHI isn't needed.
   /// \p LiveIn Old live-in value, overwritten with new one if live-in changes.
   /// \returns true if any live-ins change value, either from value propagation
   ///          or PHI elimination.
   bool vlocJoin(MachineBasicBlock &MBB, LiveIdxT &VLOCOutLocs,
                 SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
                 DbgValue &LiveIn);
 
-  /// For the given block and live-outs feeding into it, try to find a
-  /// machine location where all the variable values join together.
-  /// \returns Value ID of a machine PHI if an appropriate one is available.
-  Optional<ValueIDNum>
-  pickVPHILoc(const MachineBasicBlock &MBB, const DebugVariable &Var,
+  /// For the given block and live-outs feeding into it, try to find
+  /// machine locations for each debug operand where all the values feeding
+  /// into that operand join together.
+  /// \returns true if a joined location was found for every value that needed
+  ///          to be joined.
+  bool
+  pickVPHILoc(SmallVectorImpl<DbgOpID> &OutValues, const MachineBasicBlock &MBB,
               const LiveIdxT &LiveOuts, FuncValueTable &MOutLocs,
               const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders);
 
+  Optional<ValueIDNum> pickOperandPHILoc(
+      unsigned DbgOpIdx, const MachineBasicBlock &MBB, const LiveIdxT &LiveOuts,
+      FuncValueTable &MOutLocs,
+      const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders);
+
   /// Take collections of DBG_VALUE instructions stored in TTracker, and
   /// install them into their output blocks. Preserves a stable order of
   /// DBG_VALUEs produced (which would otherwise cause nondeterminism) through
   /// the AllVarsNumbering order.
   bool emitTransfers(DenseMap<DebugVariable, unsigned> &AllVarsNumbering);
 
   /// Boilerplate computation of some initial sets, artifical blocks and
   /// RPOT block ordering.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

 //===- InstrRefBasedImpl.cpp - Tracking Debug Value MIs -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file InstrRefBasedImpl.cpp
 ///

 /// is proportional to the working-set size of the function, which the compiler
 /// tries to keep small. (It's also proportional to the number of blocks).
 /// Additionally, we repeatedly perform the second SSA problem analysis with
 /// only the variables and blocks in a single lexical scope, exploiting their
 /// locality.
 ///
 /// ### Terminology
 ///
 /// A machine location is a register or spill slot, a value is something that's
 /// defined by an instruction or PHI node, while a variable value is the value
 /// assigned to a variable. A variable location is a machine location, that must
 /// contain the appropriate variable value. A value that is a PHI node is
 /// occasionally called an mphi.
 ///
 /// The first SSA problem is the "machine value location" problem,
 /// because we're determining which machine locations contain which values.
 /// The "locations" are constant: what's unknown is what value they contain.

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/CodeGen/LexicalScopes.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineInstrBundle.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/CodeGen/MachineOperand.h"

 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/SSAUpdaterImpl.h"
 #include <algorithm>
 #include <cassert>
 #include <climits>
 #include <cstdint>
 #include <functional>
 #include <queue>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 #include "InstrRefBasedImpl.h"
 #include "LiveDebugValues.h"
 
 using namespace llvm;
void InstrRefBasedLDV::BlockPHIPlacement(
   // InstrRefBasedLDV object.
   IDFCalculatorBase<MachineBasicBlock, false> IDF(DomTree->getBase());
 
   IDF.setLiveInBlocks(AllBlocks);
   IDF.setDefiningBlocks(DefBlocks);
   IDF.calculate(PHIBlocks);
 }
 
-Optional<ValueIDNum> InstrRefBasedLDV::pickVPHILoc(
-    const MachineBasicBlock &MBB, const DebugVariable &Var,
+bool InstrRefBasedLDV::pickVPHILoc(
+    SmallVectorImpl<DbgOpID> &OutValues, const MachineBasicBlock &MBB,
     const LiveIdxT &LiveOuts, FuncValueTable &MOutLocs,
     const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders) {
-  // Collect a set of locations from predecessor where its live-out value can
-  // be found.
-  SmallVector<SmallVector<LocIdx, 4>, 8> Locs;
-  SmallVector<const DbgValueProperties *, 4> Properties;
-  unsigned NumLocs = MTracker->getNumLocs();
 
   // No predecessors means no PHIs.
   if (BlockOrders.empty())
-    return None;
+    return false;
 
-  for (const auto *p : BlockOrders) {
-    unsigned ThisBBNum = p->getNumber();
+  // All the location operands that do not already agree need to be joined,
+  // track the indices of each such location operand here.
+  SmallDenseSet<unsigned> LocOpsToJoin;
+
+  auto FirstValueIt = LiveOuts.find(BlockOrders[0]);
+  if (FirstValueIt == LiveOuts.end())
+    return false;
+  const DbgValue &FirstValue = *FirstValueIt->second;
+
+  for (const auto p : BlockOrders) {
     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;
+      return false;
     const DbgValue &OutVal = *OutValIt->second;
 
-    if (OutVal.getDbgOpID(0).isConst() || OutVal.Kind == DbgValue::NoVal)
-      // Consts and no-values cannot have locations we can join on.
-      return None;
+    // No-values cannot have locations we can join on.
+    if (OutVal.Kind == DbgValue::NoVal)
+      return false;
+
+    // For unjoined VPHIs where we don't know the location, we definitely
+    // can't find a join loc unless the VPHI is a backedge.
+    if (OutVal.isUnjoinedPHI() && OutVal.BlockNo != MBB.getNumber())
+      return false;
+
+    if (FirstValue.Properties != OutVal.Properties)
+      return false;
+
+    for (unsigned Idx = 0; Idx < FirstValue.getLocationOpCount(); ++Idx) {
+      // An unjoined PHI has no defined locations, and so a shared location must
+      // be found for every operand.
+      if (OutVal.isUnjoinedPHI()) {
+        LocOpsToJoin.insert(Idx);
+        continue;
+      }
+      DbgOpID FirstValOp = FirstValue.getDbgOpID(Idx);
+      DbgOpID OutValOp = OutVal.getDbgOpID(Idx);
+      if (FirstValOp != OutValOp) {
+        // We can never join constant ops - the ops must either both be equal
+        // constant ops or non-const ops.
+        if (FirstValOp.isConst() || OutValOp.isConst())
+          return false;
+        else
+          LocOpsToJoin.insert(Idx);
+      }
+    }
+  }
+
+  SmallVector<DbgOpID> NewDbgOps;
 
-    Properties.push_back(&OutVal.Properties);
+  for (unsigned Idx = 0; Idx < FirstValue.getLocationOpCount(); ++Idx) {
+    // If this op doesn't need to be joined because the values agree, use that
+    // already-agreed value.
+    if (!LocOpsToJoin.contains(Idx)) {
+      NewDbgOps.push_back(FirstValue.getDbgOpID(Idx));
+      continue;
+    }
+
+    Optional<ValueIDNum> JoinedOpLoc =
+        pickOperandPHILoc(Idx, MBB, LiveOuts, MOutLocs, BlockOrders);
+
+    if (!JoinedOpLoc)
+      return false;
+
+    NewDbgOps.push_back(DbgOpStore.insert(*JoinedOpLoc));
+  }
+
+  OutValues.append(NewDbgOps);
+  return true;
+}
+
+Optional<ValueIDNum> InstrRefBasedLDV::pickOperandPHILoc(
+    unsigned DbgOpIdx, const MachineBasicBlock &MBB, const LiveIdxT &LiveOuts,
+    FuncValueTable &MOutLocs,
+    const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders) {
+
+  // Collect a set of locations from predecessor where its live-out value can
+  // be found.
+  SmallVector<SmallVector<LocIdx, 4>, 8> Locs;
+  unsigned NumLocs = MTracker->getNumLocs();
+
+  for (const auto p : BlockOrders) {
+    unsigned ThisBBNum = p->getNumber();
+    auto OutValIt = LiveOuts.find(p);
+    assert(OutValIt != LiveOuts.end());
+    const DbgValue &OutVal = *OutValIt->second;
+    DbgOpID OutValOpID = OutVal.getDbgOpID(DbgOpIdx);
+    DbgOp OutValOp = DbgOpStore.find(OutValOpID);
+    assert(!OutValOp.IsConst);
 
     // 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.getDbgOpID(0).isUndef())) {
-      ValueIDNum ValToLookFor = DbgOpStore.find(OutVal.getDbgOpID(0)).ID;
+         !OutValOp.isUndef())) {
+      ValueIDNum ValToLookFor = OutValOp.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
-      // a join loc.
-      if (OutVal.BlockNo != MBB.getNumber())
-        return None;
-
       // Otherwise: this is a VPHI on a backedge feeding back into itself, i.e.
       // a value that's live-through the whole loop. (It has to be a backedge,
       // because a block can't dominate itself). We can accept as a PHI location
       // any location where the other predecessors agree, _and_ the machine
       // locations feed back into themselves. Therefore, add all self-looping
       // machine-value PHI locations.
       for (unsigned int I = 0; I < NumLocs; ++I) {
         ValueIDNum MPHI(MBB.getNumber(), 0, LocIdx(I));
         if (MOutLocs[ThisBBNum][I] == MPHI)
           Locs.back().push_back(LocIdx(I));
       }
     }
   }
-
   // We should have found locations for all predecessors, or returned.
   assert(Locs.size() == BlockOrders.size());
 
-  // Check that all properties are the same. We can't pick a location if they're
-  // not.
-  const DbgValueProperties *Properties0 = Properties[0];
-  for (const auto *Prop : Properties)
-    if (*Prop != *Properties0)
-      return None;
-
   // Starting with the first set of locations, take the intersection with
   // subsequent sets.
   SmallVector<LocIdx, 4> CandidateLocs = Locs[0];
   for (unsigned int I = 1; I < Locs.size(); ++I) {
     auto &LocVec = Locs[I];
     SmallVector<LocIdx, 4> NewCandidates;
     std::set_intersection(CandidateLocs.begin(), CandidateLocs.end(),
                           LocVec.begin(), LocVec.end(), std::inserter(NewCandidates, NewCandidates.begin()));
if (LiveIn.Kind != DbgValue::VPHI || LiveIn.BlockNo != MBB.getNumber()) {
     if (Changed)
       LiveIn = FirstVal;
     return Changed;
   }
 
   // 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) {
+  for (const auto &V : Values) {
     if (V.second->Properties != FirstVal.Properties)
       return false;
     if (V.second->Kind == DbgValue::NoVal)
       return false;
     if (!V.second->hasJoinableLocOps(FirstVal))
       return false;
   }
 
while (!Worklist.empty() || !Pending.empty()) {
         // for it. This makes the machine-value available and propagated
         // through all blocks by the time value propagation finishes. We can't
         // do this any earlier as it needs to read the block live-outs.
         if (LiveIn->Kind == DbgValue::VPHI && LiveIn->BlockNo == (int)CurBB) {
           // 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);
+          SmallVector<DbgOpID> JoinedOps;
 
-          if (ValueNum) {
-            DbgOpID ValueID = DbgOpStore.insert(*ValueNum);
-            InLocsChanged |= LiveIn->getDbgOpID(0) != ValueID;
-            LiveIn->setDbgOpIDs(ValueID);
+          if (pickVPHILoc(JoinedOps, *MBB, LiveOutIdx, MOutLocs, Preds)) {
+            bool NewLocPicked = !equal(LiveIn->getDbgOpIDs(), JoinedOps);
+            InLocsChanged |= NewLocPicked;
+            if (NewLocPicked)
+              LiveIn->setDbgOpIDs(JoinedOps);
           }
         }
 
         if (!InLocsChanged && !FirstTrip)
           continue;
 
         DbgValue *LiveOut = LiveOutIdx[MBB];
         bool OLChanged = false;

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

void SetUp() {
     InlinedLoc = DILocation::get(Ctx, 10, 1, ToInlineFunc, InBlockLoc.get());
 
     // Make a scope that isn't nested within the others.
     NotNestedBlockLoc = DILocation::get(Ctx, 4, 1, AnotherBlock);
 
     LongInt = DIB.createBasicType("long", 64, llvm::dwarf::DW_ATE_unsigned);
     FuncVariable = DIB.createAutoVariable(OurFunc, "lala", OurFile, 1, LongInt);
     EmptyExpr = DIExpression::get(Ctx, {});
 
     DIB.finalize();
   }
 
   Register getRegByName(const char *WantedName) {
     auto *TRI = MF->getRegInfo().getTargetRegisterInfo();
     // Slow, but works.
     for (unsigned int I = 1; I < TRI->getNumRegs(); ++I) {
       const char *Name = TRI->getName(I);
public:
 
   void placeMLocPHIs(MachineFunction &MF,
                      SmallPtrSetImpl<MachineBasicBlock *> &AllBlocks,
                      FuncValueTable &MInLocs,
                      SmallVectorImpl<MLocTransferMap> &MLocTransfer) {
     LDV->placeMLocPHIs(MF, AllBlocks, MInLocs, MLocTransfer);
   }
 
-  Optional<ValueIDNum>
-  pickVPHILoc(const MachineBasicBlock &MBB, const DebugVariable &Var,
-              const InstrRefBasedLDV::LiveIdxT &LiveOuts, FuncValueTable &MOutLocs,
+  bool
+  pickVPHILoc(SmallVectorImpl<DbgOpID> &OutValues, const MachineBasicBlock &MBB,
+              const InstrRefBasedLDV::LiveIdxT &LiveOuts,
+              FuncValueTable &MOutLocs,
               const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders) {
-    return LDV->pickVPHILoc(MBB, Var, LiveOuts, MOutLocs, BlockOrders);
+    return LDV->pickVPHILoc(OutValues, MBB, LiveOuts, MOutLocs, BlockOrders);
   }
 
   bool vlocJoin(MachineBasicBlock &MBB, InstrRefBasedLDV::LiveIdxT &VLOCOutLocs,
                 SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
                 DbgValue &InLoc) {
     return LDV->vlocJoin(MBB, VLOCOutLocs, BlocksToExplore, InLoc);
   }
 
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);
+  ValueIDNum RaxPHIInBlk3(RetBlk, 0, RaxLoc);
   DbgOpID LiveInRspID = addValueDbgOp(LiveInRsp);
   DbgOpID LiveInRaxID = addValueDbgOp(LiveInRax);
   DbgOpID RspPHIInBlk2ID = addValueDbgOp(RspPHIInBlk2);
-  addValueDbgOp(RspPHIInBlk3);
+  DbgOpID RspPHIInBlk3ID = addValueDbgOp(RspPHIInBlk3);
+  DbgOpID RaxPHIInBlk3ID = addValueDbgOp(RaxPHIInBlk3);
+  DbgOpID ConstZeroID = addConstDbgOp(MachineOperand::CreateImm(0));
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
+  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);
   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;
+  bool Result;
+  SmallVector<DbgOpID> OutValues;
 
   // Simple case: join two distinct values on entry to the block.
   VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(LiveInRaxID, EmptyProps);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, VLiveOutIdx, MOutLocs, Preds);
   // Should have picked a PHI in $rsp in block 3.
   EXPECT_TRUE(Result);
   if (Result) {
-    EXPECT_EQ(*Result, RspPHIInBlk3);
+    EXPECT_EQ(OutValues[0], RspPHIInBlk3ID);
   }
 
   // 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);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, 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].setDbgOpIDs(addConstDbgOp(MachineOperand::CreateImm(0)));
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
+  VLiveOuts[1].setDbgOpIDs(ConstZeroID);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, 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.
+  // Setting both to being identical constants should result in a valid join
+  // with a constant value.
   VLiveOuts[2] = VLiveOuts[1];
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
-  EXPECT_FALSE(Result);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, VLiveOutIdx, MOutLocs, Preds);
+  EXPECT_TRUE(Result);
+  if (Result) {
+    EXPECT_EQ(OutValues[0], ConstZeroID);
+  }
 
   // NoVals shouldn't join with anything else.
   VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::NoVal);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, 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(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::VPHI);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, 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(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::VPHI);
   VLiveOuts[2].setDbgOpIDs(RspPHIInBlk2ID); // Set location where PHI happens.
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
-    EXPECT_EQ(*Result, RspPHIInBlk3);
+    EXPECT_EQ(OutValues[0], RspPHIInBlk3ID);
   }
 
   // If that value isn't available from that block, don't join.
   MOutLocs[2][0] = LiveInRsp;
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Check that we don't pick values when the properties disagree, for example
   // different indirectness or DIExpression.
+  MOutLocs[2][0] = LiveInRax;
   DIExpression *NewExpr =
       DIExpression::prepend(EmptyExpr, DIExpression::ApplyOffset, 4);
   DbgValueProperties PropsWithExpr(NewExpr, false, false);
   VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(LiveInRspID, PropsWithExpr);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   DbgValueProperties PropsWithIndirect(EmptyExpr, true, false);
   VLiveOuts[1] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[2] = DbgValue(LiveInRspID, PropsWithIndirect);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, VLiveOutIdx, MOutLocs, Preds);
+  EXPECT_FALSE(Result);
+
+  // When we have operands with values [A, B] and [B, A], we do not necessarily
+  // pick identical join locations for each operand if the locations of those
+  // values differ between incoming basic blocks.
+  MOutLocs[1][0] = LiveInRsp;
+  MOutLocs[2][0] = LiveInRax;
+  MOutLocs[1][1] = LiveInRax;
+  MOutLocs[2][1] = LiveInRsp;
+  DbgOpID Locs0[] = {LiveInRspID, LiveInRaxID};
+  DbgOpID Locs1[] = {LiveInRaxID, LiveInRspID};
+  VLiveOuts[1] = DbgValue(Locs0, TwoOpProps);
+  VLiveOuts[2] = DbgValue(Locs1, TwoOpProps);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, VLiveOutIdx, MOutLocs, Preds);
+  // Should have picked PHIs in block 3.
+  EXPECT_TRUE(Result);
+  if (Result) {
+    EXPECT_EQ(OutValues[0], RspPHIInBlk3ID);
+    EXPECT_EQ(OutValues[1], RaxPHIInBlk3ID);
+  }
+
+  // When joining identical constants for an operand, we should simply keep that
+  // constant while joining the remaining operands as normal.
+  DbgOpID Locs2[] = {LiveInRspID, ConstZeroID};
+  DbgOpID Locs3[] = {LiveInRaxID, ConstZeroID};
+  VLiveOuts[1] = DbgValue(Locs2, TwoOpProps);
+  VLiveOuts[2] = DbgValue(Locs3, TwoOpProps);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, VLiveOutIdx, MOutLocs, Preds);
+  EXPECT_TRUE(Result);
+  if (Result) {
+    EXPECT_EQ(OutValues[0], RspPHIInBlk3ID);
+    EXPECT_EQ(OutValues[1], ConstZeroID);
+  }
+
+  // If the debug values have different constants for the same operand, they
+  // cannot be joined.
+  DbgOpID ConstOneID = addConstDbgOp(MachineOperand::CreateImm(1));
+  DbgOpID Locs4[] = {LiveInRaxID, ConstOneID};
+  VLiveOuts[1] = DbgValue(Locs0, TwoOpProps);
+  VLiveOuts[2] = DbgValue(Locs2, TwoOpProps);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB3, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 }
 
 TEST_F(InstrRefLDVTest, pickVPHILocLoops) {
   setupSimpleLoop();
   //    entry
   //     |
   //     |/-----\
TEST_F(InstrRefLDVTest, pickVPHILocLoops) {
   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);
-  addValueDbgOp(RspPHIInBlk1);
-  addValueDbgOp(RaxPHIInBlk1);
+  DbgOpID RspPHIInBlk1ID = addValueDbgOp(RspPHIInBlk1);
+  DbgOpID RaxPHIInBlk1ID = addValueDbgOp(RaxPHIInBlk1);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
+  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);
   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;
+  bool Result;
+  SmallVector<DbgOpID> OutValues;
 
   // See that we can merge as normal on a backedge.
   VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(LiveInRaxID, EmptyProps);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
   // Should have picked a PHI in $rsp in block 1.
   EXPECT_TRUE(Result);
   if (Result) {
-    EXPECT_EQ(*Result, RspPHIInBlk1);
+    EXPECT_EQ(OutValues[0], RspPHIInBlk1ID);
   }
 
   // And that, if the desired values aren't available, we don't merge.
   MOutLocs[1][0] = LiveInRsp;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, 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(LiveInRspID, EmptyProps);
   // Crucially, a VPHI originating in this block:
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
-    EXPECT_EQ(*Result, RaxPHIInBlk1);
+    EXPECT_EQ(OutValues[0], RaxPHIInBlk1ID);
+  }
+
+  // Test that we can also find a location when joining a backedge PHI with
+  // a variadic debug value.
+  MOutLocs[1][0] = RspPHIInBlk1;
+  MOutLocs[0][1] = LiveInRax;
+  DbgOpID Locs0[] = {LiveInRspID, LiveInRaxID};
+  VLiveOuts[0] = DbgValue(Locs0, TwoOpProps);
+  // Crucially, a VPHI originating in this block:
+  VLiveOuts[1] = DbgValue(1, TwoOpProps, DbgValue::VPHI);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
+  EXPECT_TRUE(Result);
+  if (Result) {
+    EXPECT_EQ(OutValues[0], RspPHIInBlk1ID);
+    EXPECT_EQ(OutValues[1], RaxPHIInBlk1ID);
   }
 
   // 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);
+  VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, 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(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(0, EmptyProps, DbgValue::VPHI);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, 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.
   setupBadlyNestedLoops();
   //           entry
TEST_F(InstrRefLDVTest, pickVPHILocBadlyNestedLoops) {
   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);
-  addValueDbgOp(RspPHIInBlk1);
+  DbgOpID RspPHIInBlk1ID = addValueDbgOp(RspPHIInBlk1);
   addValueDbgOp(RaxPHIInBlk1);
-  addValueDbgOp(RbxPHIInBlk1);
+  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];
   VLiveOutIdx[MBB2] = &VLiveOuts[2];
   VLiveOutIdx[MBB3] = &VLiveOuts[3];
   VLiveOutIdx[MBB4] = &VLiveOuts[4];
 
   // We're going to focus on block 1.
   SmallVector<const MachineBasicBlock *, 2> Preds;
   for (const auto *Pred : MBB1->predecessors())
     Preds.push_back(Pred);
 
   // Specify the live-outs around the joining block. Incoming edges from the
   // entry block, self, and loop2.
   MOutLocs[0][0] = LiveInRsp;
   MOutLocs[1][0] = LiveInRax;
   MOutLocs[2][0] = LiveInRbx;
 
-  Optional<ValueIDNum> Result;
+  bool Result;
+  SmallVector<DbgOpID> OutValues;
 
   // See that we can merge as normal on a backedge.
   VLiveOuts[0] = DbgValue(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(LiveInRaxID, EmptyProps);
   VLiveOuts[2] = DbgValue(LiveInRbxID, EmptyProps);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
   // Should have picked a PHI in $rsp in block 1.
   EXPECT_TRUE(Result);
   if (Result) {
-    EXPECT_EQ(*Result, RspPHIInBlk1);
+    EXPECT_EQ(OutValues[0], RspPHIInBlk1ID);
   }
 
   // Check too that permuting the live-out locations prevents merging
   MOutLocs[0][0] = LiveInRax;
   MOutLocs[1][0] = LiveInRbx;
   MOutLocs[2][0] = LiveInRsp;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   MOutLocs[0][0] = LiveInRsp;
   MOutLocs[1][0] = LiveInRax;
   MOutLocs[2][0] = LiveInRbx;
 
   // 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);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, 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(LiveInRspID, EmptyProps);
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   VLiveOuts[2] = DbgValue(LiveInRbxID, EmptyProps);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
-    EXPECT_EQ(*Result, RspPHIInBlk1);
+    EXPECT_EQ(OutValues[0], RspPHIInBlk1ID);
   }
 
   // Likewise: the other backedge being a VPHI from block 1 should be accepted.
   MOutLocs[2][0] = RspPHIInBlk1;
   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);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
-    EXPECT_EQ(*Result, RspPHIInBlk1);
+    EXPECT_EQ(OutValues[0], RspPHIInBlk1ID);
   }
 
   // Here's where it becomes tricky: we should not merge if there are two
   // _distinct_ backedge PHIs. We can't have a PHI that happens in both rsp
   // and rax for example. We can only pick one location as the live-in.
   MOutLocs[2][0] = RaxPHIInBlk1;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // The above test sources correct machine-PHI-value from two places. Now
   // try with one machine-PHI-value, but placed in two different locations
   // on the backedge. Again, we can't merge a location here, there's no
   // location that works on all paths.
   MOutLocs[0][0] = LiveInRsp;
   MOutLocs[1][0] = RspPHIInBlk1;
   MOutLocs[2][0] = LiveInRsp;
   MOutLocs[2][1] = RspPHIInBlk1;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Scatter various PHI values across the available locations. Only rbx (loc 2)
   // has the right value in both backedges -- that's the loc that should be
   // picked.
   MOutLocs[0][2] = LiveInRsp;
   MOutLocs[1][0] = RspPHIInBlk1;
   MOutLocs[1][1] = RaxPHIInBlk1;
   MOutLocs[1][2] = RbxPHIInBlk1;
   MOutLocs[2][0] = LiveInRsp;
   MOutLocs[2][1] = RspPHIInBlk1;
   MOutLocs[2][2] = RbxPHIInBlk1;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
+  OutValues.clear();
+  Result = pickVPHILoc(OutValues, *MBB1, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
-    EXPECT_EQ(*Result, RbxPHIInBlk1);
+    EXPECT_EQ(OutValues[0], RbxPHIInBlk1ID);
   }
 }
 
 TEST_F(InstrRefLDVTest, vlocJoinDiamond) {
   //        entry
   //        /  \
   //      br1  br2
   //        \  /
TEST_F(InstrRefLDVTest, VLocSimpleLoop) {
   FuncValueTable MInLocs, MOutLocs;
   std::tie(MInLocs, MOutLocs) = allocValueTables(3, 2);
 
   initValueArray(MInLocs, 3, 2);
   initValueArray(MOutLocs, 3, 2);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false, false);
+  DIExpression *TwoOpExpr =
+      DIExpression::get(Ctx, {dwarf::DW_OP_LLVM_arg, 0, dwarf::DW_OP_LLVM_arg,
+                              1, dwarf::DW_OP_plus});
+  DbgValueProperties VariadicProps(TwoOpExpr, false, true);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   SmallPtrSet<MachineBasicBlock *, 4> AssignBlocks;
   AssignBlocks.insert(MBB0);
   AssignBlocks.insert(MBB1);
   AssignBlocks.insert(MBB2);
TEST_F(InstrRefLDVTest, VLocSimpleLoop) {
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.getDbgOpID(0), LiveInRspID);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.getDbgOpID(0), LiveInRspID);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
+  // A variadic assignment should behave the same.
+  DbgOpID Locs0[] = {LiveInRspID, LiveInRaxID};
+  VLocs[0].Vars.insert({Var, DbgValue(Locs0, VariadicProps)});
+  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.getDbgOpID(0), LiveInRspID);
+  EXPECT_EQ(Output[1][0].second.getDbgOpID(1), LiveInRaxID);
+  EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
+  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(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);