[DebugInfo] Lower dbg.declare to DBG_VALUE with DW_OP_deref

[rnk]

Summary

This is a step towards eliminating the vestigial second operand of
DBG_VALUE, which is always an immediate zero or noreg and only indicates
if the debug value is indirect in memory. Today, the offset is carried
in the DIExpression, and soon the indirection will live there too.

Many of the test case updates remove DW_OP_deref to better match the IR
that clang generates after r300523, which removed DW_OP_deref from VLAs
and indirect parameters.

[aprantl]

As discussed on IRC, I think that this is *generally* a good idea, but I'm skeptical about a few issues with the concrete implementation that I commented on inline.
These changes have to be made very carefully. Have you tried running the debuginfo-tests with your patch? To do this you need to checkout the debuginfo-tests repository into the clang/test directory and have either gdb or lldb installed and working (yes it's magical and works with both!).

We need to make sure that any change to the IR testcases can actually be reproduced by recompiling the original source with clang.

thanks for working on this!

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

5138

Can you explain why the DW_OP_deref needs to go at the end of the expression rather than the beginning?

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

12

Shouldn't this be an NFC commit?

llvm/test/DebugInfo/X86/safestack-byval.ll

18

That's a *very* different expression. Why is this correct?

88

Why the change?

llvm/test/DebugInfo/X86/vla.ll

36

I don't see a change in this patch that would have this effect.

[rnk]

Thanks for the review, it seems like this is headed in the right direction. I haven't tried debuginfo-tests yet, but I'll do that and get back.

BTW, we were thinking about adding tests for cdb to debuginfo-tests. cdb is the Windows command line debugger. I doubt the existing perl script will run on Windows out of the box, but we'll figure something out.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

5138

We have existing IR that looks like this:

dbg.declare(%block_params, !Var("foo"), !DIExpression(DW_OP_constu, 4, DW_OP_minus))

I *think* this means: take the pointer value in %block_params, subtract 4 from it, and look in memory to find the value.

I would expect this to be equivalent to:

dbg.value(%block_params, !Var("foo"), !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref))

Meaning, the DIExpression is applied to the IR value, which ultimately becomes a virtual register, and then a register or spilled stack slot. We apply the DIExpression of a dbg.declare to that value to get the address of the variable, and *then* we deref once more to get the value.

Does that makes sense? This isn't an area that I'm familiar with yet, but that's what I'm thinking here.

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

12

It isn't. I think we were getting wrong DBG_VALUEs in these cases. In this case, %agg.result starts in RDI and is spilled to RSP+8. Before this change, SDISel would make an indirect DBG_VALUE of a vreg copy of RDI. LiveDebugVariables doesn't do anything different if the original DBG_VALUE instruction was indirect and the vreg was spilled, it just makes an instruction like DBG_VALUE(<fi#N>, 0, ...) without adding a deref to the expression. It only propagates IsIndirect if the MachineOperand remained a register after register allocation.

llvm/test/DebugInfo/X86/safestack-byval.ll

18

It's a different expr, but I added the dwarfdump test to confirm that we emit the same final DWARF before and after this change. We still emit the location of [RBX-400].

88

I regenerated the IR with clang, and it doesn't come out with DW_OP_deref anymore. I didn't refresh the whole test case, but I could if you like. This is how I got it:

$ clang -g -S -emit-llvm -x c++ ss.c -fsanitize=safe-stack --target=x86_64-unknown-linux -O1 -o - | opt -S -safe-stack -o ss.ll

llvm/test/DebugInfo/X86/vla.ll

36

Clang no longer emits this DW_OP_deref after r300523. I renamed the old op_deref.ll test to vla2.ll, since it was really only using op_deref because clang used to use it for VLAs. vla2.ll is actually a much better test, it has dwarfdump checks, and I think those dwarf expressions are "more right" now.

[aprantl]

Okay, thanks for the explanation. In order to make this change our highest priority should be that the contract between Clang and LLVM still works.
Secondarily, we should make an effort to ensure that LLVM IR testcases that include source code actually reflect the contract and can be reproduced by recompiling the original source with clang. If the IR changes after a patch, it may make sense to clone the test so we get both coverage of the original codepath in the backend and coverage/documentation of how frontends are expected to behave.

The contract still works if the same source code compiled with a patched clang produces the same DWARF/codeview as an unmodified clang. The debuginfo-tests are a good indicator that we're heading in the right direction. Or in other words, every time I changed the code relating to indirectness I broke one of those tests on my first attempt :-)

[rnk]

Running debuginfo-tests was enlightening. My understanding of these opcodes is a lot worse than I thought it was. :( They are really impossible to understand without staring at the LLDB or GDB expression evaluation code. I'll have to think about this some more.

[rnk]

Closing this, I now realize this was a step in the wrong direction.

llvm/include/llvm/CodeGen/SelectionDAG.h

SDValue getTargetInsertSubreg(int SRIdx, const SDLoc &DL, EVT VT,
                                 SDValue Operand, SDValue Subreg);
 
   /// Get the specified node if it's already available, or else return NULL.
   SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTs, ArrayRef<SDValue> Ops,
                           const SDNodeFlags Flags = SDNodeFlags());
 
   /// Creates a SDDbgValue node.
   SDDbgValue *getDbgValue(DIVariable *Var, DIExpression *Expr, SDNode *N,
-                          unsigned R, bool IsIndirect, const DebugLoc &DL,
-                          unsigned O);
+                          unsigned R, const DebugLoc &DL, unsigned O);
 
   /// Constant
   SDDbgValue *getConstantDbgValue(DIVariable *Var, DIExpression *Expr,
                                   const Value *C, const DebugLoc &DL,
                                   unsigned O);
 
   /// FrameIndex
   SDDbgValue *getFrameIndexDbgValue(DIVariable *Var, DIExpression *Expr,

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
 
   /// Append \p Ops with operations to apply the \p Offset.
   static void appendOffset(SmallVectorImpl<uint64_t> &Ops, int64_t Offset);
 
   /// If this is a constant offset, extract it. If there is no expression,
   /// return true with an offset of zero.
   bool extractIfOffset(int64_t &Offset) const;
 
+  /// Append DW_OP_deref to an existing expression. Useful when converting a
+  /// dbg.declare that uses this expression to dbg.value.
+  DIExpression *appendDeref() const;
+
   /// Constants for DIExpression::prepend.
   enum { NoDeref = false, WithDeref = true, WithStackValue = true };
 
   /// Prepend \p DIExpr with a deref and offset operation and optionally turn it
   /// into a stack value.
   static DIExpression *prepend(const DIExpression *DIExpr, bool Deref,
                                int64_t Offset = 0, bool StackValue = false);
 

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

if (!Op && !Address->use_empty() && isa<Instruction>(Address) &&
       Op = MachineOperand::CreateReg(FuncInfo.InitializeRegForValue(Address),
                                      false);
 
     if (Op) {
       assert(DI->getVariable()->isValidLocationForIntrinsic(DbgLoc) &&
              "Expected inlined-at fields to agree");
       if (Op->isReg()) {
         Op->setIsDebug(true);
-        // A dbg.declare describes the address of a source variable, so lower it
-        // into an indirect DBG_VALUE.
+        // A dbg.declare describes the address of a source variable, so add
+        // DW_OP_deref.
         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
-                TII.get(TargetOpcode::DBG_VALUE), /*IsIndirect*/ true,
-                Op->getReg(), DI->getVariable(), DI->getExpression());
+                TII.get(TargetOpcode::DBG_VALUE), /*IsIndirect*/ false,
+                Op->getReg(), DI->getVariable(),
+                DI->getExpression()->appendDeref());
       } else
         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
                 TII.get(TargetOpcode::DBG_VALUE))
             .add(*Op)
             .addImm(0)
             .addMetadata(DI->getVariable())
             .addMetadata(DI->getExpression());
     } else {

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
       // dropped.
       MIB.addReg(0U);
     }
   } else {
     // Insert an Undef so we can see what we dropped.
     MIB.addReg(0U);
   }
 
