[CodeGen] Fix bugs in LiveDebugVariables when debug labels are generated.

[HsiangKai]

Summary

Remove DBG_LABELs in LiveDebugVariables and generate them in
VirtRegRewriter.

This bug is reported in https://bugs.chromium.org/p/chromium/issues/detail?id=898152

[aprantl]

lib/CodeGen/LiveDebugVariables.cpp

343

Please don't repeat the function name in the Doxygen comment. I know the other code in this file does this, but that should be fixed, too :-)

422

Would you mind doing an NFC commit that just fixes up all the doxygen comments in this file?

We generally use \ instead of @.

548

Can't this code be shared with the DBG_VALUE printing function?

1424

range-based for?

[HsiangKai]

lib/CodeGen/LiveDebugVariables.cpp

422

I create a NFC commit in https://reviews.llvm.org/D54568

[dstenb]

lib/CodeGen/LiveDebugVariables.cpp

501

The cast will assert if Node is not a DILocalVariable, so I don't think it's possible to use this function with DILabels? I think you want dyn_cast_or_null (or rather dyn_cast, if Node is expected to be non-null).

[vext01]

This patch doesn't seem to apply. Does it need regenerating?

vext01@bencher8:~/source/llvm$ patch -Ep0 <  D54465.diff
patching file lib/CodeGen/LiveDebugVariables.cpp
Hunk #2 FAILED at 340.
Hunk #3 succeeded at 352 with fuzz 1 (offset -5 lines).
Hunk #4 FAILED at 372.
Hunk #5 succeeded at 395 (offset -9 lines).
Hunk #6 succeeded at 441 (offset -9 lines).
Hunk #7 succeeded at 466 (offset -9 lines).
Hunk #8 succeeded at 487 (offset -9 lines).
Hunk #9 succeeded at 531 (offset -9 lines).
Hunk #10 succeeded at 615 (offset -9 lines).
Hunk #11 succeeded at 651 (offset -9 lines).
Hunk #12 succeeded at 1291 (offset -7 lines).
Hunk #13 succeeded at 1348 (offset -7 lines).
2 out of 13 hunks FAILED -- saving rejects to file lib/CodeGen/LiveDebugVariables.cpp.rej
The next patch would create the file test/CodeGen/Generic/live-debug-label.ll,
which already exists!  Assume -R? [n]

[wolfgangp]

test/CodeGen/Generic/live-debug-label.ll

3

Generally it is a good idea to add the original C++ source code as a comment, along with the command on how the IR has been generated.

[HsiangKai]

In D54465#1299909, @vext01 wrote:

This patch doesn't seem to apply. Does it need regenerating?

vext01@bencher8:~/source/llvm$ patch -Ep0 <  D54465.diff
patching file lib/CodeGen/LiveDebugVariables.cpp
Hunk #2 FAILED at 340.
Hunk #3 succeeded at 352 with fuzz 1 (offset -5 lines).
Hunk #4 FAILED at 372.
Hunk #5 succeeded at 395 (offset -9 lines).
Hunk #6 succeeded at 441 (offset -9 lines).
Hunk #7 succeeded at 466 (offset -9 lines).
Hunk #8 succeeded at 487 (offset -9 lines).
Hunk #9 succeeded at 531 (offset -9 lines).
Hunk #10 succeeded at 615 (offset -9 lines).
Hunk #11 succeeded at 651 (offset -9 lines).
Hunk #12 succeeded at 1291 (offset -7 lines).
Hunk #13 succeeded at 1348 (offset -7 lines).
2 out of 13 hunks FAILED -- saving rejects to file lib/CodeGen/LiveDebugVariables.cpp.rej
The next patch would create the file test/CodeGen/Generic/live-debug-label.ll,
which already exists!  Assume -R? [n]

Sorry for that.
I have created another patch to refine doxygen document first in https://reviews.llvm.org/D54568.
You should apply it first, then apply this patch.

[HsiangKai]

Ping.

[probinson]

lib/CodeGen/LiveDebugVariables.cpp

409

The only call that I see to getUserLabel is in handleDebugLabel where the return value is not used. Am I missing something? If not, perhaps this should be a void method (with a different name, maybe addUserLabel).

[HsiangKai]

Ping.

[dstenb]

lib/CodeGen/LiveDebugVariables.cpp

1401

Should this be called emitDebugLabel instead, given that we only emit one label per UserLabel?

