[SelectionDAG] Improve selection of DBG_VALUE using a PHI node result

[bjope]

Summary

When building the selection DAG at ISel all PHI nodes are
selected and lowered to Machine Instruction PHI nodes before
we start to create any SDNodes. So there are no SDNodes for
values produced by the PHI nodes.

In the past when selecting a dbg.value intrinsic that uses
the value produced by a PHI node we have been handling such
dbg.value intrinsics as "dangling debug info". I.e. we have
not created a SDDbgValue node directly, because there is
no existing SDNode for the PHI result, instead we deferred
the creationg of a SDDbgValue until we found the first use
of the PHI result.

The old solution had a couple of flaws. The position of the
selected DBG_VALUE instruction would end up quite late in a
basic block, and for example not directly after the PHI node
as in the LLVM IR input. And in case there were no use at all
in the basic block the dbg.value could be dropped completely.

This patch introduces a new VREG kind of SDDbgValue nodes.
It is similar to a SDNODE kind of node, but it refers directly
to a virtual register and not a SDNode. When we do selection
for a dbg.value that is using the result of a PHI node we
can do a lookup of the virtual register directly (as it already
is determined for the PHI node) and create a SDDbgValue node
immediately instead of delaying the selection until we find a
use.

This should fix a problem with losing debug info at ISel
as seen in PR37234 (https://bugs.llvm.org/show_bug.cgi?id=37234).
It does not resolve PR37234 completely, because the debug info
is dropped later on in the BranchFolder instead.

[bjope]

test/DebugInfo/X86/sdag-dbgvalue-phi-use-2.ll

47 ↗

(On Diff #144135)

This new test case actually expose another problem. It seems like the DBG_VALUE instructions sometimes are inserted before instead of after the SDNode that it is being associated with when building the selection DAG (at least for constants and these new phi-related nodes).

I'm thinking about looking into that later in a separate commit. This patch at least resurrects some earlier lost DBG_VALUE instructions, and puts them closer to their original position in the LLVM IR (even if they sometimes still are "off by one").

[aprantl]

lib/CodeGen/SelectionDAG/InstrEmitter.cpp

724 ↗

(On Diff #144135)

Just to be sure: this does *not* allocate a new vreg, right?

test/DebugInfo/COFF/pieces.ll

46 ↗

(On Diff #144135)

I'm having a hard time interpreting the assembler comment. Does this mean that the range of the DBG_VALUE get's immediately terminated by the assignment to edi, or does that mean "starting with the assignment"?

[bjope]

test/DebugInfo/COFF/pieces.ll

46 ↗

(On Diff #144135)

The original loop in C looks like this (at least according to the comment in the test case, I've not regenerated it from C since it is an old test case):

;   for (i = 0; i < n; i++) {
;     o.x = g(o.x);
;     o.y = g(o.y);
;   }
;   return o.x + o.y;

Without the patch we get this kind of structure in the loop body:

ox_start:
  #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 0 32] $edi
  o.x = g(o.x);
oy_start:
  #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 0 32] $edi
  #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 32 32] $esi
  o.y = g(o.y);
  #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 32 32] $esi
oy_end:

after the patch we get

ox_oy_start:
  #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 0 32] $edi
  #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 32 32] $esi
  o.x = g(o.x);
ox_start:
  #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 0 32] $edi
  o.y = g(o.y);
oy_start:
  #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 32 32] $esi
oy_end:

So the difference is basically that we now track "o.y" also for the first part of the loop body. That should be an improvement!

Perhaps I should rename ox_start as ox_restart, and oy_start as oy_restart, to indicate that those labels indicate where a new live range starts for the DEBUG_VALUEs (after the updates of o.x and o.y)? Or we could just call them LBL1, LBL2, LBL3 and LBL4.

[aprantl]

Thanks for the explanation!

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

7313 ↗

(On Diff #144135)

dangling comment?

[rnk]

test/DebugInfo/COFF/pieces.ll

46 ↗

(On Diff #144135)

I believe your analysis is correct! This is great, I was really annoyed that we didn't track o.y for the first part of the loop when I wrote this test case initially. I used it for a demo and I had to carefully put my breakpoint on the loop backedge so that both parts would show up in the debugger.

[bjope]

lib/CodeGen/SelectionDAG/InstrEmitter.cpp

724 ↗

(On Diff #144135)

No, we are just using the "unsigned" value for the register that was saved when creating the SDDbgValue.

Note that for this to work we must no change the vreg destination for the PHI node during SelectionDAG build/opt.
Since the PHI nodes aren't part of the SelectionDAG any "normal" use of the vreg would result in a CopyFromReg node that maps the PHI result to a SDValue. But since debug-info aren't supposed to affect code generation we can't create SDNodes for the debug-use. But I also assume that this means that the vreg defined by the already lowered PHI node will stay intact during the SelectionDAG build/opt.

An alternative approach that I considered was to save the Value*, for the PHI node in LLVM IR, similar to how we save a Value* when creating the SDDbgValue::CONST kind of nodes. And then we could use the FunctionLoweringInfo::ValueMap to do the translation into a vreg here in the InstrEmitter. However, then we need to expose the FunctionLoweringInfo to the InstrEmitter and pass that around while emitting things to be able to use it here. I'm not sure that it will make any difference really, and the current patch is smaller.

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

7313 ↗

(On Diff #144135)

Thanks, I'll fix that.

7320 ↗

(On Diff #144135)

Line longer than 80 columns, will be wrapped before landing this patch.

llvm/trunk/include/llvm/CodeGen/SelectionDAG.h

SDDbgValue *getConstantDbgValue(DIVariable *Var, DIExpression *Expr,
                                   const Value *C, const DebugLoc &DL,
                                   unsigned O);
 
   /// Creates a FrameIndex SDDbgValue node.
   SDDbgValue *getFrameIndexDbgValue(DIVariable *Var, DIExpression *Expr,
                                     unsigned FI, const DebugLoc &DL,
                                     unsigned O);
 
+  /// Creates a VReg SDDbgValue node.
+  SDDbgValue *getVRegDbgValue(DIVariable *Var, DIExpression *Expr,
+                              unsigned VReg, bool IsIndirect,
+                              const DebugLoc &DL, unsigned O);
+
   /// Transfer debug values from one node to another, while optionally
   /// generating fragment expressions for split-up values. If \p InvalidateDbg
   /// is set, debug values are invalidated after they are transferred.
   void transferDbgValues(SDValue From, SDValue To, unsigned OffsetInBits = 0,
                          unsigned SizeInBits = 0, bool InvalidateDbg = true);
 
   /// Remove the specified node from the system. If any of its
   /// operands then becomes dead, remove them as well. Inform UpdateListener

llvm/trunk/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

if (SD->getKind() == SDDbgValue::SDNODE) {
     // in all cases would be very fragile; this is a safeguard for any
     // that were missed.
     DenseMap<SDValue, unsigned>::iterator I = VRBaseMap.find(Op);
     if (I==VRBaseMap.end())
       MIB.addReg(0U);       // undef
     else
       AddOperand(MIB, Op, (*MIB).getNumOperands(), &II, VRBaseMap,
                  /*IsDebug=*/true, /*IsClone=*/false, /*IsCloned=*/false);
+  } else if (SD->getKind() == SDDbgValue::VREG) {
+    MIB.addReg(SD->getVReg(), RegState::Debug);
   } else if (SD->getKind() == SDDbgValue::CONST) {
     const Value *V = SD->getConst();
     if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
       if (CI->getBitWidth() > 64)
         MIB.addCImm(CI);
       else
         MIB.addImm(CI->getSExtValue());
     } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) {

llvm/trunk/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

 
 /// Holds the information from a dbg_value node through SDISel.
 /// We do not use SDValue here to avoid including its header.
 class SDDbgValue {
 public:
   enum DbgValueKind {
     SDNODE = 0,             ///< Value is the result of an expression.
     CONST = 1,              ///< Value is a constant.
-    FRAMEIX = 2             ///< Value is contents of a stack location.
+    FRAMEIX = 2,            ///< Value is contents of a stack location.
+    VREG = 3                ///< Value is a virtual register.
   };
 private:
   union {
     struct {
       SDNode *Node;         ///< Valid for expressions.
       unsigned ResNo;       ///< Valid for expressions.
     } s;
     const Value *Const;     ///< Valid for constants.
     unsigned FrameIx;       ///< Valid for stack objects.
+    unsigned VReg;          ///< Valid for registers.
   } u;
   DIVariable *Var;
   DIExpression *Expr;
   DebugLoc DL;
   unsigned Order;
   enum DbgValueKind kind;
   bool IsIndirect;
   bool Invalid = false;
public:
   /// 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) {
     kind = FRAMEIX;
     u.FrameIx = FI;
   }
 
+  /// Constructor for virtual registers.
+  SDDbgValue(DIVariable *Var, DIExpression *Expr, unsigned VReg, bool indir,
+             DebugLoc dl, unsigned O)
+      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(indir) {
+    kind = VREG;
+    u.VReg = VReg;
+  }
+
   /// Returns the kind.
   DbgValueKind getKind() const { return kind; }
 
   /// Returns the DIVariable pointer for the variable.
   DIVariable *getVariable() const { return Var; }
 
   /// Returns the DIExpression pointer for the expression.
   DIExpression *getExpression() const { return Expr; }
 
   /// Returns the SDNode* for a register ref
   SDNode *getSDNode() const { assert (kind==SDNODE); return u.s.Node; }
 
   /// Returns the ResNo for a register ref
   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 the Virtual Register for a VReg
+  unsigned getVReg() const { assert (kind==VREG); return u.VReg; }
+
   /// 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.

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

SDDbgValue *SelectionDAG::getFrameIndexDbgValue(DIVariable *Var,
                                                 DIExpression *Expr, unsigned FI,
                                                 const DebugLoc &DL,
                                                 unsigned O) {
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
   return new (DbgInfo->getAlloc()) SDDbgValue(Var, Expr, FI, DL, O);
 }
 
+/// VReg
+SDDbgValue *SelectionDAG::getVRegDbgValue(DIVariable *Var,
+                                          DIExpression *Expr,
+                                          unsigned VReg, bool IsIndirect,
+                                          const DebugLoc &DL, unsigned O) {
+  assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
+         "Expected inlined-at fields to agree");
+  return new (DbgInfo->getAlloc()) SDDbgValue(Var, Expr, VReg, IsIndirect, DL,
+                                              O);
+}
+
 void SelectionDAG::transferDbgValues(SDValue From, SDValue To,
                                      unsigned OffsetInBits, unsigned SizeInBits,
                                      bool InvalidateDbg) {
   SDNode *FromNode = From.getNode();
   SDNode *ToNode = To.getNode();
   assert(FromNode && ToNode && "Can't modify dbg values");
 
   // PR35338

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::dbg_value: {
     if (N.getNode()) {
       if (EmitFuncArgumentDbgValue(V, Variable, Expression, dl, false, N))
         return nullptr;
       SDV = getDbgValue(N, Variable, Expression, dl, SDNodeOrder);
       DAG.AddDbgValue(SDV, N.getNode(), false);
       return nullptr;
     }
 
+    // PHI nodes have already been selected, so we should know which VReg that
+    // is assigns to already.
+    if (isa<PHINode>(V)) {
+      auto It = FuncInfo.ValueMap.find(V);
+      if (It != FuncInfo.ValueMap.end()) {
+        unsigned Reg = It->second;
+        SDV = DAG.getVRegDbgValue(Variable, Expression, Reg, false, dl,
+                                  SDNodeOrder);
+        DAG.AddDbgValue(SDV, nullptr, false);
+        return nullptr;
+      }
+    }
+
     // TODO: When we get here we will either drop the dbg.value completely, or
     // we try to move it forward by letting it dangle for awhile. So we should
     // probably add an extra DbgValue to the DAG here, with a reference to
     // "noreg", to indicate that we have lost the debug location for the
     // variable.
 
     if (!V->use_empty() ) {
       // Do not call getValue(V) yet, as we don't want to generate code.

llvm/trunk/test/DebugInfo/COFF/pieces.ll

 ; ASM-LABEL: loop_csr: # @loop_csr
 ; ASM:        #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 0 32] 0
 ; ASM:        #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 32 32] 0
 ; ASM: # %bb.2:                                 # %for.body.preheader
 ; ASM:         xorl    %edi, %edi
 ; ASM:         xorl    %esi, %esi
 ; ASM:         .p2align        4, 0x90
 ; ASM: .LBB0_3:                                # %for.body
-; ASM: [[ox_start:\.Ltmp[0-9]+]]:
+; ASM: [[oy_ox_start:\.Ltmp[0-9]+]]:
 ; ASM:        #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 0 32] $edi
+; ASM:        #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 32 32] $esi
 ; ASM:        .cv_loc 0 1 13 11               # t.c:13:11
 ; ASM:        movl    %edi, %ecx
 ; ASM:        callq   g
 ; ASM:        movl    %eax, %edi
-; ASM: [[oy_start:\.Ltmp[0-9]+]]:
+; ASM: [[ox_start:\.Ltmp[0-9]+]]:
 ; ASM:         #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 0 32] $edi
-; ASM:         #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 32 32] $esi
 ; ASM:         .cv_loc 0 1 14 11               # t.c:14:11
 ; ASM:         movl    %esi, %ecx
 ; ASM:         callq   g
 ; ASM:         movl    %eax, %esi
+; ASM: [[oy_start:\.Ltmp[0-9]+]]:
 ; ASM:         #DEBUG_VALUE: loop_csr:o <- [DW_OP_LLVM_fragment 32 32] $esi
 ; ASM:         cmpl    n(%rip), %eax
 ; ASM:         jl      .LBB0_3
 ; ASM: [[oy_end:\.Ltmp[0-9]+]]:
 ; ASM:         addl    %edi, %esi
 ; ASM:         movl    %esi, %eax
 
 

 ; ASM: [[spill_o_x_end:\.Ltmp[0-9]+]]:
 ; ASM:         retq
 
 
 ; 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]], "C\021\030\000\000\000\000\000\000\000"
+; ASM:        .cv_def_range    [[oy_ox_start]] [[oy_start]], "C\021\027\000\000\000\004\000\000\000"
 ; ASM:        .cv_def_range    [[ox_start]] .Lfunc_end0, "C\021\030\000\000\000\000\000\000\000"
 ; ASM:        .cv_def_range    [[oy_start]] [[oy_end]], "C\021\027\000\000\000\004\000\000\000"
 
 
 ; OBJ-LABEL: {{.*}}Proc{{.*}}Sym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: loop_csr
 ; OBJ:       }

llvm/trunk/test/DebugInfo/X86/sdag-dbgvalue-phi-use-1.ll

+; RUN: llc -start-after=codegenprepare -stop-before expand-isel-pseudos -o - %s | FileCheck %s
+
+; This test case was generated from the following debug.c program,
+; using: clang debug.c -g -O1 -S -o dbg_value_phi_isel1.ll -emit-llvm
+; --------------------------------------
+; int end = 10;
+;
+; int main() {
+;   int x = 9;
+;   int y = 13;
+;   for (int u = 0; u < end; ++u) {
+;     x += y;
+;     y = y * 3;
+;   }
+;
+;   volatile int arr[80];
+;   for (int q = 0; q < 64; ++q) {
+;     arr[q] = q + 3;
+;   }
+;
+;   return x;
+; }
+; --------------------------------------
+;
+
+; ModuleID = 'debug.c'
+source_filename = "debug.c"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@end = dso_local local_unnamed_addr global i32 10, align 4, !dbg !0
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr #0 !dbg !11 {
+; CHECK-LABEL: name:            main
+entry:
+  %arr = alloca [80 x i32], align 16
+  call void @llvm.dbg.value(metadata i32 9, metadata !15, metadata !DIExpression()), !dbg !26
+  call void @llvm.dbg.value(metadata i32 13, metadata !16, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 0, metadata !17, metadata !DIExpression()), !dbg !28
+  %0 = load i32, i32* @end, align 4, !dbg !29, !tbaa !31
+  %cmp20 = icmp sgt i32 %0, 0, !dbg !35
+  br i1 %cmp20, label %for.body.lr.ph, label %for.cond.cleanup, !dbg !36
+
+for.body.lr.ph:                                   ; preds = %entry
+  %1 = load i32, i32* @end, align 4, !tbaa !31
+  br label %for.body, !dbg !36
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+; CHECK-LABEL: bb.{{.*}}.for.cond.cleanup:
+; CHECK:      [[REG1:%[0-9]+]]:gr32 = PHI
+; CHECK-NEXT: DBG_VALUE debug-use [[REG1]]
+  %x.0.lcssa = phi i32 [ 9, %entry ], [ %add, %for.body ]
+  call void @llvm.dbg.value(metadata i32 %x.0.lcssa, metadata !15, metadata !DIExpression()), !dbg !26
+  %2 = bitcast [80 x i32]* %arr to i8*, !dbg !37
+  call void @llvm.lifetime.start.p0i8(i64 320, i8* nonnull %2) #3, !dbg !37
+  call void @llvm.dbg.declare(metadata [80 x i32]* %arr, metadata !19, metadata !DIExpression()), !dbg !38
+  call void @llvm.dbg.value(metadata i32 0, metadata !24, metadata !DIExpression()), !dbg !39
+  br label %for.body4, !dbg !40
+
+for.body:                                         ; preds = %for.body.lr.ph, %for.body
+; CHECK-LABEL: bb.{{.*}}.for.body:
+; CHECK:      [[REG2:%[0-9]+]]:gr32 = PHI
+; CHECK-NEXT: [[REG3:%[0-9]+]]:gr32 = PHI
+; CHECK-NEXT: [[REG4:%[0-9]+]]:gr32 = PHI
+; CHECK-NEXT: DBG_VALUE debug-use [[REG2]]
+; CHECK-NEXT: DBG_VALUE debug-use [[REG3]]
+; CHECK-NEXT: DBG_VALUE debug-use [[REG4]]
+  %u.023 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.body ]
+  %y.022 = phi i32 [ 13, %for.body.lr.ph ], [ %mul, %for.body ]
+  %x.021 = phi i32 [ 9, %for.body.lr.ph ], [ %add, %for.body ]
+  call void @llvm.dbg.value(metadata i32 %u.023, metadata !17, metadata !DIExpression()), !dbg !28
+  call void @llvm.dbg.value(metadata i32 %y.022, metadata !16, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %x.021, metadata !15, metadata !DIExpression()), !dbg !26
+  %add = add nuw nsw i32 %y.022, %x.021, !dbg !41
+  %mul = mul nsw i32 %y.022, 3, !dbg !43
+  %inc = add nuw nsw i32 %u.023, 1, !dbg !44
+  call void @llvm.dbg.value(metadata i32 %inc, metadata !17, metadata !DIExpression()), !dbg !28
+  call void @llvm.dbg.value(metadata i32 %mul, metadata !16, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %add, metadata !15, metadata !DIExpression()), !dbg !26
+  %cmp = icmp slt i32 %inc, %1, !dbg !35
+  br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !36, !llvm.loop !45
+
+for.cond.cleanup3:                                ; preds = %for.body4
+  call void @llvm.lifetime.end.p0i8(i64 320, i8* nonnull %2) #3, !dbg !47
+  ret i32 %x.0.lcssa, !dbg !48
+
+for.body4:                                        ; preds = %for.body4, %for.cond.cleanup
+  %indvars.iv = phi i64 [ 0, %for.cond.cleanup ], [ %indvars.iv.next, %for.body4 ]
+  call void @llvm.dbg.value(metadata i64 %indvars.iv, metadata !24, metadata !DIExpression()), !dbg !39
+  %arrayidx = getelementptr inbounds [80 x i32], [80 x i32]* %arr, i64 0, i64 %indvars.iv, !dbg !49
+  %3 = trunc i64 %indvars.iv to i32, !dbg !52
+  %4 = add i32 %3, 3, !dbg !52
+  store volatile i32 %4, i32* %arrayidx, align 4, !dbg !52, !tbaa !31
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1, !dbg !53
+  call void @llvm.dbg.value(metadata i32 undef, metadata !24, metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)), !dbg !39
+  %exitcond = icmp eq i64 %indvars.iv.next, 64, !dbg !54
+  br i1 %exitcond, label %for.cond.cleanup3, label %for.body4, !dbg !40, !llvm.loop !55
+}
+
+; Function Attrs: argmemonly nounwind
+declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #2
+
+; Function Attrs: argmemonly nounwind
+declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.value(metadata, metadata, metadata) #2
+
+attributes #0 = { nounwind uwtable }
+attributes #1 = { argmemonly nounwind }
+attributes #2 = { nounwind readnone speculatable }
+attributes #3 = { nounwind }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9}
+!llvm.ident = !{!10}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "end", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 7.0.0 (x)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "debug.c", directory: "")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{i32 2, !"Dwarf Version", i32 4}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{!"clang version 7.0.0 (x)"}
+!11 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 3, type: !12, isLocal: false, isDefinition: true, scopeLine: 3, isOptimized: true, unit: !2, variables: !14)
+!12 = !DISubroutineType(types: !13)
+!13 = !{!6}
+!14 = !{!15, !16, !17, !19, !24}
+!15 = !DILocalVariable(name: "x", scope: !11, file: !3, line: 4, type: !6)
+!16 = !DILocalVariable(name: "y", scope: !11, file: !3, line: 5, type: !6)
+!17 = !DILocalVariable(name: "u", scope: !18, file: !3, line: 6, type: !6)
+!18 = distinct !DILexicalBlock(scope: !11, file: !3, line: 6, column: 3)
+!19 = !DILocalVariable(name: "arr", scope: !11, file: !3, line: 11, type: !20)
+!20 = !DICompositeType(tag: DW_TAG_array_type, baseType: !21, size: 2560, elements: !22)
+!21 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !6)
+!22 = !{!23}
+!23 = !DISubrange(count: 80)
+!24 = !DILocalVariable(name: "q", scope: !25, file: !3, line: 12, type: !6)
+!25 = distinct !DILexicalBlock(scope: !11, file: !3, line: 12, column: 3)
+!26 = !DILocation(line: 4, column: 7, scope: !11)
+!27 = !DILocation(line: 5, column: 7, scope: !11)
+!28 = !DILocation(line: 6, column: 12, scope: !18)
+!29 = !DILocation(line: 6, column: 23, scope: !30)
+!30 = distinct !DILexicalBlock(scope: !18, file: !3, line: 6, column: 3)
+!31 = !{!32, !32, i64 0}
+!32 = !{!"int", !33, i64 0}
+!33 = !{!"omnipotent char", !34, i64 0}
+!34 = !{!"Simple C/C++ TBAA"}
+!35 = !DILocation(line: 6, column: 21, scope: !30)
+!36 = !DILocation(line: 6, column: 3, scope: !18)
+!37 = !DILocation(line: 11, column: 3, scope: !11)
+!38 = !DILocation(line: 11, column: 16, scope: !11)
+!39 = !DILocation(line: 12, column: 12, scope: !25)
+!40 = !DILocation(line: 12, column: 3, scope: !25)
+!41 = !DILocation(line: 7, column: 7, scope: !42)
+!42 = distinct !DILexicalBlock(scope: !30, file: !3, line: 6, column: 33)
+!43 = !DILocation(line: 8, column: 11, scope: !42)
+!44 = !DILocation(line: 6, column: 28, scope: !30)
+!45 = distinct !{!45, !36, !46}
+!46 = !DILocation(line: 9, column: 3, scope: !18)
+!47 = !DILocation(line: 17, column: 1, scope: !11)
+!48 = !DILocation(line: 16, column: 3, scope: !11)
+!49 = !DILocation(line: 13, column: 5, scope: !50)
+!50 = distinct !DILexicalBlock(scope: !51, file: !3, line: 12, column: 32)
+!51 = distinct !DILexicalBlock(scope: !25, file: !3, line: 12, column: 3)
+!52 = !DILocation(line: 13, column: 12, scope: !50)
+!53 = !DILocation(line: 12, column: 27, scope: !51)
+!54 = !DILocation(line: 12, column: 21, scope: !51)
+!55 = distinct !{!55, !40, !56}
+!56 = !DILocation(line: 14, column: 3, scope: !25)

llvm/trunk/test/DebugInfo/X86/sdag-dbgvalue-phi-use-2.ll

+; RUN: llc -start-after=codegenprepare -stop-before expand-isel-pseudos -o - %s | FileCheck %s
+
+; This test case is a modified version of dbg_value_phi_isel1.ll
+; where the llvm.dbg.value nodes in for.body has been moved.
+
+; ModuleID = 'debug.c'
+source_filename = "debug.c"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@end = dso_local local_unnamed_addr global i32 10, align 4, !dbg !0
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr #0 !dbg !11 {
+entry:
+  %arr = alloca [80 x i32], align 16
+  call void @llvm.dbg.value(metadata i32 9, metadata !15, metadata !DIExpression()), !dbg !26
+  call void @llvm.dbg.value(metadata i32 13, metadata !16, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 0, metadata !17, metadata !DIExpression()), !dbg !28
+  %0 = load i32, i32* @end, align 4, !dbg !29, !tbaa !31
+  %cmp20 = icmp sgt i32 %0, 0, !dbg !35
+  br i1 %cmp20, label %for.body.lr.ph, label %for.cond.cleanup, !dbg !36
+
+for.body.lr.ph:                                   ; preds = %entry
+  %1 = load i32, i32* @end, align 4, !tbaa !31
+  br label %for.body, !dbg !36
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+; CHECK-LABEL: bb.{{.*}}.for.cond.cleanup:
+; CHECK:      [[REG1:%[0-9]+]]:gr32 = PHI
+; CHECK-NEXT: DBG_VALUE debug-use [[REG1]]
+  %x.0.lcssa = phi i32 [ 9, %entry ], [ %add, %for.body ]
+  call void @llvm.dbg.value(metadata i32 %x.0.lcssa, metadata !15, metadata !DIExpression()), !dbg !26
+  %2 = bitcast [80 x i32]* %arr to i8*, !dbg !37
+  call void @llvm.lifetime.start.p0i8(i64 320, i8* nonnull %2) #3, !dbg !37
+  call void @llvm.dbg.declare(metadata [80 x i32]* %arr, metadata !19, metadata !DIExpression()), !dbg !38
+  call void @llvm.dbg.value(metadata i32 0, metadata !24, metadata !DIExpression()), !dbg !39
+  br label %for.body4, !dbg !40
+
+for.body:                                         ; preds = %for.body.lr.ph, %for.body
+; CHECK-LABEL: bb.{{.*}}.for.body:
+; CHECK:      [[REG2:%[0-9]+]]:gr32 = PHI
+; CHECK-NEXT: [[REG3:%[0-9]+]]:gr32 = PHI
+; CHECK-NEXT: [[REG4:%[0-9]+]]:gr32 = PHI
+; CHECK-NEXT: DBG_VALUE debug-use [[REG3]], debug-use $noreg, !16
+; CHECK-NEXT: DBG_VALUE 555, debug-use $noreg, !17
+; XXX: Shouldn't the following DBG_VALUE be placed after the add (ADD32rr).
+; CHECK-NEXT: DBG_VALUE debug-use [[REG2]], debug-use $noreg, !17
+; CHECK-NEXT: ADD32rr
+; XXX: Shouldn't the following DBG_VALUE be placed after the mul (LEA etc).
+; CHECK-NEXT: DBG_VALUE 777, debug-use $noreg, !17
+; CHECK:      INC32r
+; XXX: Shouldn't the following DBG_VALUE be placed after the icmp (the non-dead implicit def of $eflags)
+; CHECK:      DBG_VALUE debug-use [[REG4]]
+; CHECK-NEXT: implicit-def $eflags
+  %u.023 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.body ]
+  %y.022 = phi i32 [ 13, %for.body.lr.ph ], [ %mul, %for.body ]
+  %x.021 = phi i32 [ 9, %for.body.lr.ph ], [ %add, %for.body ]
+  call void @llvm.dbg.value(metadata i32 %y.022, metadata !16, metadata !DIExpression()), !dbg !27
+  ; This dbg.value has been manually added compared to dbg_value_phi_isel1.ll
+  call void @llvm.dbg.value(metadata i32 555, metadata !17, metadata !DIExpression()), !dbg !28
+  %add = add nuw nsw i32 %y.022, %x.021, !dbg !41
+  ; This dbg.value has been manually moved compared to dbg_value_phi_isel1.ll
+  call void @llvm.dbg.value(metadata i32 %u.023, metadata !17, metadata !DIExpression()), !dbg !28
+  %mul = mul nsw i32 %y.022, 3, !dbg !43
+  ; This dbg.value has been manually added compared to dbg_value_phi_isel1.ll
+  call void @llvm.dbg.value(metadata i32 777, metadata !17, metadata !DIExpression()), !dbg !28
+  %inc = add nuw nsw i32 %u.023, 1, !dbg !44
+  call void @llvm.dbg.value(metadata i32 %inc, metadata !17, metadata !DIExpression()), !dbg !28
+  call void @llvm.dbg.value(metadata i32 %mul, metadata !16, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %add, metadata !15, metadata !DIExpression()), !dbg !26
+  %cmp = icmp slt i32 %inc, %1, !dbg !35
+  ; This dbg.value has been manually moved compared to dbg_value_phi_isel1.ll
+  call void @llvm.dbg.value(metadata i32 %x.021, metadata !15, metadata !DIExpression()), !dbg !26
+  br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !36, !llvm.loop !45
+
+for.cond.cleanup3:                                ; preds = %for.body4
+  call void @llvm.lifetime.end.p0i8(i64 320, i8* nonnull %2) #3, !dbg !47
+  ret i32 %x.0.lcssa, !dbg !48
+
+for.body4:                                        ; preds = %for.body4, %for.cond.cleanup
+  %indvars.iv = phi i64 [ 0, %for.cond.cleanup ], [ %indvars.iv.next, %for.body4 ]
+  call void @llvm.dbg.value(metadata i64 %indvars.iv, metadata !24, metadata !DIExpression()), !dbg !39
+  %arrayidx = getelementptr inbounds [80 x i32], [80 x i32]* %arr, i64 0, i64 %indvars.iv, !dbg !49
+  %3 = trunc i64 %indvars.iv to i32, !dbg !52
+  %4 = add i32 %3, 3, !dbg !52
+  store volatile i32 %4, i32* %arrayidx, align 4, !dbg !52, !tbaa !31
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1, !dbg !53
+  call void @llvm.dbg.value(metadata i32 undef, metadata !24, metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)), !dbg !39
+  %exitcond = icmp eq i64 %indvars.iv.next, 64, !dbg !54
+  br i1 %exitcond, label %for.cond.cleanup3, label %for.body4, !dbg !40, !llvm.loop !55
+}
+
+; Function Attrs: argmemonly nounwind
+declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #2
+
+; Function Attrs: argmemonly nounwind
+declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.value(metadata, metadata, metadata) #2
+
+attributes #0 = { nounwind uwtable }
+attributes #1 = { argmemonly nounwind }
+attributes #2 = { nounwind readnone speculatable }
+attributes #3 = { nounwind }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9}
+!llvm.ident = !{!10}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "end", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 7.0.0 (x)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "debug.c", directory: "")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{i32 2, !"Dwarf Version", i32 4}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{!"clang version 7.0.0 (x)"}
+!11 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 3, type: !12, isLocal: false, isDefinition: true, scopeLine: 3, isOptimized: true, unit: !2, variables: !14)
+!12 = !DISubroutineType(types: !13)
+!13 = !{!6}
+!14 = !{!15, !16, !17, !19, !24}
+!15 = !DILocalVariable(name: "x", scope: !11, file: !3, line: 4, type: !6)
+!16 = !DILocalVariable(name: "y", scope: !11, file: !3, line: 5, type: !6)
+!17 = !DILocalVariable(name: "u", scope: !18, file: !3, line: 6, type: !6)
+!18 = distinct !DILexicalBlock(scope: !11, file: !3, line: 6, column: 3)
+!19 = !DILocalVariable(name: "arr", scope: !11, file: !3, line: 11, type: !20)
+!20 = !DICompositeType(tag: DW_TAG_array_type, baseType: !21, size: 2560, elements: !22)
+!21 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !6)
+!22 = !{!23}
+!23 = !DISubrange(count: 80)
+!24 = !DILocalVariable(name: "q", scope: !25, file: !3, line: 12, type: !6)
+!25 = distinct !DILexicalBlock(scope: !11, file: !3, line: 12, column: 3)
+!26 = !DILocation(line: 4, column: 7, scope: !11)
+!27 = !DILocation(line: 5, column: 7, scope: !11)
+!28 = !DILocation(line: 6, column: 12, scope: !18)
+!29 = !DILocation(line: 6, column: 23, scope: !30)
+!30 = distinct !DILexicalBlock(scope: !18, file: !3, line: 6, column: 3)
+!31 = !{!32, !32, i64 0}
+!32 = !{!"int", !33, i64 0}
+!33 = !{!"omnipotent char", !34, i64 0}
+!34 = !{!"Simple C/C++ TBAA"}
+!35 = !DILocation(line: 6, column: 21, scope: !30)
+!36 = !DILocation(line: 6, column: 3, scope: !18)
+!37 = !DILocation(line: 11, column: 3, scope: !11)
+!38 = !DILocation(line: 11, column: 16, scope: !11)
+!39 = !DILocation(line: 12, column: 12, scope: !25)
+!40 = !DILocation(line: 12, column: 3, scope: !25)
+!41 = !DILocation(line: 7, column: 7, scope: !42)
+!42 = distinct !DILexicalBlock(scope: !30, file: !3, line: 6, column: 33)
+!43 = !DILocation(line: 8, column: 11, scope: !42)
+!44 = !DILocation(line: 6, column: 28, scope: !30)
+!45 = distinct !{!45, !36, !46}
+!46 = !DILocation(line: 9, column: 3, scope: !18)
+!47 = !DILocation(line: 17, column: 1, scope: !11)
+!48 = !DILocation(line: 16, column: 3, scope: !11)
+!49 = !DILocation(line: 13, column: 5, scope: !50)
+!50 = distinct !DILexicalBlock(scope: !51, file: !3, line: 12, column: 32)
+!51 = distinct !DILexicalBlock(scope: !25, file: !3, line: 12, column: 3)
+!52 = !DILocation(line: 13, column: 12, scope: !50)
+!53 = !DILocation(line: 12, column: 27, scope: !51)
+!54 = !DILocation(line: 12, column: 21, scope: !51)
+!55 = distinct !{!55, !40, !56}
+!56 = !DILocation(line: 14, column: 3, scope: !25)