-  // Indirect addressing is indicated by an Imm as the second parameter.
-  if (SD->isIndirect())
-    MIB.addImm(0U);
-  else
-    MIB.addReg(0U, RegState::Debug);
-
   MIB.addMetadata(Var);
   MIB.addMetadata(Expr);
 
   return &*MIB;
 }
 
 /// EmitMachineNode - Generate machine code for a target-specific node and
 /// needed dependencies.

llvm/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp

static void transferDbgValues(SelectionDAG &DAG, SDValue From, SDValue To,
   SmallVector<SDDbgValue *, 2> ClonedDVs;
   for (SDDbgValue *Dbg : DAG.GetDbgValues(FromNode)) {
     if (Dbg->getKind() != SDDbgValue::SDNODE)
       break;
 
     DIVariable *Var = Dbg->getVariable();
     auto *Fragment = DIExpression::createFragmentExpression(
         Dbg->getExpression(), OffsetInBits, To.getValueSizeInBits());
-    SDDbgValue *Clone =
-        DAG.getDbgValue(Var, Fragment, ToNode, To.getResNo(), Dbg->isIndirect(),
+    SDDbgValue *Clone = DAG.getDbgValue(Var, Fragment, ToNode, To.getResNo(),
                                         Dbg->getDebugLoc(), Dbg->getOrder());
     Dbg->setIsInvalidated();
     ClonedDVs.push_back(Clone);
   }
 
   for (SDDbgValue *Dbg : ClonedDVs)
     DAG.AddDbgValue(Dbg, ToNode, false);
 }
 

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

union {
     const Value *Const;     // valid for constants
     unsigned FrameIx;       // valid for stack objects
   } u;
   DIVariable *Var;
   DIExpression *Expr;
   DebugLoc DL;
   unsigned Order;
   enum DbgValueKind kind;
-  bool IsIndirect;
   bool Invalid = false;
 
 public:
   // Constructor for non-constants.
   SDDbgValue(DIVariable *Var, DIExpression *Expr, SDNode *N, unsigned R,
-             bool indir, DebugLoc dl, unsigned O)
-      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(indir) {
+             DebugLoc dl, unsigned O)
+      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O) {
     kind = SDNODE;
     u.s.Node = N;
     u.s.ResNo = R;
   }
 
   // Constructor for constants.
   SDDbgValue(DIVariable *Var, DIExpression *Expr, const Value *C, DebugLoc dl,
              unsigned O)
-      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(false) {
+      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O) {
     kind = CONST;
     u.Const = C;
   }
 
   // Constructor for frame indices.
   SDDbgValue(DIVariable *Var, DIExpression *Expr, unsigned FI, DebugLoc dl,
              unsigned O)
-      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(false) {
+      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O) {
     kind = FRAMEIX;
     u.FrameIx = FI;
   }
 
   // Returns the kind.
   DbgValueKind getKind() const { return kind; }
 
   // Returns the DIVariable pointer for the variable.
public:
   unsigned getResNo() const { assert (kind==SDNODE); return u.s.ResNo; }
 
   // Returns the Value* for a constant
   const Value *getConst() const { assert (kind==CONST); return u.Const; }
 
   // Returns the FrameIx for a stack object
   unsigned getFrameIx() const { assert (kind==FRAMEIX); return u.FrameIx; }
 
