[DebugInfo] Use DBG_VALUEs IsIndirect field for describing stack spills

[jmorse]

Summary

This is a patch that significantly changes the meaning of the IsIndirect field of DBG_VALUEs. The objective here is to pass more stack-spill information down from LiveDebugVariables to LiveDebugValues: at the moment, if a DBG_VALUE of a stack slot is created by LiveDebugVariables recording a stack spill, then LiveDebugValues interprets it as a register location, not a spill location (see the added test, dbg-value-when-spilt.ll).

Rather than just using IsIndirect to indicate "memory location please" to DwarfExpression.cpp, with this patch it means:

• Between LiveDebugVariables and PrologEpilog and where operand 0 is a stack slot, $noreg means this is a stack _pointer_ variable, immediate means it's a spill location.
• Between PrologEpilog and LiveDebugValues, for spill locations this patch places the frame-index of the spill into the IsIndirect field, sets it to $noreg for everything else.
• IsIndirect is invalid / must be $noreg everywhere else.

This means that when LiveDebugValues handles spill-location DBG_VALUEs, it can extract the frame offset and slot size from the frame index and create a SpillLocKind VarLoc instead of a register location based on the stack pointer. As a result, we can recognise loads from spills that we couldn't before, and, we can access a DIExpression that doesn't have the stack-offset already baked into it. Finally, LiveDebugValues can now propagate stack-spill locations over instructions that modify the stack pointer (like push) as shown in the new dbg-value-of-spill-with-fp.ll.

(This last improvement might be a bit debatable as the debugger would need to be aware that the stack pointer has changed. Ignoring stack-pointer writes for spills is what we do already for LiveDebugValues detected spills. I couldn't quickly convince gcc to cough up a location list with no frame pointer in a function where the stack pointer was modified, so can't show that anyone else does this).

There's a downside however: in some circumstances we newly recognise a spill restore in the middle of a loop, restore it, and then drop both the spilt and restored location for the whole loop because there isn't a single location on entering the head of the loop. For an example, see test/DebugInfo/X86/op_deref.ll where this now happens, I've marked the test XFail until there's been some discussion about this. Happily I think we can say that this is moving LiveDebugValues into the domain of having to make better choices about which location to pick, instead of just trying to stop it producing bad locations! My feeling is that there's a hierarchy of duration, of {volatile-reg, nonvolatile-reg, stack, entry-value}, and it might be worthwhile building this into LiveDebugValues. (Consider also PR43373 [0] which exhibits problems with mixing "long term" and "short term" locations).

Unfortunately there are negligable differences in location coverage on a clang-3.4 build, probably due to a mixture of the above improvements and downsides. This patch might also be too much churn; IMHO getting this information down to LiveDebugValues is something we should aim to do though. If we're going to be aware of spills/restores in LiveDebugValues then we want to know about what was spilt during LiveDebugVariables. Right now, that would have to involve interpreting a DIExpression, which IMO is undesirable.

I've added three new flavours of tests:

• The whole backend of LLVM-IR to dwarf "spill and restore of an arg" performed by regalloc should be tested for. test/DebugInfo/X86/spill-indirect-nrvo.ll does most of this at the moment, I've added a check that a restore happens.
• A DBG_VALUE that happens in the range where a Value is spilt should be dealt with in the same way. dbg-value-when-spilt.ll covers this.
• For not closing spill locations when we def the stack pointer, dbg-value-of-spill-with-fp.ll

There are a bunch of uninteresting test changes; the "standard" updates to inputs and changes in outputs are:

• I've updated MIR inputs to use frame indexes in the IsIndirect field rather than having offsets in DIExpressions and IsIndirect=0
• Checks for after LiveDebugValues now expect IsIndirect to never be set, and every memory location to explicitly have a DW_OP_deref
• Textual assembly output changes same as D68945

The uninteresting standard changes are:
test/DebugInfo/MIR/X86/live-debug-values-3preds.mir:
test/DebugInfo/X86/spill-indirect-nrvo.ll:
test/DebugInfo/X86/spill-nontrivial-param.ll:
test/DebugInfo/X86/spill-nospill.ll:
test/DebugInfo/PowerPC/live-debug-vars-subreg-offset.ll:
test/DebugInfo/X86/fission-ranges.ll:
test/DebugInfo/AArch64/compiler-gen-bbs-livedebugvalues.mir:
test/DebugInfo/MIR/X86/kill-after-spill.mir:
test/DebugInfo/MIR/X86/live-debug-values-restore-collide.mir
test/DebugInfo/X86/pieces-4.ll:
test/DebugInfo/MIR/X86/live-debug-values-spill.mir: <--- I also set a bunch of _'s to explicitly be $noreg
test/DebugInfo/MIR/X86/prolog-epilog-indirection.mir: <-- this test is mostly checking stack slot pointers, not spilt values
test/DebugInfo/MIR/X86/live-debug-values-restore.mir: <--- and now gets the deref in the right location
test/DebugInfo/MIR/X86/live-debug-values-stack-clobber.mir: <--- I added some more expression testing
test/DebugInfo/X86/prolog-params.mir: <--- contains some negative FrameIndexes that get printed positive

More interesting but sound updates:
test/CodeGen/X86/prologepilog_deref_size.mir:
prologepilog no longer produces completely lowered DBG_VALUEs. Instead, I've just let the test run until after LiveDebugValues, and left the checks the same.

test/DebugInfo/COFF/pieces.ll:
We now recognise a restore to eax prior to the end of the function. Which could be considered better.

test/DebugInfo/X86/dbg-declare-arg.ll:
This dbg.declare gets lowered to a single DBG_VALUE in a stack slot, which is then restored.

test/DebugInfo/X86/pr34545.ll:
This wants to check for spill expression, I've let it run til after LiveDebugValues not LiveDebugVars

test/DebugInfo/X86/parameters.ll:
We pick up a restore here that we didn't before, on account of not recognising when a DBG_VALUE was a spill.

The sketchier test updates:
test/DebugInfo/X86/sret.ll:
We recognise a restore now, but the hash of the split-dwarf file changes. I think this is expected, but know nothing of split-dwarf.

test/DebugInfo/X86/op_deref.ll:
I've left this XFail, because I anticipate people will have opinions on how we should go about deciding when to restore from spill and when to not.

test/CodeGen/MIR/X86/diexpr-win32.mir:
I've updated the DBG_VALUEs here to use stack slots, but one of the output offsets (-4) doesn't correspond to any actual stack slot. I've updated checks for the current output, but it's not really a sound update. Problems with this test:

• It dbg.declares an arbitrary thing in memory
• it doesn't dbg.declare a pointer
• We would now never generate this IR or MIR, I think.

My preference would be to delete the sketchy function in this test; or at the least replace the DBG_VALUE with one that isn't impersonating a stack spill.

[aprantl]

lib/CodeGen/LiveDebugValues.cpp

223 ↗