[HsiangKai]

Ping.

[dstenb]

This looks good to me, but I don't think I can give an official L-G-T-M.

Have you addressed all of the reviewers' comments?

test/CodeGen/Generic/live-debug-label.ll

36

In general I think it is preferred to have the RUN: lines at the top of the file.

[probinson]

A few more comments.

lib/CodeGen/LiveDebugVariables.cpp

589

The phrasing of the comment makes it sound like an assertion, rather than a description of the purpose of the loop. Maybe:
Nothing to do if Label already exists in userLabels.

679

addUserLabel is short and not used anywhere else, so I think it would be preferable to simply put that code inline here and not have the extra method.

test/CodeGen/Generic/live-debug-label.ll

41

These CHECK-LABEL directives can simply be CHECK directives.

[probinson]

LGTM

lib/CodeGen/LiveDebugVariables.cpp

 
 #define DEBUG_TYPE "livedebugvars"
 
 static cl::opt<bool>
 EnableLDV("live-debug-variables", cl::init(true),
           cl::desc("Enable the live debug variables pass"), cl::Hidden);
 
 STATISTIC(NumInsertedDebugValues, "Number of DBG_VALUEs inserted");
+STATISTIC(NumInsertedDebugLabels, "Number of DBG_LABELs inserted");
 
 char LiveDebugVariables::ID = 0;
 
 INITIALIZE_PASS_BEGIN(LiveDebugVariables, DEBUG_TYPE,
                 "Debug Variable Analysis", false, false)
 INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
 INITIALIZE_PASS_DEPENDENCY(LiveIntervals)
 INITIALIZE_PASS_END(LiveDebugVariables, DEBUG_TYPE,
void emitDebugValues(VirtRegMap *VRM, LiveIntervals &LIS,
                        const SpillOffsetMap &SpillOffsets);
 
   /// Return DebugLoc of this UserValue.
   DebugLoc getDebugLoc() { return dl;}
 
   void print(raw_ostream &, const TargetRegisterInfo *);
 };
 