-  // Returns whether this is an indirect value.
-  bool isIndirect() const { return IsIndirect; }
-
   // Returns the DebugLoc.
   DebugLoc getDebugLoc() const { return DL; }
 
   // Returns the SDNodeOrder.  This is the order of the preceding node in the
   // input.
   unsigned getOrder() const { return Order; }
 
   // setIsInvalidated / isInvalidated - Setter / getter of the "Invalidated"

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

SDNode *SelectionDAG::getNodeIfExists(unsigned Opcode, SDVTList VTList,
   }
   return nullptr;
 }
 
 /// getDbgValue - Creates a SDDbgValue node.
 ///
 /// SDNode
 SDDbgValue *SelectionDAG::getDbgValue(DIVariable *Var, DIExpression *Expr,
-                                      SDNode *N, unsigned R, bool IsIndirect,
-                                      const DebugLoc &DL, unsigned O) {
+                                      SDNode *N, unsigned R, const DebugLoc &DL,
+                                      unsigned O) {
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
-  return new (DbgInfo->getAlloc())
-      SDDbgValue(Var, Expr, N, R, IsIndirect, DL, O);
+  return new (DbgInfo->getAlloc()) SDDbgValue(Var, Expr, N, R, DL, O);
 }
 
 /// Constant
 SDDbgValue *SelectionDAG::getConstantDbgValue(DIVariable *Var,
                                               DIExpression *Expr,
                                               const Value *C,
                                               const DebugLoc &DL, unsigned O) {
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
for (ArrayRef<SDDbgValue *>::iterator I = DVs.begin(), E = DVs.end();
        I != E; ++I) {
     SDDbgValue *Dbg = *I;
     // Only add Dbgvalues attached to same ResNo.
     if (Dbg->getKind() == SDDbgValue::SDNODE &&
         Dbg->getSDNode() == From.getNode() &&
         Dbg->getResNo() == From.getResNo() && !Dbg->isInvalidated()) {
       assert(FromNode != ToNode &&
              "Should not transfer Debug Values intranode");
-      SDDbgValue *Clone = getDbgValue(Dbg->getVariable(), Dbg->getExpression(),
-                                      ToNode, To.getResNo(), Dbg->isIndirect(),
-                                      Dbg->getDebugLoc(), Dbg->getOrder());
+      SDDbgValue *Clone =
+          getDbgValue(Dbg->getVariable(), Dbg->getExpression(), ToNode,
+                      To.getResNo(), Dbg->getDebugLoc(), Dbg->getOrder());
       ClonedDVs.push_back(Clone);
       Dbg->setIsInvalidated();
     }
   }
   for (SDDbgValue *I : ClonedDVs)
     AddDbgValue(I, ToNode, false);
 }
 

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