(On Diff #225644)

This warrants some comment as to what those two hashes are used for.

[vsk]

The high level approach makes sense to me. Restricting the meaning of DBG_VALUE's "IsIndirect" operand should reduce the complexity surrounding creating/updating debug instructions. And the ability to recognize loads-from-spills and propagate more DBG_VALUEs is a big plus.

+ @inglorion for any comment on test/CodeGen/MIR/X86/diexpr-win32.mir.

lib/CodeGen/LiveDebugValues.cpp

223 ↗

(On Diff #225644)

I can't really tell right away what it's for, but suspect it's used in place of memcmp to do equality checking. If so, it may be simpler to just use memcmp.

330 ↗

(On Diff #225644)

It looks like the diff needs to be clang-formatted.

test/DebugInfo/X86/dbg-value-of-spill-with-fp.ll

17 ↗

(On Diff #225644)

I'm assuming these two stack slots for %somearg are from before/after the first asm sideeffect. I suppose this is the repeated location spec you referred to? If so, wdyt of tightening this to:

DW_OP_breg4 ESP+[[SLOT:[0-9]]]
DW_OP_breg4 ESP+[[SLOT]]

test/DebugInfo/X86/op_deref.ll

61 ↗

(On Diff #225644)

Mind moving the XFAIL to the first line of the test, with a pointer to the more detailed comment within for.body, and one to the check line that fails?

Alternatively, if at least one location for vla survives, why not disable the failing check line(s) instead of xfailing the whole test? You might consider filing a PR about possible improvements related to this test.

[jmorse]

Address review comments -- the "hash" fields were for comparing the contents of the Loc union, as it's now too big to be a value type. I've used memset and memcmp in its place now, which should be a bit clearer.

There's an additional change to the test CodeGen/ARM/dbg-range-extension.mir, but it's not interesting (constant-valued DBG_VALUE had isIndirect set). Not sure why this didn't fail before, I probably just forgot to add it to this patch.

[aprantl]

llvm/lib/CodeGen/LiveDebugValues.cpp

239–240

It looks like this is exploding the size of the union. Could SpillLocation be made to fit into 64 bits, or does the extra 8 bytes not matter, or should it be an index into a side-table in the union?

[aprantl]

llvm/lib/CodeGen/LiveDebugValues.cpp

239–240

At some point we'll cross over the point were this should be inheritance instead of a union.

[djtodoro]

llvm/lib/CodeGen/LiveDebugValues.cpp

239–240

+1

I think we should think about refactoring the VarLoc, by creating several structures representing various locations. That should improve readability.

1542

we do not need the PrependFlags, so:

DIExpression::prepend(DIExpr, DIExpression::ApplyOffset, Offset);

[jmorse]

llvm/lib/CodeGen/LiveDebugValues.cpp

239–240

I think 32 bits is needed for both the offset and slot size, as it's feasible (if unlikely) that objects more than 2^16 could appear on the stack. However, there's probably no point storing the frame register in the spill location as it doesn't vary. The latest revision removes storing the base register, and assumes we use the frame register everywhere. This lets us move back to just having a single 8-byte union.

1542

Done, cheers!

[aprantl]

llvm/lib/CodeGen/LiveDebugValues.cpp

239–240

Cool!
Can we put a static_assert that sizeof(Loc) == 8?

[jmorse]

llvm/lib/CodeGen/LiveDebugValues.cpp

239–240

Happily already present in the original code, lines 248/249

[aprantl]

llvm/lib/CodeGen/LiveDebugValues.cpp

1534

Nit: assuming that prependOpcodes takes an ArrayRef, a uint64 Ops[] = {dwarf::DW_OP_deref_size, Size}; seems sufficient here?

[jmorse]

(Clearing queue of old revisions) -- things have moved on a lot since this was written, I think we're close to just killing off the IsIndirect field completely and putting everything into DIExpressions.

llvm/lib/CodeGen/LiveDebugValues.cpp

 }
 
 namespace {
 
 using DefinedRegsSet = SmallSet<Register, 32>;
 
 class LiveDebugValues : public MachineFunctionPass {
 private:
+  MachineFunction *CurrentMF;
   const TargetRegisterInfo *TRI;
   const TargetInstrInfo *TII;
   const TargetFrameLowering *TFI;
   BitVector CalleeSavedRegs;
   LexicalScopes LS;
 
   enum struct TransferKind { TransferCopy, TransferSpill, TransferRestore };
 
bool operator<(const DebugVariable &Other) const {
              std::tie(Other.Variable, Other.Fragment, Other.InlinedAt);
     }
   };
 
   friend struct llvm::DenseMapInfo<DebugVariable>;
 
   /// A pair of debug variable and value location.
   struct VarLoc {
-    // The location at which a spilled variable resides. It consists of a
-    // register and an offset.
+    // The location at which a spilled variable resides. It consists of an
+    // offset and a size, and is implicitly against the frame register.
     struct SpillLoc {
-      unsigned SpillBase;
       int SpillOffset;
+      unsigned int SpillSize;
       bool operator==(const SpillLoc &Other) const {
-        return SpillBase == Other.SpillBase && SpillOffset == Other.SpillOffset;
+        return SpillOffset == Other.SpillOffset && SpillSize == Other.SpillSize;
       }
     };
 
     /// Identity of the variable at this location.
     const DebugVariable Var;
 
     /// The expression applied to this location.
     const DIExpression *Expr;
enum VarLocKind {
       EntryValueBackupKind,
       EntryValueCopyBackupKind
     } Kind = InvalidKind;
 
     /// The value location. Stored separately to avoid repeatedly
     /// extracting it from MI.
     union {
       uint64_t RegNo;
       SpillLoc SpillLocation;
       uint64_t Hash;
       int64_t Immediate;
       const ConstantFP *FPImm;
       const ConstantInt *CImm;
     } Loc;
 
     VarLoc(const MachineInstr &MI, LexicalScopes &LS)
         : Var(MI), Expr(MI.getDebugExpression()), MI(MI),
           UVS(MI.getDebugLoc(), LS) {
static VarLoc CreateCopyLoc(const MachineInstr &MI, LexicalScopes &LS,
       VarLoc VL(MI, LS);
       assert(VL.Kind == RegisterKind);
       VL.Loc.RegNo = NewReg;
       return VL;
     }
 
     /// Take the variable described by DBG_VALUE MI, and create a VarLoc
     /// locating it in the specified spill location.
-    static VarLoc CreateSpillLoc(const MachineInstr &MI, unsigned SpillBase,
-                                 int SpillOffset, LexicalScopes &LS) {
+    static VarLoc CreateSpillLoc(const MachineInstr &MI, SpillLoc Loc,
+                                 LexicalScopes &LS) {
       VarLoc VL(MI, LS);
       assert(VL.Kind == RegisterKind);
       VL.Kind = SpillLocKind;
-      VL.Loc.SpillLocation = {SpillBase, SpillOffset};
+      VL.Loc.SpillLocation = Loc;
+      return VL;
+    }
+
+    /// Restore a location from a spill. The DBG_VALUE that this location is
+    /// rooted on could either be a register location that's been spilt in a
+    /// transfer; or it could be a DBG_VALUE of a stack location, created by
+    /// the register allocator. Determine which, and create a register
+    /// location representing the restore.
+    static VarLoc CreateRestoreLoc(const MachineInstr &MI, LexicalScopes &LS,
+                                   unsigned NewReg) {
+      VarLoc VL(MI, LS);
+      assert((VL.Kind == RegisterKind || VL.Kind == SpillLocKind) &&
+             "Unexpected type of DBG_VALUE restored");
+
+      // If this was a spilt register-loc, we can use the expression from the
+      // original DBG_VALUE. Likewise, for spill locations, as the spill
+      // offset will not have been baked into the DIExpression yet, the
+      // expression can be re-used. We need only point the location to the
+      // new register.
+      VL.Kind = RegisterKind;
+      VL.Loc.RegNo = NewReg;
       return VL;
     }
 
     /// Create a DBG_VALUE representing this VarLoc in the given function.
     /// Copies variable-specific information such as DILocalVariable and
     /// inlining information from the original DBG_VALUE instruction, which may
     /// have been several transfers ago.
     MachineInstr *BuildDbgValue(MachineFunction &MF) const {
       const DebugLoc &DbgLoc = MI.getDebugLoc();
-      bool Indirect = MI.isIndirectDebugValue();
       const auto &IID = MI.getDesc();
       const DILocalVariable *Var = MI.getDebugVariable();
       const DIExpression *DIExpr = MI.getDebugExpression();
 
       switch (Kind) {
       case EntryValueKind:
         // An entry value is a register location -- but with an updated
         // expression. The register location of such DBG_VALUE is always the one
         // from the entry DBG_VALUE, it does not matter if the entry value was
         // copied in to another register due to some optimizations.
-        return BuildMI(MF, DbgLoc, IID, Indirect, MI.getOperand(0).getReg(),
-                       Var, Expr);
+        return BuildMI(MF, DbgLoc, IID, false, MI.getOperand(0).getReg(), Var,
+                       Expr);
       case RegisterKind:
         // Register locations are like the source DBG_VALUE, but with the
         // register number from this VarLoc.
-        return BuildMI(MF, DbgLoc, IID, Indirect, Loc.RegNo, Var, DIExpr);
+        return BuildMI(MF, DbgLoc, IID, false, Loc.RegNo, Var, DIExpr);
       case SpillLocKind: {
         // Spills are indirect DBG_VALUEs, with a base register and offset.
         // Use the original DBG_VALUEs expression to build the spilt location
-        // on top of. FIXME: spill locations created before this pass runs
-        // are not recognized, and not handled here.
-        auto *SpillExpr = DIExpression::prepend(
-            DIExpr, DIExpression::ApplyOffset, Loc.SpillLocation.SpillOffset);
-        unsigned Base = Loc.SpillLocation.SpillBase;
-        return BuildMI(MF, DbgLoc, IID, true, Base, Var, SpillExpr);
+        // on top of.
+
+        auto *TRI = MF.getSubtarget().getRegisterInfo();
+        unsigned FrameReg = TRI->getFrameRegister(MF);
+        if (DIExpr->isImplicit()) {
+          SmallVector<uint64_t, 2> Ops = {dwarf::DW_OP_deref_size,
+                                          Loc.SpillLocation.SpillSize};
+          DIExpr = DIExpression::prependOpcodes(DIExpr, Ops);
+          DIExpr = DIExpression::prepend(DIExpr, DIExpression::ApplyOffset,
+                                         Loc.SpillLocation.SpillOffset);
+        } else {
+          DIExpr = DIExpression::prepend(DIExpr, DIExpression::DerefAfter,
+                                         Loc.SpillLocation.SpillOffset);
+        }
+        return BuildMI(MF, DbgLoc, IID, false, FrameReg, Var, DIExpr);
       }
       case ImmediateKind: {
         MachineOperand MO = MI.getOperand(0);
-        return BuildMI(MF, DbgLoc, IID, Indirect, MO, Var, DIExpr);
+        return BuildMI(MF, DbgLoc, IID, false, MO, Var, DIExpr);
       }
       case EntryValueBackupKind:
       case EntryValueCopyBackupKind:
       case InvalidKind:
         llvm_unreachable(
             "Tried to produce DBG_VALUE for invalid or backup VarLoc");
       }
       llvm_unreachable("Unrecognized LiveDebugValues.VarLoc.Kind enum");
struct VarLoc {
     }
 
     /// Determine whether the lexical scope of this value's debug location
     /// dominates MBB.
     bool dominates(MachineBasicBlock &MBB) const { return UVS.dominates(&MBB); }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
     // TRI can be null.
-    void dump(const TargetRegisterInfo *TRI, raw_ostream &Out = dbgs()) const {
+    void dump(const MachineFunction *MF, raw_ostream &Out = dbgs()) const {
+      const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo();
       dbgs() << "VarLoc(";
       switch (Kind) {
       case RegisterKind:
       case EntryValueKind:
       case EntryValueBackupKind:
       case EntryValueCopyBackupKind:
         dbgs() << printReg(Loc.RegNo, TRI);
         break;
       case SpillLocKind:
-        dbgs() << printReg(Loc.SpillLocation.SpillBase, TRI);
+        dbgs() << printReg(TRI->getFrameRegister(*MF), TRI);
         dbgs() << "[" << Loc.SpillLocation.SpillOffset << "]";
         break;
       case ImmediateKind:
         dbgs() << Loc.Immediate;
         break;
       case InvalidKind:
         llvm_unreachable("Invalid VarLoc in dump method");
       }
#endif
 
   /// If a given instruction is identified as a spill, return the spill location
   /// and set \p Reg to the spilled register.
   Optional<VarLoc::SpillLoc> isRestoreInstruction(const MachineInstr &MI,
                                                   MachineFunction *MF,
                                                   unsigned &Reg);
   /// Given a spill instruction, extract the register and offset used to
   /// address the spill location in a target independent way.
-  VarLoc::SpillLoc extractSpillBaseRegAndOffset(const MachineInstr &MI);
+  VarLoc::SpillLoc extractSpillLocation(const MachineInstr &MI);
   void insertTransferDebugPair(MachineInstr &MI, OpenRangesSet &OpenRanges,
                                TransferMap &Transfers, VarLocMap &VarLocIDs,
                                unsigned OldVarID, TransferKind Kind,
                                unsigned NewReg = 0);
 
   void transferDebugValue(const MachineInstr &MI, OpenRangesSet &OpenRanges,
                           VarLocMap &VarLocIDs);
   void transferSpillOrRestoreInst(MachineInstr &MI, OpenRangesSet &OpenRanges,
void accumulateFragmentMap(MachineInstr &MI, VarToFragments &SeenFragments,
                              OverlapMap &OLapMap);
 
   bool join(MachineBasicBlock &MBB, VarLocInMBB &OutLocs, VarLocInMBB &InLocs,
             const VarLocMap &VarLocIDs,
             SmallPtrSet<const MachineBasicBlock *, 16> &Visited,
             SmallPtrSetImpl<const MachineBasicBlock *> &ArtificialBlocks,
             VarLocInMBB &PendingInLocs);
 
+  /// Reduce any DBG_VALUE with a stack-slot index in its 1st operand into
+  /// an operation on the frame pointer.
+  void rewriteStackLocs(MachineFunction &MF);
+
   /// Create DBG_VALUE insts for inlocs that have been propagated but
   /// had their instruction creation deferred.
   void flushPendingLocs(VarLocInMBB &PendingInLocs, VarLocMap &VarLocIDs);
 
   bool ExtendRanges(MachineFunction &MF);
 
 public:
   static char ID;
for (const MachineBasicBlock &BB : MF) {
     const VarLocSet &L = V.lookup(&BB);
     if (L.empty())
       continue;
     Out << "MBB: " << BB.getNumber() << ":\n";
     for (unsigned VLL : L) {
       const VarLoc &VL = VarLocIDs[VLL];
       Out << " Var: " << VL.Var.getVar()->getName();
       Out << " MI: ";
-      VL.dump(TRI, Out);
+      VL.dump(&MF, Out);
     }
   }
   Out << "\n";
 }
 #endif
 
 LiveDebugValues::VarLoc::SpillLoc
-LiveDebugValues::extractSpillBaseRegAndOffset(const MachineInstr &MI) {
+LiveDebugValues::extractSpillLocation(const MachineInstr &MI) {
   assert(MI.hasOneMemOperand() &&
          "Spill instruction does not have exactly one memory operand?");
   auto MMOI = MI.memoperands_begin();
   const PseudoSourceValue *PVal = (*MMOI)->getPseudoValue();
   assert(PVal->kind() == PseudoSourceValue::FixedStack &&
          "Inconsistent memory operand in spill instruction");
   int FI = cast<FixedStackPseudoSourceValue>(PVal)->getFrameIndex();
   const MachineBasicBlock *MBB = MI.getParent();
   unsigned Reg;
   int Offset = TFI->getFrameIndexReference(*MBB->getParent(), FI, Reg);
-  return {Reg, Offset};
+  (void)Reg;
+  return {Offset, (unsigned)(*MMOI)->getSize()};
 }
 
 /// Try to salvage the debug entry value if we encounter a new debug value
 /// describing the same parameter, otherwise stop tracking the value. Return
 /// true if we should stop tracking the entry value, otherwise return false.
 bool LiveDebugValues::removeEntryValue(const MachineInstr &MI,
                                        OpenRangesSet &OpenRanges,
                                        VarLocMap &VarLocIDs,
if (removeEntryValue(MI, OpenRanges, VarLocIDs, EntryVL)) {
                  MI.print(dbgs(), /*IsStandalone*/ false,
                           /*SkipOpers*/ false, /*SkipDebugLoc*/ false,
                           /*AddNewLine*/ true, TII));
       OpenRanges.erase(EntryVL);
     }
   }
 
   unsigned ID;
-  if (isDbgValueDescribedByReg(MI) || MI.getOperand(0).isImm() ||
+
+  unsigned FrameReg = TRI->getFrameRegister(*MI.getMF());
+  if (MI.isIndirectDebugValue() && MI.getOperand(0).isReg() &&
+      MI.getOperand(0).getReg() == FrameReg) {
+    // This is a spill. Its offset should be in the "indirect" operand.
+    unsigned Reg;
+    int64_t FrameIdx = MI.getOperand(1).getImm();
+    auto &MF = *MI.getMF();
+    int64_t Offset = TFI->getFrameIndexReference(MF, FrameIdx, Reg);
+    unsigned Size = MF.getFrameInfo().getObjectSize(FrameIdx);
+    VarLoc VL = VarLoc::CreateSpillLoc(MI, {(int)Offset, Size}, LS);
+    ID = VarLocIDs.insert(VL);
+    OpenRanges.insert(ID, VL);
+  } else if (isDbgValueDescribedByReg(MI) || MI.getOperand(0).isImm() ||
              MI.getOperand(0).isFPImm() || MI.getOperand(0).isCImm()) {
     // Use normal VarLoc constructor for registers and immediates.
     VarLoc VL(MI, LS);
     // End all previous ranges of VL.Var.
     OpenRanges.erase(VL);
 
     ID = VarLocIDs.insert(VL);
     // Add the VarLoc to OpenRanges from this DBG_VALUE.
     OpenRanges.insert(ID, VL);
case TransferKind::TransferCopy: {
     assert(NewReg &&
            "No register supplied when handling a copy of a debug value");
     // Create a DBG_VALUE instruction to describe the Var in its new
     // register location.
     VarLoc VL = VarLoc::CreateCopyLoc(*DebugInstr, LS, NewReg);
     ProcessVarLoc(VL);
     LLVM_DEBUG({
       dbgs() << "Creating VarLoc for register copy:";
-      VL.dump(TRI);
+      VL.dump(CurrentMF);
     });
     return;
   }
   case TransferKind::TransferSpill: {
     // Create a DBG_VALUE instruction to describe the Var in its spilled
     // location.
-    VarLoc::SpillLoc SpillLocation = extractSpillBaseRegAndOffset(MI);
-    VarLoc VL = VarLoc::CreateSpillLoc(*DebugInstr, SpillLocation.SpillBase,
-                                       SpillLocation.SpillOffset, LS);
+    VarLoc::SpillLoc SpillLocation = extractSpillLocation(MI);
+    VarLoc VL = VarLoc::CreateSpillLoc(*DebugInstr, SpillLocation, LS);
     ProcessVarLoc(VL);
     LLVM_DEBUG({
       dbgs() << "Creating VarLoc for spill:";
-      VL.dump(TRI);
+      VL.dump(CurrentMF);
     });
     return;
   }
   case TransferKind::TransferRestore: {
     assert(NewReg &&
            "No register supplied when handling a restore of a debug value");
     // DebugInstr refers to the pre-spill location, therefore we can reuse
     // its expression.
-    VarLoc VL = VarLoc::CreateCopyLoc(*DebugInstr, LS, NewReg);
+    VarLoc VL = VarLoc::CreateRestoreLoc(*DebugInstr, LS, NewReg);
     ProcessVarLoc(VL);
     LLVM_DEBUG({
       dbgs() << "Creating VarLoc for restore:";
-      VL.dump(TRI);
+      VL.dump(CurrentMF);
     });
     return;
   }
   }
   llvm_unreachable("Invalid transfer kind");
 }
 
 /// A definition of a register may mark the end of a range.
LiveDebugValues::isRestoreInstruction(const MachineInstr &MI,
                                       MachineFunction *MF, unsigned &Reg) {
   if (!MI.hasOneMemOperand())
     return None;
 
   // FIXME: Handle folded restore instructions with more than one memory
   // operand.
   if (MI.getRestoreSize(TII)) {
     Reg = MI.getOperand(0).getReg();
-    return extractSpillBaseRegAndOffset(MI);
+    return extractSpillLocation(MI);
   }
   return None;
 }
 
 /// A spilled register may indicate that we have to end the current range of
 /// a variable and create a new one for the spill location.
 /// A restored register may indicate the reverse situation.
 /// We don't want to insert any instructions in process(), so we just create
void LiveDebugValues::transferSpillOrRestoreInst(MachineInstr &MI,
 
   LLVM_DEBUG(dbgs() << "Examining instruction: "; MI.dump(););
 
   // First, if there are any DBG_VALUEs pointing at a spill slot that is
   // written to, then close the variable location. The value in memory
   // will have changed.
   VarLocSet KillSet;
   if (isSpillInstruction(MI, MF)) {
-    Loc = extractSpillBaseRegAndOffset(MI);
+    Loc = extractSpillLocation(MI);
     for (unsigned ID : OpenRanges.getVarLocs()) {
       const VarLoc &VL = VarLocIDs[ID];
       if (VL.Kind == VarLoc::SpillLocKind && VL.Loc.SpillLocation == *Loc) {
         // This location is overwritten by the current instruction -- terminate
         // the open range, and insert an explicit DBG_VALUE $noreg.
         //
         // Doing this at a later stage would require re-interpreting all
         // DBG_VALUes and DIExpressions to identify whether they point at
bool LiveDebugValues::transferTerminator(MachineBasicBlock *CurMBB,
                                          VarLocInMBB &OutLocs,
                                          const VarLocMap &VarLocIDs) {
   bool Changed = false;
 
   LLVM_DEBUG(for (unsigned ID
                   : OpenRanges.getVarLocs()) {
     // Copy OpenRanges to OutLocs, if not already present.
     dbgs() << "Add to OutLocs in MBB #" << CurMBB->getNumber() << ":  ";
-    VarLocIDs[ID].dump(TRI);
+    VarLocIDs[ID].dump(CurrentMF);
   });
   VarLocSet &VLS = OutLocs[CurMBB];
   Changed = VLS != OpenRanges.getVarLocs();
   // New OutLocs set may be different due to spill, restore or register
   // copy instruction processing.
   if (Changed)
     VLS = OpenRanges.getVarLocs();
   OpenRanges.clear();
for (auto ID : Removed) {
     ILS.reset(ID);
     ++NumRemoved;
     Changed = true;
   }
 
   return Changed;
 }
 
+void LiveDebugValues::rewriteStackLocs(MachineFunction &MF) {
+  for (auto &MBB : MF) {
+    for (auto &MI : MBB) {
+      if (!MI.isDebugValue())
+        continue;
+
+      // Examine only DBG_VALUEs with frame-indexes in the second operand.
+      if (!MI.getOperand(1).isImm())
+        continue;
+
+      // Fetch frame index details, un-set indirect field.
+      unsigned Reg;
+      int64_t FrameIdx = MI.getOperand(1).getImm();
+      int64_t Offset = TFI->getFrameIndexReference(*MI.getMF(), FrameIdx, Reg);
+      unsigned Size = MF.getFrameInfo().getObjectSize(FrameIdx);
+      MI.getOperand(1).ChangeToRegister(0, false);
+
+      const DIExpression *DIExpr = MI.getDebugExpression();
+
+      // Prepend the correct kind of deref onto the expression: big endian
+      // machines want to know the size when dealing with implicit locations.
+      if (DIExpr->isImplicit()) {
+        SmallVector<uint64_t, 2> Ops = {dwarf::DW_OP_deref_size, Size};
+        DIExpr = DIExpression::prependOpcodes(DIExpr, Ops);
+      } else {
+        SmallVector<uint64_t, 1> Ops = {dwarf::DW_OP_deref};
+        DIExpr = DIExpression::prependOpcodes(DIExpr, Ops);
+      }
+
+      // Prepend the stack offset and attach the stack-location expression.
+      DIExpr = DIExpression::prepend(DIExpr, DIExpression::ApplyOffset, Offset);
+      MI.getOperand(3).setMetadata(DIExpr);
+    }
+  }
+}
+
 void LiveDebugValues::flushPendingLocs(VarLocInMBB &PendingInLocs,
                                        VarLocMap &VarLocIDs) {
   // PendingInLocs records all locations propagated into blocks, which have
   // not had DBG_VALUE insts created. Go through and create those insts now.
   for (auto &Iter : PendingInLocs) {
     // Map is keyed on a constant pointer, unwrap it so we can insert insts.
     auto &MBB = const_cast<MachineBasicBlock &>(*Iter.first);
     VarLocSet &Pending = Iter.second;
for (auto &TR : Transfers) {
     MBB->insertAfterBundle(TR.TransferInst->getIterator(), MI);
   }
   Transfers.clear();
 
   // Deferred inlocs will not have had any DBG_VALUE insts created; do
   // that now.
   flushPendingLocs(PendingInLocs, VarLocIDs);
 
+  // Input DBG_VALUEs that refer to stack spills must be rewritten in terms
+  // of the frame register and expression calculations. This must happen
+  // last, to avoid VarLocs creating new DBG_VALUEs based on expressions
+  // that have stack spill information in them.
+  rewriteStackLocs(MF);
+
   LLVM_DEBUG(printVarLocInMBB(MF, OutLocs, VarLocIDs, "Final OutLocs", dbgs()));
   LLVM_DEBUG(printVarLocInMBB(MF, InLocs, VarLocIDs, "Final InLocs", dbgs()));
   return Changed;
 }
 
 bool LiveDebugValues::runOnMachineFunction(MachineFunction &MF) {
   if (!MF.getFunction().getSubprogram())
     // LiveDebugValues will already have removed all DBG_VALUEs.
     return false;
 
   // Skip functions from NoDebug compilation units.
   if (MF.getFunction().getSubprogram()->getUnit()->getEmissionKind() ==
       DICompileUnit::NoDebug)
     return false;
 
+  CurrentMF = &MF;
   TRI = MF.getSubtarget().getRegisterInfo();
   TII = MF.getSubtarget().getInstrInfo();
   TFI = MF.getSubtarget().getFrameLowering();
   TFI->getCalleeSaves(MF, CalleeSavedRegs);
   LS.initialize(MF);
 
   bool Changed = ExtendRanges(MF);
   return Changed;
 }

llvm/lib/CodeGen/LiveDebugVariables.cpp

MachineOperand::CreateReg(/* Reg */ 0, /* isDef */ false, /* isImp */ false,
                               /* SubReg */ 0, /* isDebug */ true);
 
   ++NumInsertedDebugValues;
 
   assert(cast<DILocalVariable>(Variable)
              ->isValidLocationForIntrinsic(getDebugLoc()) &&
          "Expected inlined-at fields to agree");
 
-  // If the location was spilled, the new DBG_VALUE will be indirect. If the
-  // original DBG_VALUE was indirect, we need to add DW_OP_deref to indicate
-  // that the original virtual register was a pointer. Also, add the stack slot
-  // offset for the spilled register to the expression.
-  const DIExpression *Expr = Expression;
-  if (Spilled)
-    Expr = DIExpression::prepend(Expr, DIExpression::ApplyOffset, SpillOffset);
-
   assert((!Spilled || MO.isFI()) && "a spilled location must be a frame index");
 
   do {
-    BuildMI(*MBB, I, getDebugLoc(), TII.get(TargetOpcode::DBG_VALUE),
-            Spilled, MO, Variable, Expr);
+    BuildMI(*MBB, I, getDebugLoc(), TII.get(TargetOpcode::DBG_VALUE), Spilled,
+            MO, Variable, Expression);
 
     // Continue and insert DBG_VALUES after every redefinition of register
     // associated with the debug value within the range
     I = findNextInsertLocation(MBB, I, StopIdx, MO, LIS, TRI);
   } while (I != MBB->end());
 }
 
 void UserLabel::insertDebugLabel(MachineBasicBlock *MBB, SlotIndex Idx,

llvm/lib/CodeGen/PrologEpilogInserter.cpp

for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
       // Frame indices in debug values are encoded in a target independent
       // way with simply the frame index and offset rather than any
       // target-specific addressing mode.
       if (MI.isDebugValue()) {
         assert(i == 0 && "Frame indices can only appear as the first "
                          "operand of a DBG_VALUE machine instruction");
         unsigned Reg;
         unsigned FrameIdx = MI.getOperand(0).getIndex();
-        unsigned Size = MF.getFrameInfo().getObjectSize(FrameIdx);
 
         int64_t Offset =
             TFI->getFrameIndexReference(MF, FrameIdx, Reg);
         MI.getOperand(0).ChangeToRegister(Reg, false /*isDef*/);
         MI.getOperand(0).setIsDebug();
 
         const DIExpression *DIExpr = MI.getDebugExpression();
 
+        // If this is an indirect debug value, store the frame offset in
+        // the "indirect" field, and let LiveDebugValues lower it to a
+        // DIExpression later. This makes it easier for LiveDebugValues to
+        // recognise and deal with spills/restores.
+        if (MI.isIndirectDebugValue()) {
+          MI.getOperand(1).setImm(FrameIdx);
+          continue;
+        }
+
         // If we have a direct DBG_VALUE, and its location expression isn't
         // currently complex, then adding an offset will morph it into a
         // complex location that is interpreted as being a memory address.
         // This changes a pointer-valued variable to dereference that pointer,
         // which is incorrect. Fix by adding DW_OP_stack_value.
         unsigned PrependFlags = DIExpression::ApplyOffset;
-        if (!MI.isIndirectDebugValue() && !DIExpr->isComplex())
+        if (!DIExpr->isComplex())
           PrependFlags |= DIExpression::StackValue;
 
-        // If we have DBG_VALUE that is indirect and has a Implicit location
-        // expression need to insert a deref before prepending a Memory
-        // location expression. Also after doing this we change the DBG_VALUE
-        // to be direct.
-        if (MI.isIndirectDebugValue() && DIExpr->isImplicit()) {
-          SmallVector<uint64_t, 2> Ops = {dwarf::DW_OP_deref_size, Size};
-          bool WithStackValue = true;
-          DIExpr = DIExpression::prependOpcodes(DIExpr, Ops, WithStackValue);
-          // Make the DBG_VALUE direct.
-          MI.getOperand(1).ChangeToRegister(0, false);
-        }
         DIExpr = DIExpression::prepend(DIExpr, PrependFlags, Offset);
         MI.getOperand(3).setMetadata(DIExpr);
         continue;
       }
 
       // TODO: This code should be commoned with the code for
       // PATCHPOINT. There's no good reason for the difference in
       // implementation other than historical accident.  The only

llvm/test/CodeGen/ARM/dbg-range-extension.mir

 # CHECK: DBG_VALUE $r0, $noreg, [[VAR_A]]
 # CHECK: DBG_VALUE [[REG_A:\$r[0-9]+]], $noreg, [[VAR_A]]
 # CHECK: DBG_VALUE [[REG_B:\$r[0-9]+]], $noreg, [[VAR_B]]
 
 # CHECK: bb.1.if.then
 # CHECK: DBG_VALUE [[REG_B]], $noreg, [[VAR_B]]
 # CHECK: DBG_VALUE [[REG_A]], $noreg, [[VAR_A]]
 # CHECK: DBG_VALUE [[REG_C:\$r[0-9]+]], $noreg, [[VAR_C]]
-# CHECK: DBG_VALUE 1, 0, [[VAR_I]]
+# CHECK: DBG_VALUE 1, $noreg, [[VAR_I]]
 
 # CHECK: bb.2.for.body
 # CHECK: DBG_VALUE [[REG_I:\$r[0-9]+]], $noreg, [[VAR_I]]
 # CHECK: DBG_VALUE [[REG_C]], $noreg, [[VAR_C]]
 # CHECK: DBG_VALUE [[REG_B]], $noreg, [[VAR_B]]
 # CHECK: DBG_VALUE [[REG_A]], $noreg, [[VAR_A]]
 # CHECK: DBG_VALUE [[REG_I]], $noreg, [[VAR_I]]
 
bb.1.if.then:
     liveins: $r4, $r5
   
     $r0 = MOVi 12, 14, $noreg, _, debug-location !26
     $r1 = MOVi 13, 14, $noreg, _, debug-location !26
     BL @func2, csr_aapcs, implicit-def dead $lr, implicit $sp, implicit killed $r0, implicit killed $r1, implicit-def $sp, implicit-def $r0, debug-location !26
     $r6 = MOVr killed $r0, 14, $noreg, _, debug-location !26
     DBG_VALUE $r6, $noreg, !15, !20, debug-location !27
     $r7 = MOVi 1, 14, $noreg, $noreg
-    DBG_VALUE 1, 0, !18, !20, debug-location !28
+    DBG_VALUE 1, $noreg, !18, !20, debug-location !28
     B %bb.3.for.cond
   
   bb.2.for.body:
     liveins: $r4, $r5, $r6, $r7
   
     $r1 = ADDrr $r5, $r7, 14, $noreg, _, debug-location !36
     $r0 = MOVr $r7, 14, $noreg, _, debug-location !36
     BL @func2, csr_aapcs, implicit-def dead $lr, implicit $sp, implicit killed $r0, implicit killed $r1, implicit-def $sp, implicit-def dead $r0, debug-location !36

llvm/test/CodeGen/MIR/X86/diexpr-win32.mir

 # CHECK-NEXT:   ]
 # CHECK-NEXT:   VarName: Bytes
 # CHECK-NEXT: }
 # CHECK-NEXT: DefRangeRegisterRelSym {
 # CHECK-NEXT:   Kind: S_DEFRANGE_REGISTER_REL (0x1145)
 # CHECK-NEXT:   BaseRegister:
 # CHECK-NEXT:   HasSpilledUDTMember: No
 # CHECK-NEXT:   OffsetInParent: 0
-# CHECK-NEXT:   BasePointerOffset: -4
+# CHECK-NEXT:   BasePointerOffset: 4
 # CHECK-NEXT:   LocalVariableAddrRange {
 # CHECK-NEXT:     OffsetStart:
 # CHECK-NEXT:     ISectStart:
 # CHECK-NEXT:     Range:
 # CHECK-NEXT:   }
 # CHECK-NEXT: }
 --- |
   ; ModuleID = '<stdin>'

 body:             |
   bb.0.entry:
     liveins: $esi
 
     frame-setup PUSH32r killed $esi, implicit-def $esp, implicit $esp
     CFI_INSTRUCTION def_cfa_offset 8
     CFI_INSTRUCTION offset $esi, -8
     $esi = MOV32rm $esp, 1, _, 8, _ :: (load 4 from %fixed-stack.2)
-    DBG_VALUE $esp, 0, !26, !10, debug-location !25
-    DBG_VALUE $esp, 0, !23, !DIExpression(DW_OP_plus_uconst, 8, DW_OP_deref), debug-location !25
+    DBG_VALUE $esp, -2, !26, !10, debug-location !25
+    DBG_VALUE $esp, -3, !23, !DIExpression(DW_OP_deref), debug-location !25
     CALLpcrel32 @getString, csr_32, implicit $esp, implicit-def $esp, implicit-def $eax, debug-location !29
     $ecx = MOV32rm $eax, 1, _, 0, _, debug-location !29 :: (dereferenceable load 4 from %ir.1)
     $edx = MOV32rm $eax, 1, _, 4, _, debug-location !29 :: (dereferenceable load 4 from %ir.1 + 4)
     MOV32mr $esi, 1, _, 0, _, killed $ecx, debug-location !29 :: (store 4 into %ir.0)
     MOV32mr $esi, 1, _, 4, _, killed $edx, debug-location !29 :: (store 4 into %ir.0 + 4)
     $eax = MOV32rm killed $eax, 1, _, 8, _, debug-location !29 :: (dereferenceable load 4 from %ir.1 + 8)
     MOV32mr $esi, 1, _, 8, _, killed $eax, debug-location !29 :: (store 4 into %ir.0 + 8)
     $eax = COPY killed $esi, debug-location !30
fixedStack:
   - { id: 1, type: default, offset: 0, size: 4, alignment: 4, stack-id: default,
       isImmutable: true, isAliased: false, callee-saved-register: '' }
 stack:
 constants:
 body:             |
   bb.0.entry:
     $eax = MOV32rm $esp, 1, _, 4, _ :: (load 4 from %fixed-stack.1)
     $eax = MOV32rm killed $eax, 1, _, 0, _, debug-location !34 :: (load 4 from %ir.0)
-    DBG_VALUE $eax, 0, !35, !DIExpression(DW_OP_constu, 4, DW_OP_minus), debug-location !34
+    DBG_VALUE $eax, -2, !35, !DIExpression(), debug-location !34
     $eax = ADD32rm killed $eax, $esp, 1, _, 8, _, implicit-def dead $eflags, debug-location !36 :: (load 4 from %fixed-stack.0)
     RET 0, $eax, debug-location !36
 
 ...

llvm/test/CodeGen/X86/prologepilog_deref_size.mir

-# RUN: llc -run-pass=prologepilog -o - %s | FileCheck %s
+# RUN: llc -start-before=prologepilog -stop-after=livedebugvalues -o - %s | FileCheck %s
 --- |
   ; ModuleID = 'dbg.opt.ll'
   source_filename = "dbg.c"
   target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
 
   ; Function Attrs: noinline nounwind uwtable
   define dso_local zeroext i16 @foo(i16 zeroext %d0, i16 zeroext %d1, i16 zeroext %d2, i16 zeroext %d3, i16 zeroext %d4, i16 zeroext %d5, i16 zeroext %d6, i16 zeroext %d7, i16 zeroext %d8, i16 signext %x) #0 !dbg !7 {

llvm/test/DebugInfo/AArch64/compiler-gen-bbs-livedebugvalues.mir

bb.0.entry:
     $sp = frame-setup SUBXri $sp, 32, 0
     frame-setup STPXi killed $fp, killed $lr, $sp, 2 :: (store 8 into %stack.2), (store 8 into %stack.1)
     frame-setup CFI_INSTRUCTION def_cfa_offset 32
     frame-setup CFI_INSTRUCTION offset $w30, -8, debug-location !12
     frame-setup CFI_INSTRUCTION offset $w29, -16, debug-location !12
     renamable $w0 = ADDWri killed renamable $w0, 1, 0, debug-location !12
     DBG_VALUE renamable $w0, $noreg, !9, !DIExpression(), debug-location !12
     STRWui killed $w0, $sp, 3 :: (store 4 into %stack.0)
-    DBG_VALUE $sp, 0, !9, !DIExpression(DW_OP_plus_uconst, 12), debug-location !12
+    DBG_VALUE $sp, 0, !9, !DIExpression(), debug-location !12
 
     ; CHECK: DBG_VALUE renamable $w0, $noreg, !9, !DIExpression(), debug-location !12
     ; CHECK-NEXT: STRWui killed $w0, $sp, 3 :: (store 4 into %stack.0)
-    ; CHECK-NEXT: DBG_VALUE $sp, 0, !9, !DIExpression(DW_OP_plus_uconst, 12)
-    ; CHECK-NEXT: DBG_VALUE $sp, 0, !9, !DIExpression(DW_OP_plus_uconst, 12)
+    ; CHECK-NEXT: DBG_VALUE $sp, $noreg, !9, !DIExpression(DW_OP_plus_uconst, 12, DW_OP_deref)
+    ; CHECK-NEXT: DBG_VALUE $sp, $noreg, !9, !DIExpression(DW_OP_plus_uconst, 12, DW_OP_deref)
   
   bb.1.artificial-bb-1:
     ; CHECK-LABEL: bb.1.artificial-bb-1:
-    ; CHECK: DBG_VALUE $sp, 0, !9, !DIExpression(DW_OP_plus_uconst, 12)
+    ; CHECK: DBG_VALUE $sp, $noreg, !9, !DIExpression(DW_OP_plus_uconst, 12, DW_OP_deref)
       
   bb.2.artificial-bb-2:
     ; CHECK-LABEL: bb.2.artificial-bb-2:
-    ; CHECK: DBG_VALUE $sp, 0, !9, !DIExpression(DW_OP_plus_uconst, 12)
+    ; CHECK: DBG_VALUE $sp, $noreg, !9, !DIExpression(DW_OP_plus_uconst, 12, DW_OP_deref)
   
   bb.3.return:
     ; CHECK-LABEL: bb.3.return:
-    ; CHECK: DBG_VALUE $sp, 0, !9, !DIExpression(DW_OP_plus_uconst, 12)
+    ; CHECK: DBG_VALUE $sp, $noreg, !9, !DIExpression(DW_OP_plus_uconst, 12, DW_OP_deref)
 
     $w0 = LDRWui $sp, 3 :: (load 4 from %stack.0)
     BL @use, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit killed $w0
     $fp, $lr = frame-destroy LDPXi $sp, 2, debug-location !15 :: (load 8 from %stack.2), (load 8 from %stack.1)
     $sp = frame-destroy ADDXri $sp, 32, 0, debug-location !15
     RET undef $lr, debug-location !15
 ...

llvm/test/DebugInfo/COFF/pieces.ll

 ; ASM:         retq
 
 ; ASM-LABEL: bitpiece_spill: # @bitpiece_spill
 ; ASM:         #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_LLVM_fragment 0 32] 0
 ; ASM:         xorl    %ecx, %ecx
 ; ASM:         callq   g
 ; ASM:         movl    %eax, [[offset_o_x:[0-9]+]](%rsp)          # 4-byte Spill
 ; ASM: [[spill_o_x_start:\.Ltmp[0-9]+]]:
-; ASM:         #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_plus_uconst [[offset_o_x]], DW_OP_LLVM_fragment 32 32] [$rsp+0]
+; ASM:         #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_plus_uconst [[offset_o_x]], DW_OP_deref, DW_OP_LLVM_fragment 32 32] $rsp
 ; ASM:         #APP
 ; ASM:         #NO_APP
 ; ASM:         movl    [[offset_o_x]](%rsp), %eax          # 4-byte Reload
-; ASM:         retq
 ; ASM-NEXT: [[spill_o_x_end:\.Ltmp[0-9]+]]:
+; ASM-NEXT:    #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_LLVM_fragment 32 32] $eax
+; ASM:         retq
+; ASM-NEXT: .Ltmp
 ; ASM-NEXT: .Lfunc_end4:
 
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "loop_csr"              # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
 ; ASM:        .cv_def_range    [[oy_ox_start]] [[ox_start]], subfield_reg, 24, 0

 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "bitpiece_spill"        # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    [[spill_o_x_start]] .Lfunc_end4, reg_rel, 335, 65, 36
+; ASM:        .cv_def_range    [[spill_o_x_start]] [[spill_o_x_end]], reg_rel, 335, 65, 36
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: bitpiece_spill
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o
 ; OBJ:       }

llvm/test/DebugInfo/MIR/X86/kill-after-spill.mir

 # RUN: llc -run-pass=livedebugvalues -o - %s | FileCheck %s
 #
 # This test is used to acknowledge situation when spill register is killed
 # in instruction after the spill occurs.
 # Generated MIR is changed in order to test case when instruction after
 # possible spill, say instruction B, kills register different than than
 # the one that is used in possible spill, say instruction A. In that case
 # the instruction A is not recognized as spill. Changed instructions are
 # commented in MIR below.
 #
 # ...
 # A - possible spill instruction with register R2
 # B - instruction that kills R3
 # ...
 #
 # CHECK: bb.1.if.end:
-# CHECK: DBG_VALUE $rbp, 0, !37, !DIExpression(DW_OP_constu, 44, DW_OP_minus), debug-location !58
-# CHECK-NOT: DBG_VALUE $rbp, 0, !36, !DIExpression(DW_OP_constu, 48, DW_OP_minus), debug-location !57
+# CHECK: DBG_VALUE $rbp, $noreg, !37, !DIExpression(DW_OP_constu, 44, DW_OP_minus, DW_OP_deref), debug-location !58
+# CHECK-NOT: DBG_VALUE $rbp, $noreg, !36, !DIExpression(DW_OP_constu, 48, DW_OP_minus, DW_OP_deref), debug-location !57
 
 --- |
   ; ModuleID = '<stdin>'
   source_filename = "<stdin>"
   target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
 
   %struct.firstStruct = type { i32, i8, %struct.secondStruct* }

llvm/test/DebugInfo/MIR/X86/live-debug-values-3preds.mir

body:             |
   bb.0.entry:
     successors: %bb.1.for.body.preheader(20), %bb.9.for.end(12)
     liveins: $ecx, $edi, $edx, $esi
   
     DBG_VALUE $edi, _, !9, !17, debug-location !18
     DBG_VALUE $esi, _, !10, !17, debug-location !19
     DBG_VALUE $edx, _, !11, !17, debug-location !21
     DBG_VALUE $ecx, _, !12, !17, debug-location !23
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     $r8d = MOV32rr $esi, debug-location !26
     $r8d = IMUL32rr killed $r8d, $edi, implicit-def dead $eflags, debug-location !26
     TEST32rr $r8d, $r8d, implicit-def $eflags, debug-location !31
     JCC_1 %bb.9.for.end, 14, implicit $eflags
   
   bb.1.for.body.preheader:
     successors: %bb.3.for.body(0)
     liveins: $ecx, $edi, $edx, $esi, $r8d
   
     DBG_VALUE $edi, _, !9, !17, debug-location !18
     DBG_VALUE $esi, _, !10, !17, debug-location !19
     DBG_VALUE $edx, _, !11, !17, debug-location !21
     DBG_VALUE $ecx, _, !12, !17, debug-location !23
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
   
   bb.3.for.body (align 4):
     successors: %bb.4.if.then(4), %bb.5.if.end(124)
     liveins: $eax, $ecx, $edi, $edx, $esi, $r8d
   
     DBG_VALUE $edi, _, !9, !17, debug-location !18
     DBG_VALUE $esi, _, !10, !17, debug-location !19
     DBG_VALUE $edx, _, !11, !17, debug-location !21
     DBG_VALUE $ecx, _, !12, !17, debug-location !23
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     TEST32rr $edi, $edi, implicit-def $eflags, debug-location !35
     JCC_1 %bb.4.if.then, 15, implicit $eflags
   
   bb.5.if.end:
     successors: %bb.6.if.then.4(4), %bb.7.if.end.6(124)
     liveins: $eax, $ecx, $edi, $edx, $esi, $r8d
   
     DBG_VALUE $edi, _, !9, !17, debug-location !18
     DBG_VALUE $esi, _, !10, !17, debug-location !19
     DBG_VALUE $edx, _, !11, !17, debug-location !21
     DBG_VALUE $ecx, _, !12, !17, debug-location !23
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     TEST32rr $esi, $esi, implicit-def $eflags, debug-location !39
     JCC_1 %bb.6.if.then.4, 15, implicit $eflags
   
   bb.7.if.end.6:
     successors: %bb.8.if.then.8(4), %bb.2.for.cond(124)
     liveins: $eax, $ecx, $edi, $edx, $esi, $r8d
   
     DBG_VALUE $edi, _, !9, !17, debug-location !18
     DBG_VALUE $esi, _, !10, !17, debug-location !19
     DBG_VALUE $edx, _, !11, !17, debug-location !21
     DBG_VALUE $ecx, _, !12, !17, debug-location !23
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     TEST32rr $edx, $edx, implicit-def $eflags, debug-location !45
     JCC_1 %bb.8.if.then.8, 15, implicit $eflags
   
   bb.2.for.cond:
     successors: %bb.3.for.body(124), %bb.9.for.end(4)
     liveins: $eax, $ecx, $edi, $edx, $esi, $r8d
   
     DBG_VALUE $edi, _, !9, !17, debug-location !18
     DBG_VALUE $esi, _, !10, !17, debug-location !19
     DBG_VALUE $edx, _, !11, !17, debug-location !21
     DBG_VALUE $ecx, _, !12, !17, debug-location !23
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     $eax = INC32r killed $eax, implicit-def dead $eflags, debug-location !44
     DBG_VALUE $eax, _, !13, !17, debug-location !25
     CMP32rr $eax, $r8d, implicit-def $eflags, debug-location !31
     JCC_1 %bb.3.for.body, 12, implicit $eflags
     JMP_1 %bb.9.for.end
   
   bb.4.if.then:
     liveins: $ecx, $edi
   
     DBG_VALUE $edi, _, !9, !17, debug-location !18
     DBG_VALUE $ecx, _, !12, !17, debug-location !23
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     $ecx = IMUL32rr killed $ecx, killed $edi, implicit-def dead $eflags, debug-location !36
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     $eax = MOV32rr killed $ecx, debug-location !50
     RETQ $eax, debug-location !50
   
   bb.6.if.then.4:
     liveins: $ecx, $esi
   
     DBG_VALUE $esi, _, !10, !17, debug-location !19
     DBG_VALUE $ecx, _, !12, !17, debug-location !23
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     $ecx = IMUL32rr killed $ecx, killed $esi, implicit-def dead $eflags, debug-location !40
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     $eax = MOV32rr killed $ecx, debug-location !50
     RETQ $eax, debug-location !50
   
   bb.8.if.then.8:
     successors: %bb.9.for.end(0)
     liveins: $ecx, $edx
   
     DBG_VALUE $edx, _, !11, !17, debug-location !21
     DBG_VALUE $ecx, _, !12, !17, debug-location !23
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     $ecx = IMUL32rr killed $ecx, killed $edx, implicit-def dead $eflags, debug-location !46
   
   bb.9.for.end:
     liveins: $ecx
   
-    DBG_VALUE 0, 0, !13, !17, debug-location !25
+    DBG_VALUE 0, $noreg, !13, !17, debug-location !25
     $eax = MOV32rr killed $ecx, debug-location !50
     RETQ $eax, debug-location !50
 
 ...

llvm/test/DebugInfo/MIR/X86/live-debug-values-restore-collide.mir

 # RUN: llc %s -o - -run-pass=livedebugvalues -mtriple=x86_64-unknown-unknown | FileCheck %s
 #
 # This is a regression test for register/stack variable locations being
 # interpreted as each other. We place a variable location on the stack, based
 # on $rsp. We later make a memory load from $rsp. On faulty versions of LLVM
 # this gets interpreted as a stack restore of the spilt value (it's not).
 #
 # Test that LiveDebugValues does not create any new variable locations.
 #
 # CHECK-LABEL: name: baaar
 # CHECK-LABEL: bb.0.entry:
 # CHECK:       DBG_VALUE $r9d, $noreg, !{{[0-9]*}}, !DIExpression()
-# CHECK:       DBG_VALUE $rsp, 0, !{{[0-9]*}}, !DIExpression(DW_OP_plus_uconst, 16)
+# CHECK:       DBG_VALUE $rsp, $noreg, !{{[0-9]*}}, !DIExpression(DW_OP_plus_uconst, 16, DW_OP_deref)
 # CHECK-NOT:   DBG_VALUE
 --- |
   target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
   
   define void @baaar() !dbg !4 {
   entry:
     ret void
bb.0.entry:
     liveins: $rcx, $rdi, $rdx, $rsi, $r8, $r9d, $rbp, $r15, $r14, $r13, $r12, $rbx
   
     ; Setup
     DBG_VALUE $r9d, $noreg, !9, !DIExpression(), debug-location !10
     $rsp = frame-setup SUB64ri8 $rsp, 24, implicit-def dead $eflags
 
     ; Spill
     MOV32mr $rsp, 1, $noreg, 16, $noreg, $r9d :: (store 4 into %stack.0)
-    DBG_VALUE $rsp, 0, !9, !DIExpression(DW_OP_plus_uconst, 16), debug-location !10
+    DBG_VALUE $rsp, 0, !9, !DIExpression(), debug-location !10
 
     ; This load from the stack can be misinterpreted as a stack restore of
     ; any DBG_VALUe pointing at $rsp.
     $rsi = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load 8 from %stack.1)
 
     ; Return faff
     $eax = MOV32ri 0
     $rsp = frame-destroy ADD64ri8 $rsp, 24, implicit-def dead $eflags
     RETQ debug-location !10
 ...

llvm/test/DebugInfo/MIR/X86/live-debug-values-restore.mir

 # CHECK: ![[PVAR:[0-9]+]] = !DILocalVariable(name: "p",
 # CHECK: ![[QVAR:[0-9]+]] = !DILocalVariable(name: "q",
 # CHECK: ![[RVAR:[0-9]+]] = !DILocalVariable(name: "r",
 # CHECK: ![[SVAR:[0-9]+]] = !DILocalVariable(name: "s",
 # CHECK: ![[TVAR:[0-9]+]] = !DILocalVariable(name: "t",
 
 # Ascertain that the spill has been recognized and manifested in a DBG_VALUE.
 # CHECK: MOV64mr $rsp,{{.*-8.*}}killed{{.*}}$rdi :: (store 8 into %stack.0)
-# CHECK-NEXT: DBG_VALUE $rsp,{{.*}}![[PVAR]],{{.*}}!DIExpression(DW_OP_constu, 8, DW_OP_minus)
+# CHECK-NEXT: DBG_VALUE $rsp, $noreg, ![[PVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref)
 
 # Check for the restore.
 # CHECK: $rdi = MOV64rm $rsp,{{.*-8.*}}:: (load 8 from %stack.0)
 # CHECK-NEXT: DBG_VALUE $rdi,{{.*}}![[PVAR]], !DIExpression()
 
 --- |
   define dso_local i32 @f(i32* readonly %p) local_unnamed_addr !dbg !7 {
   entry:
bb.2.if.end:
     $rdi = MOV64ri 0
     RETQ $eax, debug-location !128
 
 ...
 ---
 # This third function tests that complex expressions are spilt, and restored
 # correctly within a basic block.
 
-# FIXME: the spilt location below is wrong, there should be a deref between
-# the spill-offset and the DW_OP_plus_uconst.
-
 # CHECK-LABEL: name: h
 # CHECK-LABEL: bb.0.entry:
 # CHECK:       DBG_VALUE $rdi, $noreg, ![[RVAR]], !DIExpression(DW_OP_plus_uconst, 1)
 # CHECK-LABEL: bb.1.if.then:
 # CHECK:       DBG_VALUE $rdi, $noreg, ![[RVAR]], !DIExpression(DW_OP_plus_uconst, 1)
-# CHECK:       DBG_VALUE $rsp, 0, ![[RVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 1)
+# CHECK:       DBG_VALUE $rsp, $noreg, ![[RVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_plus_uconst, 1)
 # CHECK:       DBG_VALUE $rdi, $noreg, ![[RVAR]], !DIExpression(DW_OP_plus_uconst, 1)
 # CHECK-LABEL: bb.2.if.end:
 # CHECK:       DBG_VALUE $rdi, $noreg, ![[RVAR]], !DIExpression(DW_OP_plus_uconst, 1)
 
 name:            h
 alignment:       16
 tracksRegLiveness: true
 liveins:         

 
 ...
 ---
 # Function four: test that spill restores are detected across block
 # boundaries. The spill has been moved to bb.1, children of which are
 # bb 2 and 3, neither of which modifies the stack loc. The exit block (3)
 # should still be tracking the spill, and restore it on stack load.
 
-# FIXME: this test too contains a broken spill location.
-
 # Summary: loc is in $rdi in bb0, spills to stack in bb1, remains in stack
 # in bb2, starts in stack then loaded in bb3.
 
 # CHECK-LABEL: name: i
 # CHECK-LABEL: bb.0.entry:
 # CHECK:       DBG_VALUE $rdi, $noreg, ![[SVAR]], !DIExpression(DW_OP_plus_uconst, 1)
 # CHECK-LABEL: bb.1.foo:
 # CHECK:       DBG_VALUE $rdi, $noreg, ![[SVAR]], !DIExpression(DW_OP_plus_uconst, 1)
-# CHECK:       DBG_VALUE $rsp, 0, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 1)
+# CHECK:       DBG_VALUE $rsp, $noreg, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_plus_uconst, 1)
 # CHECK-LABEL: bb.2.if.then:
-# CHECK:       DBG_VALUE $rsp, 0, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 1)
+# CHECK:       DBG_VALUE $rsp, $noreg, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_plus_uconst, 1)
 # CHECK-LABEL: bb.3.if.end
-# CHECK:       DBG_VALUE $rsp, 0, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 1)
+# CHECK:       DBG_VALUE $rsp, $noreg, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_plus_uconst, 1)
 # CHECK:       DBG_VALUE $rdi, $noreg, ![[SVAR]], !DIExpression(DW_OP_plus_uconst, 1)
 name:            i
 alignment:       16
 tracksRegLiveness: true
 liveins:         
   - { reg: '$rdi', virtual-reg: '' }
 frameInfo:       
   stackSize:       48
bb.3.if.end:
   
     renamable $rdi = MOV64rm $rsp, 1, $noreg, -8, $noreg :: (load 8 from %stack.0)
     renamable $eax = MOV32rm killed renamable $rdi, 1, $noreg, 4, $noreg, debug-location !323 :: (load 4 from %ir.add.ptr, !tbaa !24)
     RETQ $eax, debug-location !328
 
 ...
 ---
 # Test that if an unspilt DBG_VALUE starts as an indirect DBG_VALUE, then it
-# is restored as an indirect DBG_VALUE. FIXME: Note that for the intervening
-# period of being a spilt location there is still a missing layer of
-# indirection.
+# is restored as an indirect DBG_VALUE.
 
 # CHECK-LABEL: name: j
 # CHECK-LABEL: bb.0.entry:
-# CHECK:       DBG_VALUE $rdi, 0, ![[TVAR]], !DIExpression()
+# CHECK:       DBG_VALUE $rdi, $noreg, ![[TVAR]], !DIExpression(DW_OP_deref)
 # CHECK-LABEL: bb.1.if.then:
-# CHECK:       DBG_VALUE $rsp, 0, ![[TVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus)
+# CHECK:       DBG_VALUE $rsp, $noreg, ![[TVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_deref)
 # CHECK:       INLINEASM
-# CHECK:       DBG_VALUE ${{[a-zA-Z0-9]+}}, 0, ![[TVAR]], !DIExpression()
+# CHECK:       DBG_VALUE ${{[a-zA-Z0-9]+}}, $noreg, ![[TVAR]], !DIExpression(DW_OP_deref)
 # CHECK-LABEL: bb.2.if.end
 
 name:            j
 tracksRegLiveness: true
 liveins:         
   - { reg: '$rdi', virtual-reg: '' }
 frameInfo:       
   stackSize:       48
- { id: 0, name: '', type: spill-slot, offset: -64, size: 8, alignment: 8,
       stack-id: default, callee-saved-register: '', callee-saved-restored: true,
       debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
 constants:       []
 body:             |
   bb.0.entry:
     successors: %bb.2, %bb.1
     liveins: $rdi, $rbx, $r12, $r13, $r14, $r15, $rbp
   
-    DBG_VALUE $rdi, 0, !404, !DIExpression(), debug-location !405
-    DBG_VALUE $rdi, 0, !404, !DIExpression(), debug-location !405
+    DBG_VALUE $rdi, $noreg, !404, !DIExpression(DW_OP_deref), debug-location !405
+    DBG_VALUE $rdi, $noreg, !404, !DIExpression(DW_OP_deref), debug-location !405
     TEST64rr renamable $rdi, renamable $rdi, implicit-def $eflags, debug-location !406
     JCC_1 %bb.2, 4, implicit $eflags, debug-location !408
   
   bb.1.if.then:
     successors: %bb.2
     liveins: $rdi, $rbp, $r15, $r14, $r13, $r12, $rbx
   
     frame-setup PUSH64r killed $rbp, implicit-def $rsp, implicit $rsp

llvm/test/DebugInfo/MIR/X86/live-debug-values-spill.mir

 #
 # Make sure that we generated DBG_VALUE instructions for the spills
 # GENERATE: ![[INT0:[0-9]+]] = !DILocalVariable(name: "int0",{{.*}})
 # GENERATE: ![[INTB:[0-9]+]] = !DILocalVariable(name: "intb",{{.*}})
 # GENERATE: ![[INTD:[0-9]+]] = !DILocalVariable(name: "intd",{{.*}})
 #
 # GENERATE:      bb.1.if.end:
 # GENERATE:      MOV32mr $rbp, 1, $noreg, -48, $noreg, killed $edx :: (store 4 into %stack.5)
-# GENERATE-NEXT: DBG_VALUE $rbp, 0, ![[INT0]], !DIExpression(DW_OP_constu, 48, DW_OP_minus)
+# GENERATE-NEXT: DBG_VALUE $rbp, $noreg, ![[INT0]], !DIExpression(DW_OP_constu, 48, DW_OP_minus, DW_OP_deref)
 # GENERATE:      MOV32mr $rbp, 1, $noreg, -52, $noreg, killed $r8d :: (store 4 into %stack.4)
-# GENERATE-NEXT: DBG_VALUE $rbp, 0, ![[INTB]], !DIExpression(DW_OP_constu, 52, DW_OP_minus)
+# GENERATE-NEXT: DBG_VALUE $rbp, $noreg, ![[INTB]], !DIExpression(DW_OP_constu, 52, DW_OP_minus, DW_OP_deref)
 # GENERATE:      MOV32mr $rbp, 1, $noreg, -56, $noreg, killed $esi :: (store 4 into %stack.3)
-# GENERATE-NEXT: DBG_VALUE $rbp, 0, ![[INTD]], !DIExpression(DW_OP_constu, 56, DW_OP_minus)
+# GENERATE-NEXT: DBG_VALUE $rbp, $noreg, ![[INTD]], !DIExpression(DW_OP_constu, 56, DW_OP_minus, DW_OP_deref)
 #
 # Check that the spill locations that are valid at the end of bb.1.if.end are
 # propagated to subsequent BBs.
 #
 # GENERATE:      bb.2.if.then4:
 # GENERATE-NOT:  bb.3:
-# GENERATE-DAG:  DBG_VALUE $rbp, 0, ![[INTD]], !DIExpression(DW_OP_constu, 56, DW_OP_minus)
-# GENERATE-DAG:  DBG_VALUE $rbp, 0, ![[INTB]], !DIExpression(DW_OP_constu, 52, DW_OP_minus)
+# GENERATE-DAG:  DBG_VALUE $rbp, $noreg, ![[INTD]], !DIExpression(DW_OP_constu, 56, DW_OP_minus, DW_OP_deref)
+# GENERATE-DAG:  DBG_VALUE $rbp, $noreg, ![[INTB]], !DIExpression(DW_OP_constu, 52, DW_OP_minus, DW_OP_deref)
 #
 # GENERATE:      bb.3:
 # GENERATE-NOT:  bb.4.if.end13:
-# GENERATE-DAG:  DBG_VALUE $rbp, 0, ![[INTD]], !DIExpression(DW_OP_constu, 56, DW_OP_minus)
-# GENERATE-DAG:  DBG_VALUE $rbp, 0, ![[INTB]], !DIExpression(DW_OP_constu, 52, DW_OP_minus)
+# GENERATE-DAG:  DBG_VALUE $rbp, $noreg, ![[INTD]], !DIExpression(DW_OP_constu, 56, DW_OP_minus, DW_OP_deref)
+# GENERATE-DAG:  DBG_VALUE $rbp, $noreg, ![[INTB]], !DIExpression(DW_OP_constu, 52, DW_OP_minus, DW_OP_deref)
 #
 # GENERATE:      bb.4.if.end13:
 # GENERATE-NOT:  bb.5.cleanup:
-# GENERATE-DAG:  DBG_VALUE $rbp, 0, ![[INTD]], !DIExpression(DW_OP_constu, 56, DW_OP_minus)
-# GENERATE-DAG:  DBG_VALUE $rbp, 0, ![[INTB]], !DIExpression(DW_OP_constu, 52, DW_OP_minus)
+# GENERATE-DAG:  DBG_VALUE $rbp, $noreg, ![[INTD]], !DIExpression(DW_OP_constu, 56, DW_OP_minus, DW_OP_deref)
+# GENERATE-DAG:  DBG_VALUE $rbp, $noreg, ![[INTB]], !DIExpression(DW_OP_constu, 52, DW_OP_minus, DW_OP_deref)
 # 
 # Check that the spill location rbp-48 (the variable int0) is not propagated 
 # because int0 is redefined within the same basic block.
 #
 # TERMINATE:     bb.2.if.then4:
 # TERMINATE-NOT: DBG_VALUE $rbp, -48,
 --- |
   ; ModuleID = '<stdin>'
bb.0.entry:
     frame-setup PUSH64r killed $r12, implicit-def $rsp, implicit $rsp
     frame-setup PUSH64r killed $rbx, implicit-def $rsp, implicit $rsp
     $rsp = frame-setup SUB64ri8 $rsp, 24, implicit-def dead $eflags
     CFI_INSTRUCTION offset $rbx, -56
     CFI_INSTRUCTION offset $r12, -48
     CFI_INSTRUCTION offset $r13, -40
     CFI_INSTRUCTION offset $r14, -32
     CFI_INSTRUCTION offset $r15, -24
-    DBG_VALUE $edi, _, !24, !38, debug-location !39
-    DBG_VALUE $esi, _, !25, !38, debug-location !40
-    DBG_VALUE $edx, _, !26, !38, debug-location !41
-    DBG_VALUE $ecx, _, !27, !38, debug-location !42
-    DBG_VALUE $r8d, _, !28, !38, debug-location !43
-    DBG_VALUE $r9d, _, !29, !38, debug-location !44
+    DBG_VALUE $edi, $noreg, !24, !38, debug-location !39
+    DBG_VALUE $esi, $noreg, !25, !38, debug-location !40
+    DBG_VALUE $edx, $noreg, !26, !38, debug-location !41
+    DBG_VALUE $ecx, $noreg, !27, !38, debug-location !42
+    DBG_VALUE $r8d, $noreg, !28, !38, debug-location !43
+    DBG_VALUE $r9d, $noreg, !29, !38, debug-location !44
     $r14d = MOV32rr $r8d
-    DBG_VALUE $r14d, _, !28, !38, debug-location !43
+    DBG_VALUE $r14d, $noreg, !28, !38, debug-location !43
     $r12d = MOV32rr $esi
     DBG_VALUE $r12d, _, !25, !38, debug-location !40
     $eax = MOV32rr $edi
-    DBG_VALUE $eax, _, !24, !38, debug-location !39
+    DBG_VALUE $eax, $noreg, !24, !38, debug-location !39
     $r13d = MOV32rm $rip, 1, _, @glob0, _, debug-location !46 :: (dereferenceable load 4 from @glob0, !tbaa !47)
-    DBG_VALUE $r13d, _, !31, !38, debug-location !51
+    DBG_VALUE $r13d, $noreg, !31, !38, debug-location !51
     $r8d = MOV32rm $rip, 1, _, @glob1, _, debug-location !52 :: (dereferenceable load 4 from @glob1, !tbaa !47)
-    DBG_VALUE $r8d, _, !32, !38, debug-location !53
+    DBG_VALUE $r8d, $noreg, !32, !38, debug-location !53
     $r15d = MOV32rm $rip, 1, _, @glob2, _, debug-location !54 :: (dereferenceable load 4 from @glob2, !tbaa !47)
-    DBG_VALUE $r15d, _, !33, !38, debug-location !55
+    DBG_VALUE $r15d, $noreg, !33, !38, debug-location !55
     $esi = MOV32rm $rip, 1, _, @glob3, _, debug-location !56 :: (dereferenceable load 4 from @glob3, !tbaa !47)
-    DBG_VALUE $esi, _, !34, !38, debug-location !57
+    DBG_VALUE $esi, $noreg, !34, !38, debug-location !57
     $ebx = MOV32rm $rip, 1, _, @glob4, _, debug-location !59 :: (dereferenceable load 4 from @glob4, !tbaa !47)
-    DBG_VALUE $ebx, _, !35, !38, debug-location !60
+    DBG_VALUE $ebx, $noreg, !35, !38, debug-location !60
     MOV32mr $rbp, 1, _, -44, _, $ebx, debug-location !60 :: (store 4 into %ir.inte, !tbaa !47)
     $edi = MOV32rm $rip, 1, _, @glob5, _, debug-location !62 :: (dereferenceable load 4 from @glob5, !tbaa !47)
-    DBG_VALUE $edi, _, !36, !38, debug-location !63
+    DBG_VALUE $edi, $noreg, !36, !38, debug-location !63
     MOV32mr $rbp, 1, _, -60, _, $edi, debug-location !63 :: (store 4 into %ir.intf, !tbaa !47)
     TEST32rr killed $eax, $eax, implicit-def $eflags, debug-location !67
     JCC_1 %bb.5.cleanup, 5, implicit $eflags
   
   bb.1.if.end:
     successors: %bb.2(0x30000000), %bb.3.if.then4(0x50000000)
     liveins: $ebx, $ecx, $edi, $edx, $esi, $r8d, $r9d, $r12d, $r13d, $r14d, $r15d, $rbp
   
     MOV32mr $rbp, 1, _, -48, _, killed $edx :: (store 4 into %stack.5)
     MOV32mr $rbp, 1, _, -52, _, killed $r8d :: (store 4 into %stack.4)
     MOV32mr $rbp, 1, _, -56, _, killed $esi :: (store 4 into %stack.3)
-    DBG_VALUE _, _, !30, !38, debug-location !45
+    DBG_VALUE $noreg, $noreg, !30, !38, debug-location !45
     $r14d = ADD32rr killed $r14d, killed $ecx, implicit-def dead $eflags, debug-location !68
     $r14d = ADD32rr killed $r14d, killed $r9d, implicit-def dead $eflags, debug-location !69
     $r14d = IMUL32rm killed $r14d, $rbp, 1, _, 16, _, implicit-def dead $eflags, debug-location !70 :: (load 4 from %fixed-stack.6, align 16)
-    DBG_VALUE $r14d, _, !26, !38, debug-location !41
+    DBG_VALUE $r14d, $noreg, !26, !38, debug-location !41
     CALL64pcrel32 @use, csr_64, implicit $rsp, implicit $edi, implicit-def $rsp, debug-location !72
     $edi = MOV32rr killed $ebx, debug-location !73
     CALL64pcrel32 @use, csr_64, implicit $rsp, implicit $edi, implicit-def $rsp, debug-location !73
     TEST32rr killed $r12d, $r12d, implicit-def $eflags, debug-location !74
     JCC_1 %bb.2, 4, implicit $eflags
   
   bb.3.if.then4:
     successors: %bb.4.if.end13(0x80000000)
     liveins: $r14d, $r15d, $rbp
   
     $rdi = LEA64r $rbp, 1, _, -44, _
-    DBG_VALUE $rbp, -44, !35, !38, debug-location !60
+    DBG_VALUE $rbp, 0, !35, !38, debug-location !60
     $rsi = LEA64r $rbp, 1, _, -60, _
-    DBG_VALUE $rbp, -60, !36, !38, debug-location !63
+    DBG_VALUE $rbp, 1, !36, !38, debug-location !63
     $rdx = LEA64r $rbp, 1, _, -64, _
-    DBG_VALUE $rbp, -64, !37, !38, debug-location !78
+    DBG_VALUE $rbp, 2, !37, !38, debug-location !78
     CALL64pcrel32 @set, csr_64, implicit $rsp, implicit $rdi, implicit $rsi, implicit $rdx, implicit-def $rsp, debug-location !79
     $eax = MOV32rm $rbp, 1, _, -44, _, debug-location !81 :: (dereferenceable load 4 from %ir.inte, !tbaa !47)
-    DBG_VALUE $eax, _, !35, !38, debug-location !60
+    DBG_VALUE $eax, $noreg, !35, !38, debug-location !60
     $r15d = ADD32rm killed $r15d, $rbp, 1, _, -52, _, implicit-def dead $eflags, debug-location !82 :: (load 4 from %stack.4)
     $r15d = IMUL32rr killed $r15d, $eax, implicit-def dead $eflags, debug-location !82
     $r15d = ADD32rm killed $r15d, $rbp, 1, _, -56, _, implicit-def dead $eflags, debug-location !83 :: (load 4 from %stack.3)
     $r15d = IMUL32rr killed $r15d, killed $eax, implicit-def dead $eflags, debug-location !84
-    DBG_VALUE $r15d, _, !31, !38, debug-location !51
+    DBG_VALUE $r15d, $noreg, !31, !38, debug-location !51
     $r13d = MOV32rr killed $r15d
-    DBG_VALUE $r13d, _, !31, !38, debug-location !51
+    DBG_VALUE $r13d, $noreg, !31, !38, debug-location !51
     JMP_1 %bb.4.if.end13
   
   bb.2:
     successors: %bb.4.if.end13(0x80000000)
     liveins: $r13d, $r14d, $rbp
   
     $r14d = ADD32rm killed $r14d, $rbp, 1, _, -48, _, implicit-def dead $eflags, debug-location !71 :: (load 4 from %stack.5)
-    DBG_VALUE $r14d, _, !26, !38, debug-location !41
+    DBG_VALUE $r14d, $noreg, !26, !38, debug-location !41
   
   bb.4.if.end13:
     successors: %bb.5.cleanup(0x80000000)
     liveins: $r13d, $r14d, $rbp
   
-    DBG_VALUE $r14d, _, !26, !38, debug-location !41
-    DBG_VALUE $r13d, _, !31, !38, debug-location !51
+    DBG_VALUE $r14d, $noreg, !26, !38, debug-location !41
+    DBG_VALUE $r13d, $noreg, !31, !38, debug-location !51
     $r13d = IMUL32rm killed $r13d, $rbp, 1, _, 16, _, implicit-def dead $eflags, debug-location !86 :: (load 4 from %fixed-stack.6, align 16)
     $r13d = ADD32rr killed $r13d, killed $r14d, implicit-def dead $eflags, debug-location !87
-    DBG_VALUE $r13d, _, !26, !38, debug-location !41
+    DBG_VALUE $r13d, $noreg, !26, !38, debug-location !41
     $edi = MOV32rr killed $r13d, debug-location !88
     CALL64pcrel32 @use, csr_64, implicit $rsp, implicit $edi, implicit-def $rsp, debug-location !88
   
   bb.5.cleanup:
     liveins: $rbp
   
     $rsp = ADD64ri8 $rsp, 24, implicit-def dead $eflags, debug-location !90
     $rbx = POP64r implicit-def $rsp, implicit $rsp, debug-location !90
     $r12 = POP64r implicit-def $rsp, implicit $rsp, debug-location !90
     $r13 = POP64r implicit-def $rsp, implicit $rsp, debug-location !90
     $r14 = POP64r implicit-def $rsp, implicit $rsp, debug-location !90
     $r15 = POP64r implicit-def $rsp, implicit $rsp, debug-location !90
     $rbp = POP64r implicit-def $rsp, implicit $rsp, debug-location !90
     RETQ debug-location !90
 
 ...

llvm/test/DebugInfo/MIR/X86/live-debug-values-stack-clobber.mir

 # -------->8--------
 #
 # CHECK:       ![[ANUM:[0-9]+]] = !DILocalVariable(name: "a"
 # CHECK:       ![[BNUM:[0-9]+]] = !DILocalVariable(name: "b"
 #
 # These variables should be spilt,
 # CHECK-LABEL: bb.1.if.end:
 # CHECK:       MOV64mr $rsp, 1, $noreg, 16, $noreg, killed renamable $rsi
-# CHECK-NEXT:  DBG_VALUE $rsp, 0, ![[BNUM]], !DIExpression(
+# CHECK-NEXT:  DBG_VALUE $rsp, $noreg, ![[BNUM]], !DIExpression(
+# CHECK-SAME:         DW_OP_plus_uconst, 16, DW_OP_deref)
 # CHECK-NEXT:  MOV64mr $rsp, 1, $noreg, 8, $noreg, killed renamable $rdi
-# CHECK-NEXT:  DBG_VALUE $rsp, 0, ![[ANUM]], !DIExpression(
+# CHECK-NEXT:  DBG_VALUE $rsp, $noreg, ![[ANUM]], !DIExpression(
+# CHECK-SAME:         DW_OP_plus_uconst, 8, DW_OP_deref)
 # CHECK-NEXT:  INLINEASM
 #
 # Then the location of "a" should be terminated when overwritten
 # CHECK-LABEL: bb.3.if.end3:
 # CHECK:       CALL64pcrel32 @sum
 # CHECK-NEXT:  MOV64mr $rsp, 1, $noreg, 8, $noreg, $rax
 # CHECK-NEXT:  DBG_VALUE $noreg, $noreg, ![[ANUM]], !DIExpression()
 # CHECK-NEXT:  INLINEASM

llvm/test/DebugInfo/MIR/X86/prolog-epilog-indirection.mir

 # CHECK:      ![[VAR3:[0-9]+]] = !DILocalVariable(name: "bees"
 #
 # CHECK:      LEA64r $rsp
 # CHECK-NEXT: DBG_VALUE $rsp, $noreg, ![[VAR]], !DIExpression(DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_stack_value)
 # CHECK-NEXT: DBG_VALUE $rsp, $noreg, ![[VAR2]], !DIExpression(DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_stack_value, DW_OP_LLVM_fragment, 1, 2)
 # CHECK-NEXT: DBG_VALUE $rsp, $noreg, ![[VAR3]], !DIExpression(DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_LLVM_tag_offset, 0, DW_OP_stack_value)
 # CHECK-NEXT: DBG_VALUE 1834104526
 # CHECK-NEXT: MOV64mr
-# CHECK-NEXT: DBG_VALUE $rsp, 0, ![[VAR]], !DIExpression(DW_OP_plus_uconst, {{[0-9]+}})
+# CHECK-NEXT: DBG_VALUE $rsp, 0, ![[VAR]], !DIExpression()
 
 --- |
   ; ModuleID = 'out.ll'
   source_filename = "abc.c"
   target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
   
   @b = common dso_local local_unnamed_addr global i32* null, align 8, !dbg !0

llvm/test/DebugInfo/PowerPC/live-debug-vars-subreg-offset.ll

 ;
 ; compiled using:
 ;
 ;     clang --target=ppc64 -O3 -g -S -emit-llvm
 
 ; CHECK: ![[VAR:.*]] = !DILocalVariable(name: "spilled"
 
 ; CHECK: STD $x3, 0, %stack.0
-; CHECK-NEXT: DBG_VALUE %stack.0, 0, ![[VAR]], !DIExpression(DW_OP_plus_uconst, 4)
+; CHECK-NEXT: DBG_VALUE %stack.0, 0, ![[VAR]], !DIExpression()
 
 ; Function Attrs: noreturn nounwind
 define signext i32 @main() local_unnamed_addr #0 !dbg !8 {
 entry:
   %call = tail call signext i32 @foo() #2, !dbg !14
   call void @llvm.dbg.value(metadata i32 %call, metadata !13, metadata !DIExpression()), !dbg !14
   tail call void asm sideeffect "", "~{r0},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{r16},~{r17},~{r18},~{r19},~{r20},~{r21},~{r22},~{r23},~{r24},~{r25},~{r26},~{r27},~{r28},~{r29},~{r30},~{r31}"() #2, !dbg !14, !srcloc !15
   br label %for.cond, !dbg !14

llvm/test/DebugInfo/X86/dbg-declare-arg.ll

 ;   if (i == 42) {
 ;     j = i + 1;
 ;   };
 ;   A my_a;
 ;   my_a.x = j;
 ;   return my_a;
 ; }
 
+; dbg.declare for agg.result becomes a single DBG_VALUE, appearing first in a
+; spill slot, which is later restored into rcx.
+
 ; CHECK: DW_AT_name {{.*}}"j"
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_sec_offset] (
-; CHECK-NEXT:     [0x{{.*}}, 0x{{.*}}): DW_OP_breg7 RSP+16, DW_OP_deref)
+; CHECK-NEXT:     [0x{{.*}}, 0x{{.*}}): DW_OP_breg7 RSP+16, DW_OP_deref
+; CHECK-NEXT:     [0x{{.*}}, 0x{{.*}}): DW_OP_breg2 RCX+0)
 ; CHECK-NEXT:   DW_AT_name {{.*}}"my_a"
 
 %class.A = type { i32, i32, i32, i32 }
 
 define void @_Z3fooi(%class.A* sret %agg.result, i32 %i) ssp !dbg !19 {
 entry:
   %i.addr = alloca i32, align 4
   %j = alloca i32, align 4

llvm/test/DebugInfo/X86/dbg-value-of-spill-with-fp.ll

+; RUN: llc -start-after=codegenprepare %s -mtriple=i386-unknown-unknown -filetype=obj -o - | llvm-dwarfdump - --name=result | FileCheck %s
+
+; Like dbg-value-when-spilt.ll, but testing what happens when we have a stack
+; spill location and the stack pointer is modified. LiveDebugValues could
+; interpret the spilt-location as being invalidated by $esp being def'd, for
+; example by pushing a value onto the stack during a call (@extern below).
+; It shouldn't -- the debugger should be aware of the call site and take
+; account of it.
+
+; FIXME: While LiveDebugValues handles this correctly,
+; DbgEntityHistoryCalculator still terminates the location of 'result' early,
+; hence there's a gap (and repeated location spec) in the DWARF produced.
+
+; CHECK:      DW_TAG_variable
+; CHECK-NEXT: DW_AT_location
+; CHECK-NEXT: DW_OP_breg4 ESP+[[SLOT:[0-9]]]
+; CHECK-NEXT: DW_OP_breg4 ESP+[[SLOT]]
+; CHECK-NEXT: DW_OP_reg0 EAX)
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+@someglobal = global i32 0
+
+define i32 @_Z10get_stringv() !dbg !7 {
+entry:
+  %somearg = load i32, i32 *@someglobal
+  %nrvo = alloca i1, align 1
+  store i1 false, i1* %nrvo, align 1, !dbg !24
+  call void asm sideeffect "", "~{eax},~{ebx},~{ecx},~{edx},~{esi},~{edi},~{ebp},~{dirflag},~{fpsr},~{flags}"(), !dbg !24, !srcloc !28
+  call void @llvm.dbg.value(metadata i32 %somearg, metadata !23, metadata !DIExpression()), !dbg !24
+  call void @extern(i32 0), !dbg !24
+  call void asm sideeffect "", "~{eax},~{ebx},~{ecx},~{edx},~{esi},~{edi},~{ebp},~{dirflag},~{fpsr},~{flags}"(), !dbg !24, !srcloc !28
+  store i1 true, i1* %nrvo, align 1, !dbg !24
+  %nrvo.val = load i1, i1* %nrvo, align 1, !dbg !24
+  br i1 %nrvo.val, label %blocka, label %blockb, !dbg !24
+
+blocka:
+  store i32 0, i32 *@someglobal
+  br label %exit, !dbg !24
+
+blockb:
+  store i32 1, i32 *@someglobal
+  br label %exit, !dbg !24
+
+exit:
+  ret i32 %somearg, !dbg !24
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+declare void @extern(i32)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 6.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "t.cpp", directory: "C:\5Csrc\5Cllvm-project\5Cbuild")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 6.0.0 "}
+!7 = distinct !DISubprogram(name: "get_string", linkageName: "_Z10get_stringv", scope: !1, file: !1, line: 13, type: !8, isLocal: false, isDefinition: true, scopeLine: 13, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !22)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "string", file: !1, line: 7, size: 32, elements: !11, identifier: "_ZTS6string")
+!11 = !{!12, !14, !18, !21}
+!12 = !DIDerivedType(tag: DW_TAG_member, name: "i", scope: !10, file: !1, line: 11, baseType: !13, size: 32)
+!13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!14 = !DISubprogram(name: "string", scope: !10, file: !1, line: 8, type: !15, isLocal: false, isDefinition: false, scopeLine: 8, flags: DIFlagPrototyped, isOptimized: true)
+!15 = !DISubroutineType(types: !16)
+!16 = !{null, !17}
+!17 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!18 = !DISubprogram(name: "string", scope: !10, file: !1, line: 9, type: !19, isLocal: false, isDefinition: false, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: true)
+!19 = !DISubroutineType(types: !20)
+!20 = !{null, !17, !13}
+!21 = !DISubprogram(name: "~string", scope: !10, file: !1, line: 10, type: !15, isLocal: false, isDefinition: false, scopeLine: 10, flags: DIFlagPrototyped, isOptimized: true)
+!22 = !{!23}
+!23 = !DILocalVariable(name: "result", scope: !7, file: !1, line: 14, type: !10)
+!24 = !DILocation(line: 14, column: 3, scope: !7)
+!28 = !{i32 -2147471175}

llvm/test/DebugInfo/X86/dbg-value-when-spilt.ll

+; RUN: llc -start-after=codegenprepare %s -mtriple=x86_64-unknown-unknown -filetype=obj -o - | llvm-dwarfdump - --name=result | FileCheck %s
+
+; This is a copy of spill-indirect-nrvo.ll, testing that if we have a
+; dbg.value of a Value at a point where it's in a spill slot, then we should
+; be able to track through subsequent loads, regardless of implementation.
+
+; FIXME: Originally there was a conditional a call before return
+; (see spill-indirect-nrvo.ll); the spilt value was loaded into $rbx before
+; the call, but LiveDebugValues missed the later copy to $rax for return.
+
+; CHECK:      DW_TAG_variable
+; CHECK-NEXT: DW_AT_location
+; CHECK-NEXT: DW_OP_breg7 RSP+{{[0-9]}}
+; CHECK-NEXT: DW_OP_reg0 RAX)
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64--linux"
+
+@someglobal = global i32 0
+
+define i32 @_Z10get_stringv(i32 %somearg) !dbg !7 {
+entry:
+  %nrvo = alloca i1, align 1
+  store i1 false, i1* %nrvo, align 1, !dbg !24
+  call void @extern(i32 %somearg), !dbg !24
+  call void asm sideeffect "", "~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{dirflag},~{fpsr},~{flags}"(), !dbg !24, !srcloc !28
+  call void @llvm.dbg.value(metadata i32 %somearg, metadata !23, metadata !DIExpression()), !dbg !24
+  call void asm sideeffect "", "~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{dirflag},~{fpsr},~{flags}"(), !dbg !24, !srcloc !28
+  store i1 true, i1* %nrvo, align 1, !dbg !24
+  %nrvo.val = load i1, i1* %nrvo, align 1, !dbg !24
+  br i1 %nrvo.val, label %blocka, label %blockb, !dbg !24
+
+blocka:
+  store i32 0, i32 *@someglobal
+  br label %exit, !dbg !24
+
+blockb:
+  store i32 1, i32 *@someglobal
+  br label %exit, !dbg !24
+
+exit:
+  ret i32 %somearg, !dbg !24
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+declare void @extern(i32)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 6.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "t.cpp", directory: "C:\5Csrc\5Cllvm-project\5Cbuild")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 6.0.0 "}
+!7 = distinct !DISubprogram(name: "get_string", linkageName: "_Z10get_stringv", scope: !1, file: !1, line: 13, type: !8, isLocal: false, isDefinition: true, scopeLine: 13, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !22)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "string", file: !1, line: 7, size: 32, elements: !11, identifier: "_ZTS6string")
+!11 = !{!12, !14, !18, !21}
+!12 = !DIDerivedType(tag: DW_TAG_member, name: "i", scope: !10, file: !1, line: 11, baseType: !13, size: 32)
+!13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!14 = !DISubprogram(name: "string", scope: !10, file: !1, line: 8, type: !15, isLocal: false, isDefinition: false, scopeLine: 8, flags: DIFlagPrototyped, isOptimized: true)
+!15 = !DISubroutineType(types: !16)
+!16 = !{null, !17}
+!17 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!18 = !DISubprogram(name: "string", scope: !10, file: !1, line: 9, type: !19, isLocal: false, isDefinition: false, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: true)
+!19 = !DISubroutineType(types: !20)
+!20 = !{null, !17, !13}
+!21 = !DISubprogram(name: "~string", scope: !10, file: !1, line: 10, type: !15, isLocal: false, isDefinition: false, scopeLine: 10, flags: DIFlagPrototyped, isOptimized: true)
+!22 = !{!23}
+!23 = !DILocalVariable(name: "result", scope: !7, file: !1, line: 14, type: !10)
+!24 = !DILocation(line: 14, column: 3, scope: !7)
+!28 = !{i32 -2147471175}

llvm/test/DebugInfo/X86/fission-ranges.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 ; RUN: llvm-objdump -h %t | FileCheck --check-prefix=HDR %s
 
 ; RUN: llc -dwarf-version=5 -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck --check-prefix=V5RNGLISTS %s
 
 ; RUN: llc -O0 %s -mtriple=x86_64-unknown-linux-gnu -stop-after=livedebugvalues -o -| FileCheck --check-prefix=CHECK-MIR %s
 
 ; LiveDebugValues should produce DBG_VALUEs for variable "b" in successive
 ; blocks once we recognize that it is spilled.
 ; CHECK-MIR: ![[BDIVAR:[0-9]+]] = !DILocalVariable(name: "b"
-; CHECK-MIR: DBG_VALUE $rsp, 0, ![[BDIVAR]], !DIExpression(DW_OP_constu, 32, DW_OP_minus)
+; CHECK-MIR: DBG_VALUE $rsp, $noreg, ![[BDIVAR]], !DIExpression(DW_OP_constu, 32, DW_OP_minus, DW_OP_deref)
 ; CHECK-MIR-LABEL: bb.6.for.inc13:
-; CHECK-MIR: DBG_VALUE $rsp, 0, ![[BDIVAR]], !DIExpression(DW_OP_constu, 32, DW_OP_minus)
+; CHECK-MIR: DBG_VALUE $rsp, $noreg, ![[BDIVAR]], !DIExpression(DW_OP_constu, 32, DW_OP_minus, DW_OP_deref)
 ; CHECK-MIR-LABEL: bb.7.for.inc16:
-; CHECK-MIR: DBG_VALUE $rsp, 0, ![[BDIVAR]], !DIExpression(DW_OP_constu, 32, DW_OP_minus)
+; CHECK-MIR: DBG_VALUE $rsp, $noreg, ![[BDIVAR]], !DIExpression(DW_OP_constu, 32, DW_OP_minus, DW_OP_deref)
 
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NEXT: DW_AT_stmt_list
 ; CHECK-NEXT: DW_AT_comp_dir
 ; CHECK-NEXT: DW_AT_GNU_dwo_name
 ; CHECK-NEXT: DW_AT_GNU_dwo_id

llvm/test/DebugInfo/X86/op_deref.ll

 ; ASM-CHECK: DEBUG_VALUE: vla <- [DW_OP_deref] $rdx
 ; vla ptr is spilt too, it should have a stack location,
 ; ASM-CHECK: DEBUG_VALUE: vla <- [DW_OP_constu {{[0-9]+}}, DW_OP_minus, DW_OP_deref] [$rbp+0]
 ; ASM-CHECK: DW_OP_breg1
 
 ; RUN: llvm-as %s -o - | llvm-dis - | FileCheck %s --check-prefix=PRETTY-PRINT
 ; PRETTY-PRINT: DIExpression()
 
+; XFAIL: *
+; See the for.body block, LiveDebugValues sees a stack load and moves the
+; variable location with it, rather than leaving it alone.
+
 define void @testVLAwithSize(i32 %s) nounwind uwtable ssp !dbg !5 {
 entry:
   %s.addr = alloca i32, align 4
   %saved_stack = alloca i8*
   %i = alloca i32, align 4
   store i32 %s, i32* %s.addr, align 4
   call void @llvm.dbg.declare(metadata i32* %s.addr, metadata !10, metadata !DIExpression()), !dbg !11
   %0 = load i32, i32* %s.addr, align 4, !dbg !12
for.cond:                                         ; preds = %for.inc, %entry
   br i1 %cmp, label %for.body, label %for.end, !dbg !21
 
 for.body:                                         ; preds = %for.cond
   %5 = load i32, i32* %i, align 4, !dbg !23
   %6 = load i32, i32* %i, align 4, !dbg !23
   %mul = mul nsw i32 %5, %6, !dbg !23
   %7 = load i32, i32* %i, align 4, !dbg !23
   %idxprom = sext i32 %7 to i64, !dbg !23
+; XXX FIXME
+; The restore of vla here causes the stack location to be clobbered going
+; back around the loop. Ideally in the future, LLVM should be clever enough
+; to know that the variable location of vla is best left on the stack through
+; the body of the loop, rather than eagerly promoting it and losing it.
+; Some more example of poor decisions are in PR42834.
   %arrayidx = getelementptr inbounds i32, i32* %vla, i64 %idxprom, !dbg !23
   store i32 %mul, i32* %arrayidx, align 4, !dbg !23
   br label %for.inc, !dbg !25
 
 for.inc:                                          ; preds = %for.body
   %8 = load i32, i32* %i, align 4, !dbg !26
   %inc = add nsw i32 %8, 1, !dbg !26
   store i32 %inc, i32* %i, align 4, !dbg !26

llvm/test/DebugInfo/X86/parameters.ll

 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_name{{.*}} = "func"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_AT_location {{.*}}
 ; CHECK-NEXT: DW_OP_breg4 RSI+0)
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}} = "f"
 
+; Argument "g" enters in RSI, is spilt, then restored to RAX.
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_name{{.*}} = "func2"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_AT_location{{.*}}(DW_OP_fbreg +23)
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_AT_location{{.*}}(
 ; CHECK-NEXT: {{.*}}: DW_OP_breg4 RSI+0{{$}}
-; CHECK-NEXT: {{.*}}: DW_OP_breg7 RSP+8, DW_OP_deref)
+; CHECK-NEXT: {{.*}}: DW_OP_breg7 RSP+8, DW_OP_deref{{$}}
+; CHECK-NEXT: {{.*}}: DW_OP_breg0 RAX+0){{$}}
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}} = "g"
 
 %"struct.pr14763::foo" = type { i8 }
 
 ; Function Attrs: uwtable
 define void @_ZN7pr147634funcENS_3fooE(%"struct.pr14763::foo"* noalias sret %agg.result, %"struct.pr14763::foo"* %f) #0 !dbg !4 {
 entry:

llvm/test/DebugInfo/X86/pieces-4.ll

 ;                "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15");
 ;   return o.x;
 ; }
 
 ; CHECK-LABEL: bitpiece_spill:                         # @bitpiece_spill
 ; CHECK:               callq   g
 ; CHECK:               movl    %eax, [[offs:[0-9]+]](%rsp)          # 4-byte Spill
 ; CHECK:               #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_LLVM_fragment 32 32] 0
-; CHECK:               #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_plus_uconst [[offs]], DW_OP_LLVM_fragment 0 32] [$rsp+0]
+; CHECK:               #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_plus_uconst [[offs]], DW_OP_deref, DW_OP_LLVM_fragment 0 32] $rsp
 ; CHECK:               #APP
 ; CHECK:               #NO_APP
 ; CHECK:               movl    [[offs]](%rsp), %eax          # 4-byte Reload
 ; CHECK:               retq
 
 ; DWARF: .debug_loc contents:
 ; DWARF-NEXT: 0x00000000:
 ; DWARF-NEXT: {{.*}}: DW_OP_breg7 RSP+{{[0-9]+}}, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4

llvm/test/DebugInfo/X86/pr34545.ll

-; RUN: llc -O1 -filetype=asm -mtriple x86_64-unknown-linux-gnu -mcpu=x86-64 -o - %s -stop-after=livedebugvars | FileCheck %s
+; RUN: llc -O1 -filetype=asm -mtriple x86_64-unknown-linux-gnu -mcpu=x86-64 -o - %s -stop-after=livedebugvalues | FileCheck %s
 
 ; CHECK: $eax = MOV32rm
 ; CHECK: DBG_VALUE $eax
 ; CHECK: $eax = SHL32rCL killed renamable $eax
 ; CHECK: DBG_VALUE $eax
-; CHECK: DBG_VALUE $rsp, 0, !{{[0-9]+}}, !DIExpression(DW_OP_constu, 4, DW_OP_minus)
+; CHECK: DBG_VALUE $rsp, $noreg, !{{[0-9]+}}, !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref)
 ; CHECK: DBG_VALUE $eax
 ; CHECK: $eax = SHL32rCL killed renamable $eax
 ; CHECK: DBG_VALUE $eax
 ; CHECK: RETQ $eax
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 

llvm/test/DebugInfo/X86/prolog-params.mir

 # CHECK-NEXT: DBG_VALUE $edi, $noreg, ![[P1]], !DIExpression()
 # CHECK-NEXT: DBG_VALUE $esi, $noreg, ![[P2]], !DIExpression(DW_OP_LLVM_fragment, 0, 32)
 # CHECK-NEXT: DBG_VALUE $rdx, $noreg, ![[P2]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
 # CHECK-NEXT: DBG_VALUE $ecx, $noreg, ![[P3]], !DIExpression()
 # CHECK-NEXT: DBG_VALUE $r8d, $noreg, ![[P4]], !DIExpression()
 # CHECK-NEXT: DBG_VALUE $r9d, $noreg, ![[P5]], !DIExpression()
 # CHECK-NEXT: frame-setup PUSH64r
 
-# Locals and stack parameters are emitted after the prologue code.
-# CHECK: DBG_VALUE $rsp, 0, ![[P6]], !DIExpression(DW_OP_plus_uconst, 16)
+# Locals and stack parameters are emitted after the prologue code. The
+# second operand records their (negative) frame index, printed unsigned.
+# CHECK: DBG_VALUE $rsp, 4294967293, ![[P6]], !DIExpression()
 # CHECK-NEXT: DBG_VALUE $r9d, $noreg, ![[P6]], !DIExpression()
-# CHECK-NEXT: DBG_VALUE $rsp, 0, ![[P7]], !DIExpression(DW_OP_plus_uconst, 24)
-# CHECK-NEXT: DBG_VALUE $rsp, 0, ![[P8]], !DIExpression(DW_OP_plus_uconst, 32)
+# CHECK-NEXT: DBG_VALUE $rsp, 4294967294, ![[P7]], !DIExpression()
+# CHECK-NEXT: DBG_VALUE $rsp, 4294967295, ![[P8]], !DIExpression()
 # CHECK-NEXT: DBG_VALUE $edi, $noreg, ![[LOCAL1]], !DIExpression()
-# CHECK-NEXT: DBG_VALUE $rsp, 0, ![[LOCAL2]], !DIExpression(DW_OP_plus_uconst, 16)
+# CHECK-NEXT: DBG_VALUE $rsp, 4294967293, ![[LOCAL2]], !DIExpression()

llvm/test/DebugInfo/X86/spill-indirect-nrvo.ll

 ;   string result = 3;
 ;   FORCE_SPILL();
 ;   return result;
 ; }
 
 ; CHECK-LABEL: _Z10get_stringv:
 ; CHECK: #DEBUG_VALUE: get_string:result <- [DW_OP_deref] $rdi
 ; CHECK: movq   %rdi, [[OFFS:[0-9]+]](%rsp)          # 8-byte Spill
-; CHECK: #DEBUG_VALUE: get_string:result <- [DW_OP_plus_uconst [[OFFS]], DW_OP_deref] [$rsp+0]
+; CHECK: #DEBUG_VALUE: get_string:result <- [DW_OP_plus_uconst [[OFFS]], DW_OP_deref, DW_OP_deref] $rsp
 ; CHECK: callq  _ZN6stringC1Ei
 ; CHECK: #APP
 ; CHECK: #NO_APP
+; CHECK: movq    [[OFFS]](%rsp), %[[LOADREG:r[abcds][xi]]]  # 8-byte Reload
+; CHECK: #DEBUG_VALUE: get_string:result <- [DW_OP_deref] $[[LOADREG]]
 
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux"
 
 %struct.string = type { i32 }
 

llvm/test/DebugInfo/X86/spill-nontrivial-param.ll

 ; int foo(NonTrivial nt) {
 ;   FORCE_SPILL();
 ;   return nt.i;
 ; }
 
 ; CHECK-LABEL: _Z3foo10NonTrivial:
 ; CHECK: #DEBUG_VALUE: foo:nt <- [DW_OP_deref] $rdi
 ; CHECK: movq    %rdi, -8(%rsp)          # 8-byte Spill
-; CHECK: #DEBUG_VALUE: foo:nt <- [DW_OP_constu 8, DW_OP_minus, DW_OP_deref] [$rsp+0]
+; CHECK: #DEBUG_VALUE: foo:nt <- [DW_OP_constu 8, DW_OP_minus, DW_OP_deref, DW_OP_deref] $rsp
 ; CHECK: #APP
 ; CHECK: #NO_APP
 ; CHECK: movq    -8(%rsp), %rax          # 8-byte Reload
 ; CHECK: movl    (%rax), %eax
 
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"

llvm/test/DebugInfo/X86/spill-nospill.ll

 ;   g(y);
 ;   g(y);
 ;   return x + y;
 ; }
 
 ; CHECK-LABEL: f: # @f
 ; CHECK: callq   g
 ; CHECK: movl    %eax, [[X_OFFS:[0-9]+]](%rsp)          # 4-byte Spill
-; CHECK: #DEBUG_VALUE: f:x <- [DW_OP_plus_uconst [[X_OFFS]]] [$rsp+0]
+; CHECK: #DEBUG_VALUE: f:x <- [DW_OP_plus_uconst [[X_OFFS]], DW_OP_deref] $rsp
 ; CHECK: #APP
 ; CHECK: #NO_APP
 ; CHECK: callq   g
 ; CHECK: movl    %eax, %[[CSR:[^ ]*]]
 ; CHECK: #DEBUG_VALUE: f:y <- $esi
 ; CHECK: movl    %eax, %ecx
 ; CHECK: callq   g
 ; CHECK: movl    %[[CSR]], %ecx

llvm/test/DebugInfo/X86/sret.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -v -all %t | FileCheck %s --check-prefix=CHECK-DWO
 
 ; Based on the debuginfo-tests/sret.cpp code.
 
-; CHECK-DWO: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x51ac5644b1937aa1)
-; CHECK-DWO: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x51ac5644b1937aa1)
+; CHECK-DWO: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x29bc2656bdb2e5dc)
+; CHECK-DWO: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x29bc2656bdb2e5dc)
 
 ; RUN: llc -O0 -fast-isel=true -mtriple=x86_64-apple-darwin -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ; RUN: llc -O0 -fast-isel=false -mtriple=x86_64-apple-darwin -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ; CHECK: _ZN1B9AInstanceEv
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_sec_offset] (0x00000000
 ; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_breg5 RDI+0
-; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_breg6 RBP-24, DW_OP_deref)
+; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_breg6 RBP-24, DW_OP_deref
+; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_breg5 RDI+0
 ; CHECK-NEXT:   DW_AT_name {{.*}}"a"
 
 %class.A = type { i32 (...)**, i32 }
 %class.B = type { i8 }
 
 @_ZTV1A = linkonce_odr unnamed_addr constant [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (void (%class.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%class.A*)* @_ZN1AD0Ev to i8*)]
 @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
 @_ZTS1A = linkonce_odr constant [3 x i8] c"1A\00"