+/// A user label is a part of a debug info user label.
+class UserLabel {
+  const DILabel *Label; /// The debug info label we are part of.
+  DebugLoc dl;          /// The debug location for the label. This is
+                        /// used by dwarf writer to find lexical scope.
+  SlotIndex loc;        /// Slot used by the debug label.
+
+  /// Insert a DBG_LABEL into MBB at Idx.
+  void insertDebugLabel(MachineBasicBlock *MBB, SlotIndex Idx,
+                        LiveIntervals &LIS, const TargetInstrInfo &TII);
+
+public:
+  /// Create a new UserLabel.
+  UserLabel(const DILabel *label, DebugLoc L, SlotIndex Idx)
+      : Label(label), dl(std::move(L)), loc(Idx) {}
+
+  /// Does this UserLabel match the parameters?
+  bool match(const DILabel *L, const DILocation *IA,
+             const SlotIndex Index) const {
+    return Label == L && dl->getInlinedAt() == IA && loc == Index;
+  }
+
+  /// Recreate DBG_LABEL instruction from data structures.
+  void emitDebugLabels(LiveIntervals &LIS, const TargetInstrInfo &TII);
+
+  /// Return DebugLoc of this UserLabel.
+  DebugLoc getDebugLoc() { return dl; }
+
+  void print(raw_ostream &, const TargetRegisterInfo *);
+};
+
 /// Implementation of the LiveDebugVariables pass.
 class LDVImpl {
   LiveDebugVariables &pass;
   LocMap::Allocator allocator;
   MachineFunction *MF = nullptr;
   LiveIntervals *LIS;
   const TargetRegisterInfo *TRI;
 
   /// Whether emitDebugValues is called.
   bool EmitDone = false;
 
   /// Whether the machine function is modified during the pass.
   bool ModifiedMF = false;
 
   /// All allocated UserValue instances.
   SmallVector<std::unique_ptr<UserValue>, 8> userValues;
 
+  /// All allocated UserLabel instances.
+  SmallVector<std::unique_ptr<UserLabel>, 2> userLabels;
+
   /// Map virtual register to eq class leader.
   using VRMap = DenseMap<unsigned, UserValue *>;
   VRMap virtRegToEqClass;
 
   /// Map user variable to eq class leader.
   using UVMap = DenseMap<const DILocalVariable *, UserValue *>;
   UVMap userVarMap;
 
   /// Find or create a UserValue.
   UserValue *getUserValue(const DILocalVariable *Var, const DIExpression *Expr,
                           const DebugLoc &DL);
 
+  /// Find or create a UserLabel.
+  UserLabel *getUserLabel(const DILabel *Label, const DebugLoc &DL,
+                          const SlotIndex Idx);
+
   /// Find the EC leader for VirtReg or null.
   UserValue *lookupVirtReg(unsigned VirtReg);
 
   /// Add DBG_VALUE instruction to our maps.
   ///
   /// \param MI DBG_VALUE instruction
   /// \param Idx Last valid SLotIndex before instruction.
   ///
-  /// \returns   True if the DBG_VALUE instruction should be deleted.
+  /// \returns True if the DBG_VALUE instruction should be deleted.
   bool handleDebugValue(MachineInstr &MI, SlotIndex Idx);
 
+  /// Add DBG_LABEL instruction to UserLabel.
+  ///
+  /// \param MI DBG_LABEL instruction
+  /// \param Idx Last valid SlotIndex before instruction.
+  ///
+  /// \returns True if the DBG_LABEL instruction should be deleted.
+  bool handleDebugLabel(MachineInstr &MI, SlotIndex Idx);
+
   /// \brief Collect and erase all DBG_VALUE instructions, adding
   /// a UserValue def for each instruction.
   ///
   /// \param mf MachineFunction to be scanned.
   ///
   /// \returns True if any debug values were found.
   bool collectDebugValues(MachineFunction &mf);
 
   /// \brief Compute the live intervals of all user values after
   /// collecting all their def points.
   void computeIntervals();
 
 public:
   LDVImpl(LiveDebugVariables *ps) : pass(*ps) {}
 
   bool runOnMachineFunction(MachineFunction &mf);
 
   /// Release all memory.
   void clear() {
     MF = nullptr;
     userValues.clear();
+    userLabels.clear();
     virtRegToEqClass.clear();
     userVarMap.clear();
     // Make sure we call emitDebugValues if the machine function was modified.
     assert((!ModifiedMF || EmitDone) &&
            "Dbg values are not emitted in LDV");
     EmitDone = false;
     ModifiedMF = false;
   }
static void printDebugLoc(const DebugLoc &DL, raw_ostream &CommentOS,
   if (!InlinedAtDL)
     return;
 
   CommentOS << " @[ ";
   printDebugLoc(InlinedAtDL, CommentOS, Ctx);
   CommentOS << " ]";
 }
 
-static void printExtendedName(raw_ostream &OS, const DILocalVariable *V,
+static void printExtendedName(raw_ostream &OS, const DINode *Node,
                               const DILocation *DL) {
-  const LLVMContext &Ctx = V->getContext();
-  StringRef Res = V->getName();
+  const LLVMContext &Ctx = Node->getContext();
+  StringRef Res;
+  unsigned Line;
+  if (const auto *V = cast_or_null<const DILocalVariable>(Node)) {
+    Res = V->getName();
+    Line = V->getLine();
+  } else if (const auto *L = cast_or_null<const DILabel>(Node)) {
+    Res = L->getName();
+    Line = L->getLine();
+  }
+
   if (!Res.empty())
-    OS << Res << "," << V->getLine();
+    OS << Res << "," << Line;
   if (auto *InlinedAt = DL->getInlinedAt()) {
     if (DebugLoc InlinedAtDL = InlinedAt) {
       OS << " @[";
       printDebugLoc(InlinedAtDL, OS, Ctx);
       OS << "]";
     }
   }
 }
 
 void UserValue::print(raw_ostream &OS, const TargetRegisterInfo *TRI) {
-  auto *DV = cast<DILocalVariable>(Variable);
   OS << "!\"";
-  printExtendedName(OS, DV, dl);
+  printExtendedName(OS, Variable, dl);
 
   OS << "\"\t";
   for (LocMap::const_iterator I = locInts.begin(); I.valid(); ++I) {
     OS << " [" << I.start() << ';' << I.stop() << "):";
     if (I.value().isUndef())
       OS << "undef";
     else {
       OS << I.value().locNo();
       if (I.value().wasIndirect())
         OS << " ind";
     }
   }
   for (unsigned i = 0, e = locations.size(); i != e; ++i) {
     OS << " Loc" << i << '=';
     locations[i].print(OS, TRI);
   }
   OS << '\n';
 }
 
+void UserLabel::print(raw_ostream &OS, const TargetRegisterInfo *TRI) {
+  OS << "!\"";
+  printExtendedName(OS, Label, dl);
+
+  OS << "\"\t";
+  OS << loc;
+  OS << '\n';
+}
+
 void LDVImpl::print(raw_ostream &OS) {
   OS << "********** DEBUG VARIABLES **********\n";
   for (unsigned i = 0, e = userValues.size(); i != e; ++i)
     userValues[i]->print(OS, TRI);
+  OS << "********** DEBUG LABELS **********\n";
+  for (unsigned i = 0, e = userLabels.size(); i != e; ++i)
+    userLabels[i]->print(OS, TRI);
 }
 #endif
 
 void UserValue::mapVirtRegs(LDVImpl *LDV) {
   for (unsigned i = 0, e = locations.size(); i != e; ++i)
     if (locations[i].isReg() &&
         TargetRegisterInfo::isVirtualRegister(locations[i].getReg()))
       LDV->mapVirtReg(locations[i].getReg(), this);
UserValue *LDVImpl::getUserValue(const DILocalVariable *Var,
 
   userValues.push_back(
       llvm::make_unique<UserValue>(Var, Expr, DL, allocator));
   UserValue *UV = userValues.back().get();
   Leader = UserValue::merge(Leader, UV);
   return UV;
 }
 
+UserLabel *LDVImpl::getUserLabel(const DILabel *Label, const DebugLoc &DL,
+                                 const SlotIndex Idx) {
+  for (auto const &L : userLabels) {
+    if (L->match(Label, DL->getInlinedAt(), Idx))
+      return L.get();
+  }
+
+  userLabels.push_back(llvm::make_unique<UserLabel>(Label, DL, Idx));
+  UserLabel *UL = userLabels.back().get();
+  return UL;
+}
+
 void LDVImpl::mapVirtReg(unsigned VirtReg, UserValue *EC) {
   assert(TargetRegisterInfo::isVirtualRegister(VirtReg) && "Only map VirtRegs");
   UserValue *&Leader = virtRegToEqClass[VirtReg];
   Leader = UserValue::merge(Leader, EC);
 }
 
 UserValue *LDVImpl::lookupVirtReg(unsigned VirtReg) {
   if (UserValue *UV = virtRegToEqClass.lookup(VirtReg))
bool LDVImpl::handleDebugValue(MachineInstr &MI, SlotIndex Idx) {
   else {
     MachineOperand MO = MachineOperand::CreateReg(0U, false);
     MO.setIsDebug();
     UV->addDef(Idx, MO, false);
   }
   return true;
 }
 
+bool LDVImpl::handleDebugLabel(MachineInstr &MI, SlotIndex Idx) {
+  // DBG_LABEL label
+  if (MI.getNumOperands() != 1 || !MI.getOperand(0).isMetadata()) {
+    LLVM_DEBUG(dbgs() << "Can't handle " << MI);
+    return false;
+  }
+
+  // Get or create the UserLabel for label here.
+  const DILabel *Label = MI.getDebugLabel();
+  getUserLabel(Label, MI.getDebugLoc(), Idx);
+  return true;
+}
+
 bool LDVImpl::collectDebugValues(MachineFunction &mf) {
   bool Changed = false;
   for (MachineFunction::iterator MFI = mf.begin(), MFE = mf.end(); MFI != MFE;
        ++MFI) {
     MachineBasicBlock *MBB = &*MFI;
     for (MachineBasicBlock::iterator MBBI = MBB->begin(), MBBE = MBB->end();
          MBBI != MBBE;) {
       // Use the first debug instruction in the sequence to get a SlotIndex
       // for following consecutive debug instructions.
       if (!MBBI->isDebugInstr()) {
         ++MBBI;
         continue;
       }
       // Debug instructions has no slot index. Use the previous
       // non-debug instruction's SlotIndex as its SlotIndex.
       SlotIndex Idx =
           MBBI == MBB->begin()
               ? LIS->getMBBStartIdx(MBB)
               : LIS->getInstructionIndex(*std::prev(MBBI)).getRegSlot();
       // Handle consecutive debug instructions with the same slot index.
       do {
         // Only handle DBG_VALUE in handleDebugValue(). Skip all other
         // kinds of debug instructions.
-        if (MBBI->isDebugValue() && handleDebugValue(*MBBI, Idx)) {
+        if ((MBBI->isDebugValue() && handleDebugValue(*MBBI, Idx)) ||
+            (MBBI->isDebugLabel() && handleDebugLabel(*MBBI, Idx))) {
           MBBI = MBB->erase(MBBI);
           Changed = true;
         } else
           ++MBBI;
       } while (MBBI != MBBE && MBBI->isDebugInstr());
     }
   }
   return Changed;
BuildMI(*MBB, I, getDebugLoc(), TII.get(TargetOpcode::DBG_VALUE),
             IsIndirect, MO, Variable, Expr);
 
     // 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,
+                                 LiveIntervals &LIS,
+                                 const TargetInstrInfo &TII) {
+  MachineBasicBlock::iterator I = findInsertLocation(MBB, Idx, LIS);
+  ++NumInsertedDebugLabels;
+  BuildMI(*MBB, I, getDebugLoc(), TII.get(TargetOpcode::DBG_LABEL))
+      .addMetadata(Label);
+}
+
 void UserValue::emitDebugValues(VirtRegMap *VRM, LiveIntervals &LIS,
                                 const TargetInstrInfo &TII,
                                 const TargetRegisterInfo &TRI,
                                 const SpillOffsetMap &SpillOffsets) {
   MachineFunction::iterator MFEnd = VRM->getMachineFunction().end();
 
   for (LocMap::const_iterator I = locInts.begin(); I.valid();) {
     SlotIndex Start = I.start();
for (LocMap::const_iterator I = locInts.begin(); I.valid();) {
     LLVM_DEBUG(dbgs() << '\n');
     if (MBB == MFEnd)
       break;
 
     ++I;
   }
 }
 
+void UserLabel::emitDebugLabels(LiveIntervals &LIS,
+                                const TargetInstrInfo &TII) {
+  LLVM_DEBUG(dbgs() << "\t" << loc);
+  MachineFunction::iterator MBB = LIS.getMBBFromIndex(loc)->getIterator();
+
+  LLVM_DEBUG(dbgs() << ' ' << printMBBReference(*MBB));
+  insertDebugLabel(&*MBB, loc, LIS, TII);
+
+  LLVM_DEBUG(dbgs() << '\n');
+}
+
 void LDVImpl::emitDebugValues(VirtRegMap *VRM) {
   LLVM_DEBUG(dbgs() << "********** EMITTING LIVE DEBUG VARIABLES **********\n");
   if (!MF)
     return;
   const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
   SpillOffsetMap SpillOffsets;
   for (unsigned i = 0, e = userValues.size(); i != e; ++i) {
     LLVM_DEBUG(userValues[i]->print(dbgs(), TRI));
     userValues[i]->rewriteLocations(*VRM, *MF, *TII, *TRI, SpillOffsets);
     userValues[i]->emitDebugValues(VRM, *LIS, *TII, *TRI, SpillOffsets);
   }
+  LLVM_DEBUG(dbgs() << "********** EMITTING LIVE DEBUG LABELS **********\n");
+  for (unsigned i = 0, e = userLabels.size(); i != e; ++i) {
+    LLVM_DEBUG(userLabels[i]->print(dbgs(), TRI));
+    userLabels[i]->emitDebugLabels(*LIS, *TII);
+  }
   EmitDone = true;
 }
 
 void LiveDebugVariables::emitDebugValues(VirtRegMap *VRM) {
   if (pImpl)
     static_cast<LDVImpl*>(pImpl)->emitDebugValues(VRM);
 }
 

test/CodeGen/Generic/live-debug-label.ll

+; RUN: llc < %s -stop-after=virtregrewriter -o - | FileCheck %s
+;
+; CHECK-LABEL: {{^body:}}
+; CHECK-LABEL: bye.thread21:
+; CHECK: DBG_LABEL !14
+; CHECK-LABEL: if.then5:
+; CHECK: DBG_LABEL !14
+; CHECK-NOT: DBG_LABEL !14
+
+$_Z3barc = comdat any
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @_Z3fooPKciPi(i8* nocapture readonly %data, i32 %length, i32* nocapture %parsing_result) local_unnamed_addr !dbg !4 {
+entry:
+  %0 = load i8, i8* %data, align 1
+  %call23 = tail call zeroext i1 @_Z3barc(i8 signext %0), !dbg !15
+  br i1 %call23, label %while.body, label %while.end
+
+while.body:                                       ; preds = %entry, %while.body
+  %overflow.026 = phi i8 [ %spec.select18, %while.body ], [ 0, %entry ]
+  %result.025 = phi i32 [ %spec.select, %while.body ], [ 1, %entry ]
+  %value.024 = phi i32 [ %value.1, %while.body ], [ 0, %entry ]
+  %cmp = icmp ugt i32 %value.024, 1
+  %spec.select = select i1 %cmp, i32 2, i32 %result.025
+  %spec.select18 = select i1 %cmp, i8 1, i8 %overflow.026
+  %1 = and i8 %spec.select18, 1
+  %2 = xor i8 %1, 1
+  %3 = zext i8 %2 to i32
+  %value.1 = add i32 %value.024, %3
+  %4 = load i8, i8* %data, align 1
+  %call = tail call zeroext i1 @_Z3barc(i8 signext %4), !dbg !15
+  br i1 %call, label %while.body, label %while.end.loopexit
+
+while.end.loopexit:                               ; preds = %while.body
+  %phitmp = and i8 %spec.select18, 1
+  br label %while.end
+
+while.end:                                        ; preds = %while.end.loopexit, %entry
+  %value.0.lcssa = phi i32 [ 0, %entry ], [ %value.1, %while.end.loopexit ]
+  %result.0.lcssa = phi i32 [ 1, %entry ], [ %spec.select, %while.end.loopexit ]
+  %overflow.0.lcssa = phi i8 [ 0, %entry ], [ %phitmp, %while.end.loopexit ]
+  %cmp3 = icmp eq i32 %length, 0
+  %tobool4 = icmp ne i32 %value.0.lcssa, 0
+  %or.cond = or i1 %cmp3, %tobool4
+  br i1 %or.cond, label %if.then5, label %bye.thread21
+
+bye.thread21:                                     ; preds = %while.end
+  call void @llvm.dbg.label(metadata !14), !dbg !16
+  store i32 1, i32* %parsing_result, align 4
+  br label %6
+
+if.then5:                                         ; preds = %while.end
+  %tobool6 = icmp eq i8 %overflow.0.lcssa, 0
+  call void @llvm.dbg.label(metadata !14), !dbg !16
+  call void @llvm.dbg.label(metadata !14), !dbg !16
+  br i1 %tobool6, label %bye.thread, label %bye
+
+bye.thread:                                       ; preds = %if.then5
+  store i32 0, i32* %parsing_result, align 4
+  br label %5
+
+bye:                                              ; preds = %if.then5
+  store i32 %result.0.lcssa, i32* %parsing_result, align 4
+  %cmp10 = icmp eq i32 %result.0.lcssa, 0
+  br i1 %cmp10, label %5, label %6
+
+; <label>:5:                                      ; preds = %bye.thread, %bye
+  br label %6
+
+; <label>:6:                                      ; preds = %bye.thread21, %bye, %5
+  %7 = phi i32 [ %value.0.lcssa, %5 ], [ 0, %bye ], [ 0, %bye.thread21 ]
+  ret i32 %7
+}
+
+; Function Attrs: inlinehint nounwind uwtable
+define linkonce_odr dso_local zeroext i1 @_Z3barc(i8 signext %c) local_unnamed_addr comdat {
+entry:
+  %c.off = add i8 %c, -48
+  %0 = icmp ult i8 %c.off, 10
+  ret i1 %0
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.label(metadata) #0
+
+attributes #0 = { nounwind readnone speculatable }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "live-debug-label.cc", directory: ".")
+!2 = !{}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = distinct !DISubprogram(name: "foo", linkageName: "_Z3fooPKciPi", scope: !1, file: !1, line: 5, type: !5, isLocal: false, isDefinition: true, scopeLine: 7, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !13)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7, !8, !11, !12}
+!7 = !DIBasicType(name: "unsigned int", size: 32, encoding: DW_ATE_unsigned)
+!8 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !9, size: 64)
+!9 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !10)
+!10 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
+!13 = !{!14}
+!14 = !DILabel(scope: !4, name: "bye", file: !1, line: 28)
+!15 = !DILocation(line: 12, column: 10, scope: !4)
+!16 = !DILocation(line: 28, column: 1, scope: !4)