bool SelectionDAGBuilder::EmitFuncArgumentDbgValue(
   const TargetInstrInfo *TII = DAG.getSubtarget().getInstrInfo();
 
   // Ignore inlined function arguments here.
   //
   // FIXME: Should we be checking DL->inlinedAt() to determine this?
   if (!Variable->getScope()->getSubprogram()->describes(MF.getFunction()))
     return false;
 
-  bool IsIndirect = false;
   Optional<MachineOperand> Op;
   // Some arguments' frame index is recorded during argument lowering.
   int FI = FuncInfo.getArgumentFrameIndex(Arg);
   if (FI != INT_MAX)
     Op = MachineOperand::CreateFI(FI);
 
   if (!Op && N.getNode()) {
     unsigned Reg = getUnderlyingArgReg(N);
     if (Reg && TargetRegisterInfo::isVirtualRegister(Reg)) {
       MachineRegisterInfo &RegInfo = MF.getRegInfo();
       unsigned PR = RegInfo.getLiveInPhysReg(Reg);
       if (PR)
         Reg = PR;
     }
-    if (Reg) {
+    if (Reg)
       Op = MachineOperand::CreateReg(Reg, false);
-      IsIndirect = IsDbgDeclare;
-    }
   }
 
   if (!Op) {
     // Check if ValueMap has reg number.
     DenseMap<const Value *, unsigned>::iterator VMI = FuncInfo.ValueMap.find(V);
-    if (VMI != FuncInfo.ValueMap.end()) {
+    if (VMI != FuncInfo.ValueMap.end())
       Op = MachineOperand::CreateReg(VMI->second, false);
-      IsIndirect = IsDbgDeclare;
-    }
   }
 
   if (!Op && N.getNode())
     // Check if frame index is available.
     if (LoadSDNode *LNode = dyn_cast<LoadSDNode>(N.getNode()))
       if (FrameIndexSDNode *FINode =
           dyn_cast<FrameIndexSDNode>(LNode->getBasePtr().getNode()))
         Op = MachineOperand::CreateFI(FINode->getIndex());
 
   if (!Op)
     return false;
 
   assert(Variable->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
-  if (Op->isReg())
+  if (Op->isReg()) {
+    // Make this an indirect register location if this was dbg.declare.
+    if (IsDbgDeclare)
+      Expr = Expr->appendDeref();
     FuncInfo.ArgDbgValues.push_back(
-        BuildMI(MF, DL, TII->get(TargetOpcode::DBG_VALUE), IsIndirect,
+        BuildMI(MF, DL, TII->get(TargetOpcode::DBG_VALUE), /*IsIndirect=*/false,
                 Op->getReg(), Variable, Expr));
-  else
+  } else
     FuncInfo.ArgDbgValues.push_back(
         BuildMI(MF, DL, TII->get(TargetOpcode::DBG_VALUE))
             .add(*Op)
             .addImm(0)
             .addMetadata(Variable)
             .addMetadata(Expr));
 
   return true;
 }
 
 /// Return the appropriate SDDbgValue based on N.
 SDDbgValue *SelectionDAGBuilder::getDbgValue(SDValue N,
                                              DILocalVariable *Variable,
                                              DIExpression *Expr,
                                              const DebugLoc &dl,
                                              unsigned DbgSDNodeOrder) {
   if (auto *FISDN = dyn_cast<FrameIndexSDNode>(N.getNode())) {
     // Construct a FrameIndexDbgValue for FrameIndexSDNodes so we can describe
     // stack slot locations as such instead of as indirectly addressed
     // locations.
     return DAG.getFrameIndexDbgValue(Variable, Expr, FISDN->getIndex(), dl,
                                      DbgSDNodeOrder);
   }
-  return DAG.getDbgValue(Variable, Expr, N.getNode(), N.getResNo(), false, dl,
+  return DAG.getDbgValue(Variable, Expr, N.getNode(), N.getResNo(), dl,
                          DbgSDNodeOrder);
 }
 
 // VisualStudio defines setjmp as _setjmp
 #if defined(_MSC_VER) && defined(setjmp) && \
                          !defined(setjmp_undefined_for_msvc)
 #  pragma push_macro("setjmp")
 #  undef setjmp
if (N.getNode()) {
         SDV = DAG.getFrameIndexDbgValue(Variable, Expression,
                                         FINode->getIndex(), dl, SDNodeOrder);
       } else if (isa<Argument>(Address)) {
         // Address is an argument, so try to emit its dbg value using
         // virtual register info from the FuncInfo.ValueMap.
         EmitFuncArgumentDbgValue(Address, Variable, Expression, dl, true, N);
         return nullptr;
       } else {
-        SDV = DAG.getDbgValue(Variable, Expression, N.getNode(), N.getResNo(),
-                              true, dl, SDNodeOrder);
+        SDV = DAG.getDbgValue(Variable, Expression->appendDeref(), N.getNode(),
+                              N.getResNo(), dl, SDNodeOrder);
       }
       DAG.AddDbgValue(SDV, N.getNode(), isParameter);
     } else {
       // If Address is an argument then try to emit its dbg value using
       // virtual register info from the FuncInfo.ValueMap.
       if (!EmitFuncArgumentDbgValue(Address, Variable, Expression, dl, true,
                                     N)) {
         DEBUG(dbgs() << "Dropping debug info for " << DI << "\n");

llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

if (LDI != LiveInMap.end()) {
       assert(!hasFI && "There's no handling of frame pointer updating here yet "
                        "- add if needed");
       MachineInstr *Def = RegInfo->getVRegDef(LDI->second);
       MachineBasicBlock::iterator InsertPos = Def;
       const MDNode *Variable = MI->getDebugVariable();
       const MDNode *Expr = MI->getDebugExpression();
       DebugLoc DL = MI->getDebugLoc();
       bool IsIndirect = MI->isIndirectDebugValue();
-      if (IsIndirect)
-        assert(MI->getOperand(1).getImm() == 0 &&
-               "DBG_VALUE with nonzero offset");
+      assert(!IsIndirect && "no indirect DBG_VALUES before regalloc");
       assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
              "Expected inlined-at fields to agree");
       // Def is never a terminator here, so it is ok to increment InsertPos.
       BuildMI(*EntryMBB, ++InsertPos, DL, TII->get(TargetOpcode::DBG_VALUE),
               IsIndirect, LDI->second, Variable, Expr);
 
       // If this vreg is directly copied into an exported register then
       // that COPY instructions also need DBG_VALUE, if it is the only

llvm/lib/IR/DebugInfoMetadata.cpp

if (Elements[2] == dwarf::DW_OP_minus) {
       Offset = -Elements[1];
       return true;
     }
   }
 
   return false;
 }
 
+DIExpression *DIExpression::appendDeref() const {
+  // Place DW_OP_deref after all opcodes that compute the pointer, and place any
+  // fragment ops at the end.
+  SmallVector<uint64_t, 8> Ops(elements_begin(), elements_end());
+  auto I = expr_op_iterator(Ops.begin()), E = expr_op_iterator(Ops.end());
+  for (; I != E; ++I)
+    if (I->getOp() == dwarf::DW_OP_LLVM_fragment)
+      break;
+  Ops.insert(const_cast<uint64_t *>(I.getBase()), dwarf::DW_OP_deref);
+  return DIExpression::get(getContext(), Ops);
+}
+
 DIExpression *DIExpression::prepend(const DIExpression *Expr, bool Deref,
                                     int64_t Offset, bool StackValue) {
   SmallVector<uint64_t, 8> Ops;
   appendOffset(Ops, Offset);
   if (Deref)
     Ops.push_back(dwarf::DW_OP_deref);
   if (Expr)
     for (auto Op : Expr->expr_ops()) {

llvm/test/DebugInfo/COFF/pieces.ll

 ; ASM-LABEL: pad_left: # @pad_left
 ; ASM:         #DEBUG_VALUE: pad_left:o <- [DW_OP_LLVM_fragment 0 32] %ECX
 ; ASM:         .cv_loc 2 1 24 3                # t.c:24:3
 ; ASM:         movl    %ecx, %eax
 ; ASM:         retq
 
 
 ; ASM-LABEL: nested: # @nested
-; ASM:         #DEBUG_VALUE: nested:o <- [DW_OP_deref] [%RCX+0]
+; ASM:         #DEBUG_VALUE: nested:o <- [DW_OP_deref] %RCX
 ; ASM:         movl    12(%rcx), %eax
 ; ASM: [[p_start:\.Ltmp[0-9]+]]:
 ; ASM:         #DEBUG_VALUE: nested:p <- [DW_OP_LLVM_fragment 32 32] %EAX
 ; 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

 ; OBJ:       }
 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "nested"                # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    .Lfunc_begin3 .Lfunc_end3, "E\021J\001\000\000\000\000\000\000"
+; ASM:        .cv_def_range .Lfunc_begin3 .Lfunc_end3, "E\021J\001\000\000\000\000\000\000"
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "p"
 ; ASM:        .cv_def_range    [[p_start]] .Lfunc_end3, "C\021\021\000\000\000\004\000\000\000"
 
 ; OBJ-LABEL: {{.*}}Proc{{.*}}Sym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: nested
 ; OBJ:       }
 ; OBJ:       LocalSym {
-; OBJ:         Type: Nested&
+; OBJ:         Type: Nested ({{.*}})
 ; OBJ:         VarName: o
 ; OBJ:       }
 ; OBJ:       DefRangeRegisterRelSym {
 ; OBJ:         BaseRegister: 330
 ; OBJ:         HasSpilledUDTMember: No
 ; OBJ:         OffsetInParent: 0
 ; OBJ:         BasePointerOffset: 0
 ; OBJ:         LocalVariableAddrRange {

 !65 = !{!66}
 !66 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !64, file: !1, line: 4, baseType: !67, size: 128, align: 32)
 !67 = !DICompositeType(tag: DW_TAG_array_type, baseType: !53, size: 128, align: 32, elements: !68)
 !68 = !{!69}
 !69 = !DISubrange(count: 2)
 !70 = !{!71, !72}
 !71 = !DILocalVariable(name: "o", arg: 1, scope: !61, file: !1, line: 27, type: !64)
 !72 = !DILocalVariable(name: "p", scope: !61, file: !1, line: 28, type: !53)
-!73 = !DIExpression(DW_OP_deref)
+!73 = !DIExpression()
 !74 = !DILocation(line: 27, column: 26, scope: !61)
 !75 = !DILocation(line: 28, column: 18, scope: !61)
 !76 = !DILocation(line: 28, column: 22, scope: !61)
 !77 = !DILocation(line: 29, column: 3, scope: !61)
 !78 = distinct !DISubprogram(name: "bitpiece_spill", scope: !1, file: !1, line: 32, type: !8, isLocal: false, isDefinition: true, scopeLine: 32, isOptimized: true, unit: !0, variables: !79)
 !79 = !{!80}
 !80 = !DILocalVariable(name: "o", scope: !78, file: !1, line: 33, type: !13)
 !81 = !DILocation(line: 33, column: 18, scope: !78)
 !82 = !DILocation(line: 33, column: 26, scope: !78)
 !83 = !DILocation(line: 35, column: 3, scope: !78)
 !84 = !{i32 603}
 !85 = !DILocation(line: 37, column: 3, scope: !78)

llvm/test/DebugInfo/COFF/types-array-advanced.ll

 ; CHECK:   }
 ; CHECK:   Array (0x1003) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
 ; CHECK:     ElementType: int (0x74)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 4
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Pointer (0x1004) {
-; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
-; CHECK:     PointeeType: 0x1003
-; CHECK:     PointerAttributes: 0x2A
-; CHECK:     PtrType: Near32 (0xA)
-; CHECK:     PtrMode: LValueReference (0x1)
-; CHECK:     IsFlat: 0
-; CHECK:     IsConst: 0
-; CHECK:     IsVolatile: 0
-; CHECK:     IsUnaligned: 0
-; CHECK:     SizeOf: 0
-; CHECK:   }
-; CHECK:   Array (0x1005) {
+; CHECK:   Array (0x1004) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
 ; CHECK:     ElementType: char (0x70)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 7
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Array (0x1006) {
+; CHECK:   Array (0x1005) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK:     ElementType: 0x1005
+; CHECK:     ElementType: 0x1004
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 35
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Array (0x1007) {
+; CHECK:   Array (0x1006) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK:     ElementType: 0x1006
+; CHECK:     ElementType: 0x1005
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 70
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Struct (0x1008) {
+; CHECK:   Struct (0x1007) {
 ; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
 ; CHECK:     MemberCount: 0
 ; CHECK:     Properties [ (0x280)
 ; CHECK:       ForwardReference (0x80)
 ; CHECK:       HasUniqueName (0x200)
 ; CHECK:     ]
 ; CHECK:     FieldList: 0x0
 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: incomplete_struct
 ; CHECK:     LinkageName: .?AUincomplete_struct@@
 ; CHECK:   }
-; CHECK:   Array (0x1009) {
+; CHECK:   Array (0x1008) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK:     ElementType: incomplete_struct (0x1008)
+; CHECK:     ElementType: incomplete_struct (0x1007)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 12
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Pointer (0x100A) {
+; CHECK:   Pointer (0x1009) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
-; CHECK:     PointeeType: 0x1009
+; CHECK:     PointeeType: 0x1008
 ; CHECK:     PointerAttributes: 0x800A
 ; CHECK:     PtrType: Near32 (0xA)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 4
 ; CHECK:   }
-; CHECK:   FieldList (0x100B) {
-; CHECK:     TypeLeafKind: LF_FIELDLIST (0x1203)
-; CHECK:     DataMember {
-; CHECK:       TypeLeafKind: LF_MEMBER (0x150D)
-; CHECK:       AccessSpecifier: Public (0x3)
-; CHECK:       Type: int (0x74)
-; CHECK:       FieldOffset: 0x0
-; CHECK:       Name: s1
-; CHECK:     }
-; CHECK:   }
-; CHECK:   Struct (0x100C) {
-; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
-; CHECK:     MemberCount: 1
-; CHECK:     Properties [ (0x200)
-; CHECK:       HasUniqueName (0x200)
-; CHECK:     ]
-; CHECK:     FieldList: <field list> (0x100B)
-; CHECK:     DerivedFrom: 0x0
-; CHECK:     VShape: 0x0
-; CHECK:     SizeOf: 4
-; CHECK:     Name: incomplete_struct
-; CHECK:     LinkageName: .?AUincomplete_struct@@
-; CHECK:   }
-; CHECK:   StringId (0x100D) {
-; CHECK:     TypeLeafKind: LF_STRING_ID (0x1605)
-; CHECK:     Id: 0x0
-; CHECK:     StringData: \t.cpp
-; CHECK:   }
-; CHECK:   UdtSourceLine (0x100E) {
-; CHECK:     TypeLeafKind: LF_UDT_SRC_LINE (0x1606)
-; CHECK:     UDT: incomplete_struct (0x100C)
-; CHECK:     SourceFile: \t.cpp (0x100D)
-; CHECK:     LineNumber: 4
-; CHECK:   }
-; CHECK:   Modifier (0x100F) {
+;
+; CHECK:   Modifier (0x100E) {
 ; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
 ; CHECK:     ModifiedType: int (0x74)
 ; CHECK:     Modifiers [ (0x3)
 ; CHECK:       Const (0x1)
 ; CHECK:       Volatile (0x2)
 ; CHECK:     ]
 ; CHECK:   }
-; CHECK:   Array (0x1010) {
+; CHECK:   Array (0x100F) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK:     ElementType: const volatile int (0x100F)
+; CHECK:     ElementType: const volatile int (0x100E)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 16
-; CHECK:     Name: 
+; CHECK:     Name:
 ; CHECK:   }
 ; CHECK: ]
 
 source_filename = "test/DebugInfo/COFF/types-array-advanced.ll"
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc18.0.31101"
 
 %struct.incomplete_struct = type { i32 }
entry:
   %x.addr = alloca i32, align 4
   %saved_stack = alloca i8*, align 4
   store i32 %x, i32* %x.addr, align 4
   call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !38, metadata !39), !dbg !40
   %0 = load i32, i32* %x.addr, align 4, !dbg !41
   %1 = call i8* @llvm.stacksave(), !dbg !42
   store i8* %1, i8** %saved_stack, align 4, !dbg !42
   %vla = alloca i32, i32 %0, align 4, !dbg !42
-  call void @llvm.dbg.declare(metadata i32* %vla, metadata !43, metadata !47), !dbg !48
+  call void @llvm.dbg.declare(metadata i32* %vla, metadata !43, metadata !DIExpression()), !dbg !48
   %arrayidx = getelementptr inbounds i32, i32* %vla, i32 0, !dbg !49
   store i32 0, i32* %arrayidx, align 4, !dbg !50
   %2 = load i8*, i8** %saved_stack, align 4, !dbg !51
   call void @llvm.stackrestore(i8* %2), !dbg !51
   ret void, !dbg !51
 }
 
 ; Function Attrs: nounwind readnone

 !39 = !DIExpression()
 !40 = !DILocation(line: 8, column: 14, scope: !35)
 !41 = !DILocation(line: 9, column: 21, scope: !35)
 !42 = !DILocation(line: 9, column: 4, scope: !35)
 !43 = !DILocalVariable(name: "dyn_size_arr", scope: !35, file: !3, line: 9, type: !44)
 !44 = !DICompositeType(tag: DW_TAG_array_type, baseType: !13, align: 32, elements: !45)
 !45 = !{!46}
 !46 = !DISubrange(count: -1)
-!47 = !DIExpression(DW_OP_deref)
 !48 = !DILocation(line: 9, column: 8, scope: !35)
 !49 = !DILocation(line: 10, column: 4, scope: !35)
 !50 = !DILocation(line: 10, column: 20, scope: !35)
 !51 = !DILocation(line: 11, column: 1, scope: !35)
 

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

 ; RUN: llc -O0 -fast-isel=true  -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-macosx10.6.7"
 ; rdar://problem/9321650
+
+; %agg.result is spilled to [RSP+8] early on. It is a pointer to the "my_a"
+; value, so we need DW_OP_deref.
 ;
 ; 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+8)
+; CHECK-NEXT:     0x{{.*}} - 0x{{.*}}: DW_OP_breg7 RSP+8, DW_OP_deref)
 ; 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/debug-loc-asan.ll

 ; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
 ; RUN: llc  -O0 -mtriple=x86_64-unknown-linux-gnu -filetype=obj < %s \
 ; RUN:   | llvm-dwarfdump -debug-dump=info - | FileCheck %s --check-prefix=DWARF
 
 ; Verify that we have correct debug info for local variables in code
 ; instrumented with AddressSanitizer.
 
 ; Generated from the source file test.cc:
 ; int bar(int y) {
 ;   return y + 2;
 ; }
 ; with "clang++ -S -emit-llvm -mllvm -asan-skip-promotable-allocas=0 -fsanitize=address -O0 -g test.cc"
 
 ; The address of the (potentially now malloc'ed) alloca ends up
 ; in RDI, after which it is spilled to the stack. We record the
 ; spill OFFSET on the stack for checking the debug info below.
-; CHECK: #DEBUG_VALUE: bar:y <- [DW_OP_deref] [%RDI+0]
+; CHECK: #DEBUG_VALUE: bar:y <- [DW_OP_deref, DW_OP_deref] %RDI
 ; CHECK: movq %rdi, [[OFFSET:[0-9]+]](%rsp)
 ; CHECK-NEXT: [[START_LABEL:.Ltmp[0-9]+]]
 ; CHECK-NEXT: #DEBUG_VALUE: bar:y <- [DW_OP_plus_uconst [[OFFSET]], DW_OP_deref, DW_OP_deref]
 ; This location should be valid until the end of the function.
 
 ; CHECK:        movq    %rbp, %rsp
 ; CHECK-NEXT: [[END_LABEL:.Ltmp[0-9]+]]:
 

llvm/test/DebugInfo/X86/dw_op_minus.ll

 ; Test dwarf codegen of DW_OP_minus.
 ; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
+; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu %s -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump %t.o -debug-dump=info | FileCheck %s --check-prefix=DWARF
 
 ; This was built by compiling the following source with SafeStack and
 ; simplifying the result a little.
 ; extern "C" {
 ; void Capture(int *);
 ; void f() {
 ;   int buf[100];
 ;   Capture(buf);

 ; CHECK-NEXT: .byte 240                     # -400
 ; CHECK-NEXT: .byte 124
 
 ; RCX is clobbered in call @Capture, but there is a spilled copy.
 ; *(RSP + 8) - 400
 ; CHECK:      .short  7                       # Loc expr size
 ; CHECK-NEXT: .byte 119                     # DW_OP_breg7
 ; CHECK-NEXT: .byte 8                       # 8
-; CHECK-NEXT: .byte 6                       # DW_OP_deref
 ; CHECK-NEXT: .byte 16                      # DW_OP_constu
 ; CHECK-NEXT: .byte 144                     # 400
 ; CHECK-NEXT: .byte 3                       # DW_OP_minus
-; CHECK-NEXT: .byte 28
+; CHECK-NEXT: .byte 28                      # DW_OP_deref
+; CHECK-NEXT: .byte 6
+
+; DWARF:          DW_TAG_variable
+; DWARF-NEXT:       DW_AT_location [DW_FORM_sec_offset]   (0x00000000
+; DWARF-NEXT:          {{.*}} - {{.*}}: DW_OP_breg2 RCX-400
+; DWARF-NEXT:          {{.*}} - {{.*}}: DW_OP_breg7 RSP+8, DW_OP_constu 0x190, DW_OP_minus, DW_OP_deref)
+; DWARF-NEXT:       DW_AT_name [DW_FORM_strp]     ( .debug_str[{{.*}}] = "buf")

llvm/test/DebugInfo/X86/safestack-byval.ll

 ; Test dwarf codegen for DILocalVariable of a byval function argument that
 ; points to neither an argument nor an alloca. This kind of IR is generated by
 ; SafeStack for unsafe byval arguments.
 ; RUN: llc -mtriple=x86_64-unknown-unknown -stop-after expand-isel-pseudos %s -o - | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-unknown -filetype=obj %s -o - | llvm-dwarfdump -debug-dump=info - | FileCheck %s --check-prefix=DWARF
 
 ; This was built by compiling the following source with SafeStack and
 ; simplifying the result a little.
 ; struct S {
 ;   int a[100];
 ; };
 ;
 ; int f(S zzz, unsigned long len) {
 ;   return zzz.a[len];
 ; }
 
 ; CHECK: ![[ZZZ:.*]] = !DILocalVariable(name: "zzz",
-; CHECK: DBG_VALUE {{.*}} ![[ZZZ]], !DIExpression(DW_OP_deref, DW_OP_constu, 400, DW_OP_minus)
+; CHECK: DBG_VALUE {{.*}} ![[ZZZ]], !DIExpression(DW_OP_constu, 400, DW_OP_minus, DW_OP_deref)
+
+; DWARF: DW_TAG_formal_parameter
+; DWARF-NOT: DW_TAG_
+; DWARF: DW_AT_location {{.*}} ({{.*}}
+; DWARF-NEXT: {{.*}} - {{.*}}: DW_OP_breg3 RBX-400)
+; DWARF-NEXT: DW_AT_name {{.*}} "zzz"
 
 %struct.S = type { [100 x i32] }
 
 @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global i8*
 
 ; Function Attrs: norecurse nounwind readonly safestack uwtable
 define i32 @_Z1f1Sm(%struct.S* byval nocapture readonly align 8 %zzz, i64 %len) #0 !dbg !12 {
 entry:

 !15 = !DIBasicType(name: "long unsigned int", size: 64, align: 64, encoding: DW_ATE_unsigned)
 !16 = !{!17, !18}
 !17 = !DILocalVariable(name: "zzz", arg: 1, scope: !12, file: !1, line: 8, type: !4)
 !18 = !DILocalVariable(name: "len", arg: 2, scope: !12, file: !1, line: 8, type: !15)
 !19 = !{i32 2, !"Dwarf Version", i32 4}
 !20 = !{i32 2, !"Debug Info Version", i32 3}
 !21 = !{!"clang version 3.8.0 (trunk 254107) (llvm/trunk 254109)"}
 !22 = !DILocation(line: 8, column: 9, scope: !12)
-!23 = !DIExpression(DW_OP_deref, DW_OP_constu, 400, DW_OP_minus)
+!23 = !DIExpression(DW_OP_constu, 400, DW_OP_minus)
 !24 = !DILocation(line: 8, column: 28, scope: !12)
 !25 = !DIExpression()
 !26 = !DILocation(line: 9, column: 10, scope: !12)
 !27 = !{!28, !28, i64 0}
 !28 = !{!"int", !29, i64 0}
 !29 = !{!"omnipotent char", !30, i64 0}
 !30 = !{!"Simple C/C++ TBAA"}
 !31 = !DILocation(line: 9, column: 3, scope: !12)

llvm/test/DebugInfo/X86/vla.ll

 ; RUN: llc -O0 -mtriple=x86_64-apple-darwin -filetype=asm %s -o - | FileCheck %s
 ; Ensure that we generate an indirect location for the variable length array a.
-; CHECK: ##DEBUG_VALUE: vla:a <- [DW_OP_deref] [%RCX+0]
+; CHECK: ##DEBUG_VALUE: vla:a <- [DW_OP_deref] %RCX
 ; CHECK: DW_OP_breg2
 ; rdar://problem/13658587
 ;
 ; generated from:
 ;
 ; int vla(int n) {
 ;   int a[n];
 ;   a[0] = 42;
entry:
   %cleanup.dest.slot = alloca i32
   store i32 %n, i32* %n.addr, align 4
   call void @llvm.dbg.declare(metadata i32* %n.addr, metadata !15, metadata !DIExpression()), !dbg !16
   %0 = load i32, i32* %n.addr, align 4, !dbg !17
   %1 = zext i32 %0 to i64, !dbg !17
   %2 = call i8* @llvm.stacksave(), !dbg !17
   store i8* %2, i8** %saved_stack, !dbg !17
   %vla = alloca i32, i64 %1, align 16, !dbg !17
-  call void @llvm.dbg.declare(metadata i32* %vla, metadata !18, metadata !DIExpression(DW_OP_deref)), !dbg !17
+  call void @llvm.dbg.declare(metadata i32* %vla, metadata !18, metadata !DIExpression()), !dbg !17
   %arrayidx = getelementptr inbounds i32, i32* %vla, i64 0, !dbg !22
   store i32 42, i32* %arrayidx, align 4, !dbg !22
   %3 = load i32, i32* %n.addr, align 4, !dbg !23
   %sub = sub nsw i32 %3, 1, !dbg !23
   %idxprom = sext i32 %sub to i64, !dbg !23
   %arrayidx1 = getelementptr inbounds i32, i32* %vla, i64 %idxprom, !dbg !23
   %4 = load i32, i32* %arrayidx1, align 4, !dbg !23
   store i32 1, i32* %cleanup.dest.slot

llvm/test/DebugInfo/X86/vla2.ll

+; RUN: llc -O0 -mtriple=x86_64-apple-darwin %s -o - -filetype=asm \
+; RUN:     | FileCheck %s -check-prefix=ASM-CHECK
 ; RUN: llc -O0 -mtriple=x86_64-apple-darwin < %s -filetype=obj \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - \
 ; RUN:     | FileCheck %s -check-prefix=CHECK -check-prefix=DWARF4
 ; RUN: llc -O0 -mtriple=x86_64-apple-darwin < %s -filetype=obj -dwarf-version=3 \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - \
 ; RUN:     | FileCheck %s -check-prefix=CHECK -check-prefix=DWARF3
 
+; ASM-CHECK-LABEL: _testVLAwithSize:
+; ASM-CHECK-LABEL: Lfunc_begin0:
+;       Copy from RSP to RCX.
+; ASM-CHECK: movq %rsp, %rcx
+; ASM-CHECK: DEBUG_VALUE: vla <- [DW_OP_deref] %RCX
+; ASM-CHECK-LABEL: Lfunc_end0:
+
+; ASM-CHECK: DW_OP_breg2
+
 ; DWARF4: DW_AT_location [DW_FORM_sec_offset]                      (0x00000000
-; DWARF4-NEXT:  {{.*}}: DW_OP_breg2 RCX+0, DW_OP_deref
+; DWARF4-NEXT:  {{.*}}: DW_OP_breg2 RCX+0{{$}}
 
 ; DWARF3: DW_AT_location [DW_FORM_data4]                      (0x00000000
-; DWARF3-NEXT:  {{.*}}: DW_OP_breg2 RCX+0, DW_OP_deref
+; DWARF3-NEXT:  {{.*}}: DW_OP_breg2 RCX+0{{$}}
 
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name [DW_FORM_strp]  ( .debug_str[0x00000067] = "vla")
 
-; Check the DEBUG_VALUE comments for good measure.
-; RUN: llc -O0 -mtriple=x86_64-apple-darwin %s -o - -filetype=asm | FileCheck %s -check-prefix=ASM-CHECK
-; vla should have a register-indirect address at one point.
-; ASM-CHECK: DEBUG_VALUE: vla <- [DW_OP_deref] [%RCX+0]
-; ASM-CHECK: DW_OP_breg2
-
-; RUN: llvm-as %s -o - | llvm-dis - | FileCheck %s --check-prefix=PRETTY-PRINT
-; PRETTY-PRINT: DIExpression(DW_OP_deref)
-
 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
   %1 = zext i32 %0 to i64, !dbg !12
   %2 = call i8* @llvm.stacksave(), !dbg !12
   store i8* %2, i8** %saved_stack, !dbg !12
   %vla = alloca i32, i64 %1, align 16, !dbg !12
-  call void @llvm.dbg.declare(metadata i32* %vla, metadata !14, metadata !30), !dbg !18
+  call void @llvm.dbg.declare(metadata i32* %vla, metadata !14, metadata !DIExpression()), !dbg !18
   call void @llvm.dbg.declare(metadata i32* %i, metadata !19, metadata !DIExpression()), !dbg !20
   store i32 0, i32* %i, align 4, !dbg !21
   br label %for.cond, !dbg !21
 
 for.cond:                                         ; preds = %for.inc, %entry
   %3 = load i32, i32* %i, align 4, !dbg !21
   %4 = load i32, i32* %s.addr, align 4, !dbg !21
   %cmp = icmp slt i32 %3, %4, !dbg !21

 !22 = distinct !DILexicalBlock(line: 5, column: 3, file: !28, scope: !13)
 !23 = !DILocation(line: 6, column: 5, scope: !24)
 !24 = distinct !DILexicalBlock(line: 5, column: 27, file: !28, scope: !22)
 !25 = !DILocation(line: 7, column: 3, scope: !24)
 !26 = !DILocation(line: 5, column: 22, scope: !22)
 !27 = !DILocation(line: 8, column: 1, scope: !13)
 !28 = !DIFile(filename: "bar.c", directory: "/Users/echristo/tmp")
 !29 = !{i32 1, !"Debug Info Version", i32 3}
-!30 = !DIExpression(DW_OP_deref)