Update getMergedLocation to check the instruction type and merge properly.

[danielcdh]

Summary

If the merged instruction is call instruction, we need to set the scope to the closes common scope between 2 locations, otherwise it will cause trouble when the call is getting inlined.

[dblaikie]

include/llvm/IR/DebugInfoMetadata.h

1434–1435

Perhaps the API should change to be less error prone (so it's not the responsibility of the caller to know to pass the Instruction if it might be a call).

Could this be "applyMergedLocation" and have it take the Instruction as the first parameter & modify its debug location in place? (are there callers that don't have the destination Instruction on-hand at the point where they want to make this call?)

lib/IR/DebugInfo.cpp

680–687

I'd expect to walk more than the inlined-at attributes, but the plain scopes too. Which should look something like "keep calling getScope until it returns null, then use getInlinedAt, then go back to walking scopes, etc, until getInlinedAt returns null".

Probably not as important/necessary, but could still help smooth out debug_ranges which cost a bunch of debug info size.

test/Transforms/SimplifyCFG/remove-debug.ll

4–5

Might be worth checking the specific instructions that these lines apply to?

[danielcdh]

include/llvm/IR/DebugInfoMetadata.h

1434–1435

We will also have MachineInstruction to call this.

lib/IR/DebugInfo.cpp

680–687

Not sure if I understand... why would walking scopes help? And also, the case for merged call should be very rare, may not have big impact on overall size?

[danielcdh]

update test

[aprantl]

Just wanted to say that I like the direction this is going and LGTM from my side once you sorted out the details David mentioned.

[danielcdh]

include/llvm/IR/DebugInfoMetadata.h

1434–1435

Updated the API:

MachineInstruction should use the original API
Instruction should use the new API to pass in the Instruction *

lib/IR/DebugInfo.cpp

680–687

Discussed offline with David. It is an overkill to add another level of complexity to traverse Scope chain because

• it will not either help the user of the tool (the purpose of merge location is to prevent "wrong location" to be the "right location", not to get the right location, which is impossible to get anyway.
• it will not affect debug info size much: our experiments on a very large binary shows that it only has 0.00008% impact on the debug_line size and 0.00003% impact on the debug_info size.

[danielcdh]

update the API

[dblaikie]

Looks good, thanks!

Adrian - dunno what you think about the API changes here. Open to iterating (probably just post-commit) if you reckon this doesn't add enough, or have other ideas.

lib/Transforms/Utils/SimplifyCFG.cpp

1541

This probably needs a similar assert/comment that I0 isn't a CallInst?

[aprantl]

I think this works for me.

include/llvm/IR/DebugInfoMetadata.h

1430

it has ?

1435

Please add something like /// See documentation of \p getMergedLocation.

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

1436

Sorry, one more thing: Why is this a static function instead of a member?

[danielcdh]

include/llvm/IR/DebugInfoMetadata.h

1436

Moved the API to Instruction::applyMergedLocation.

[danielcdh]

update

[aprantl]

Looks mostly good now. One more inline comment.

include/llvm/IR/Instruction.h

391

Should we document what happens to the debug location already attached to this? Or - looking at the use-cases - should it assert that the debugloc is empty?

[danielcdh]

include/llvm/IR/Instruction.h

391

Not sure if I understand this. this->debugloc will be either empty, or locA or locB. But it will be overwritten anyway, why do we care about its value?

[danielcdh]

ping...

Adrian, please let me know if you have further concerns about this patch.

Thanks,
Dehao

[aprantl]

LGTM, I would add one extra line to the comment of applyMergedLocation (see inline).
Thanks!

include/llvm/IR/DebugInfoMetadata.h

1428

I think if we spell this as \p applyMergedLocation it gets turned into a link by Doxygen, might be worth trying.

include/llvm/IR/Instruction.h

391

I was thinking of adding an extra line like to make the behavior clear to the casual reader:
/// The DebugLoc attached to this instruction will be overwritten by the merged DebugLoc.

[danielcdh]

update comments

include/llvm/IR/DebugInfoMetadata.h

public:
   /// need to combine the original locations into a single location.
   ///
   /// When the locations are the same we can use either location. When they
   /// differ, we need a third location which is distinct from either. If
   /// they have the same file/line but have a different discriminator we
   /// could create a location with a new discriminator. If they are from
   /// different files/lines the location is ambiguous and can't be
   /// represented in a single line entry.  In this case, no location
-  /// should be set.
-  ///
-  /// Currently the function does not create a new location. If the locations
-  /// are the same, or cannot be discriminated, the first location is returned.
-  /// Otherwise an empty location will be used.
+  /// should be set, unless the merged instruction is a call, which we will
+  /// set the merged debug location as line 0 of the nearest common scope
+  /// where 2 locations are inlined from. This only applies to Instruction,
+  /// For MachineInstruction, as it is post-inline, we will treat the call
+  /// instruction the same way as other instructions.
+  ///
+  /// This should only be used by MachineInstruction because call can be
+  /// treated the same as other instructions. Otherwise, use
+  /// \p applyMergedLocation instead.
   static const DILocation *getMergedLocation(const DILocation *LocA,
                                              const DILocation *LocB) {
     if (LocA && LocB && (LocA == LocB || !LocA->canDiscriminate(*LocB)))
       return LocA;
     return nullptr;
   }
 
   /// Returns the base discriminator for a given encoded discriminator \p D.
   static unsigned getBaseDiscriminatorFromDiscriminator(unsigned D) {
     if ((D & 1) == 0)
       return getUnsignedFromPrefixEncoding(D >> 1);
     else
       return 0;
   }
 
   /// Returns the duplication factor for a given encoded discriminator \p D.

include/llvm/IR/Instruction.h

public:
   /// Convenience method to copy supported exact, fast-math, and (optionally)
   /// wrapping flags from V to this instruction.
   void copyIRFlags(const Value *V, bool IncludeWrapFlags = true);
 
   /// Logical 'and' of any supported wrapping, exact, and fast-math flags of
   /// V and this instruction.
   void andIRFlags(const Value *V);
 
+  /// Merge 2 debug locations and apply it to the Instruction. If the
+  /// instruction is a CallIns, we need to traverse the inline chain to find
+  /// the common scope. This is not efficient for N-way merging as each time
+  /// you merge 2 iterations, you need to rebuild the hashmap to find the
+  /// common scope. However, we still choose this API because:
+  ///  1) Simplicity: it takes 2 locations instead of a list of locations.
+  ///  2) In worst case, it increases the complexity from O(N*I) to
+  ///     O(2*N*I), where N is # of Instructions to merge, and I is the
+  ///     maximum level of inline stack. So it is still linear.
+  ///  3) Merging of call instructions should be extremely rare in real
+  ///     applications, thus the N-way merging should be in code path.
+  /// The DebugLoc attached to this instruction will be overwritten by the
+  /// merged DebugLoc.
+  void applyMergedLocation(const DILocation *LocA, const DILocation *LocB);
+
 private:
   /// Return true if we have an entry in the on-the-side metadata hash.
   bool hasMetadataHashEntry() const {
     return (getSubclassDataFromValue() & HasMetadataBit) != 0;
   }
 
   // These are all implemented in Metadata.cpp.
   MDNode *getMetadataImpl(unsigned KindID) const;

lib/IR/DebugInfo.cpp

 }
 
 unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
   if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
           M.getModuleFlag("Debug Info Version")))
     return Val->getZExtValue();
   return 0;
 }
+
+void Instruction::applyMergedLocation(const DILocation *LocA,
+                                      const DILocation *LocB) {
+  if (LocA && LocB && (LocA == LocB || !LocA->canDiscriminate(*LocB))) {
+    setDebugLoc(LocA);
+    return;
+  }
+  if (!LocA || !LocB || !isa<CallInst>(this)) {
+    setDebugLoc(nullptr);
+    return;
+  }
+  SmallPtrSet<DILocation *, 5> InlinedLocationsA;
+  for (DILocation *L = LocA->getInlinedAt(); L; L = L->getInlinedAt())
+    InlinedLocationsA.insert(L);
+  const DILocation *Result = LocB;
+  for (DILocation *L = LocB->getInlinedAt(); L; L = L->getInlinedAt()) {
+    Result = L;
+    if (InlinedLocationsA.count(L))
+      break;
+  }
+  setDebugLoc(DILocation::get(
+      Result->getContext(), 0, 0, Result->getScope(), Result->getInlinedAt()));
+}

lib/Transforms/IPO/FunctionImport.cpp

for (auto &S : Entry.second.SummaryList)
         Worklist.push_back(ValueInfo(&Entry));
         ++LiveSymbols;
         break;
       }
 
   // Make value live and add it to the worklist if it was not live before.
   // FIXME: we should only make the prevailing copy live here
   auto visit = [&](ValueInfo VI) {
+    for (auto &S : VI.getSummaryList())
+      S->setLive(true);
+    ++LiveSymbols;
+    Worklist.push_back(VI);
     // FIXME: If we knew which edges were created for indirect call profiles,
     // we could skip them here. Any that are live should be reached via
     // other edges, e.g. reference edges. Otherwise, using a profile collected
     // on a slightly different binary might provoke preserving, importing
     // and ultimately promoting calls to functions not linked into this
     // binary, which increases the binary size unnecessarily. Note that
     // if this code changes, the importer needs to change so that edges
     // to functions marked dead are skipped.

lib/Transforms/InstCombine/InstCombineInternal.h

private:
   /// \brief Try to rotate an operation below a PHI node, using PHI nodes for
   /// its operands.
   Instruction *FoldPHIArgOpIntoPHI(PHINode &PN);
   Instruction *FoldPHIArgBinOpIntoPHI(PHINode &PN);
   Instruction *FoldPHIArgGEPIntoPHI(PHINode &PN);
   Instruction *FoldPHIArgLoadIntoPHI(PHINode &PN);
   Instruction *FoldPHIArgZextsIntoPHI(PHINode &PN);
 
-  /// Helper function for FoldPHIArgXIntoPHI() to get debug location for the
+  /// Helper function for FoldPHIArgXIntoPHI() to set debug location for the
   /// folded operation.
-  DebugLoc PHIArgMergedDebugLoc(PHINode &PN);
+  void PHIArgMergedDebugLoc(Instruction *Inst, PHINode &PN);
 
   Instruction *foldGEPICmp(GEPOperator *GEPLHS, Value *RHS,
                            ICmpInst::Predicate Cond, Instruction &I);
   Instruction *foldAllocaCmp(ICmpInst &ICI, const AllocaInst *Alloca,
                              const Value *Other);
   Instruction *foldCmpLoadFromIndexedGlobal(GetElementPtrInst *GEP,
                                             GlobalVariable *GV, CmpInst &ICI,
                                             ConstantInt *AndCst = nullptr);

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

bool InstCombiner::SimplifyStoreAtEndOfBlock(StoreInst &SI) {
   BBI = DestBB->getFirstInsertionPt();
   StoreInst *NewSI = new StoreInst(MergedVal, SI.getOperand(1),
                                    SI.isVolatile(),
                                    SI.getAlignment(),
                                    SI.getOrdering(),
                                    SI.getSyncScopeID());
   InsertNewInstBefore(NewSI, *BBI);
   // The debug locations of the original instructions might differ; merge them.
-  NewSI->setDebugLoc(DILocation::getMergedLocation(SI.getDebugLoc(),
-                                                   OtherStore->getDebugLoc()));
+  NewSI->applyMergedLocation(SI.getDebugLoc(), OtherStore->getDebugLoc());
 
   // If the two stores had AA tags, merge them.
   AAMDNodes AATags;
   SI.getAAMetadata(AATags);
   if (AATags) {
     OtherStore->getAAMetadata(AATags, /* Merge = */ true);
     NewSI->setAAMetadata(AATags);
   }
 
   // Nuke the old stores.
   eraseInstFromFunction(SI);
   eraseInstFromFunction(*OtherStore);
   return true;
 }

lib/Transforms/InstCombine/InstCombinePHI.cpp

 using namespace llvm;
 using namespace llvm::PatternMatch;
 
 #define DEBUG_TYPE "instcombine"
 
 /// The PHI arguments will be folded into a single operation with a PHI node
 /// as input. The debug location of the single operation will be the merged
 /// locations of the original PHI node arguments.
-DebugLoc InstCombiner::PHIArgMergedDebugLoc(PHINode &PN) {
+void InstCombiner::PHIArgMergedDebugLoc(Instruction *Inst, PHINode &PN) {
   auto *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
-  const DILocation *Loc = FirstInst->getDebugLoc();
+  Inst->setDebugLoc(FirstInst->getDebugLoc());
+  // We do not expect a CallInst here, otherwise, N-way merging of DebugLoc
+  // will be inefficient.
+  assert(!isa<CallInst>(Inst));
 
   for (unsigned i = 1; i != PN.getNumIncomingValues(); ++i) {
     auto *I = cast<Instruction>(PN.getIncomingValue(i));
-    Loc = DILocation::getMergedLocation(Loc, I->getDebugLoc());
+    Inst->applyMergedLocation(Inst->getDebugLoc(), I->getDebugLoc());
   }
-
-  return Loc;
 }
 
 /// If we have something like phi [add (a,b), add(a,c)] and if a/b/c and the
 /// adds all have a single use, turn this into a phi and a single binop.
 Instruction *InstCombiner::FoldPHIArgBinOpIntoPHI(PHINode &PN) {
   Instruction *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
   assert(isa<BinaryOperator>(FirstInst) || isa<CmpInst>(FirstInst));
   unsigned Opc = FirstInst->getOpcode();
for (unsigned i = 1, e = PN.getNumIncomingValues(); i != e; ++i) {
         NewRHS->addIncoming(NewInRHS, PN.getIncomingBlock(i));
       }
     }
   }
 
   if (CmpInst *CIOp = dyn_cast<CmpInst>(FirstInst)) {
     CmpInst *NewCI = CmpInst::Create(CIOp->getOpcode(), CIOp->getPredicate(),
                                      LHSVal, RHSVal);
-    NewCI->setDebugLoc(PHIArgMergedDebugLoc(PN));
+    PHIArgMergedDebugLoc(NewCI, PN);
     return NewCI;
   }
 
   BinaryOperator *BinOp = cast<BinaryOperator>(FirstInst);
   BinaryOperator *NewBinOp =
     BinaryOperator::Create(BinOp->getOpcode(), LHSVal, RHSVal);
 
   NewBinOp->copyIRFlags(PN.getIncomingValue(0));
 
   for (unsigned i = 1, e = PN.getNumIncomingValues(); i != e; ++i)
     NewBinOp->andIRFlags(PN.getIncomingValue(i));
 
-  NewBinOp->setDebugLoc(PHIArgMergedDebugLoc(PN));
+  PHIArgMergedDebugLoc(NewBinOp, PN);
   return NewBinOp;
 }
 
 Instruction *InstCombiner::FoldPHIArgGEPIntoPHI(PHINode &PN) {
   GetElementPtrInst *FirstInst =cast<GetElementPtrInst>(PN.getIncomingValue(0));
 
   SmallVector<Value*, 16> FixedOperands(FirstInst->op_begin(),
                                         FirstInst->op_end());
if (HasAnyPHIs) {
     }
   }
 
   Value *Base = FixedOperands[0];
   GetElementPtrInst *NewGEP =
       GetElementPtrInst::Create(FirstInst->getSourceElementType(), Base,
                                 makeArrayRef(FixedOperands).slice(1));
   if (AllInBounds) NewGEP->setIsInBounds();
-  NewGEP->setDebugLoc(PHIArgMergedDebugLoc(PN));
+  PHIArgMergedDebugLoc(NewGEP, PN);
   return NewGEP;
 }
 
 
 /// Return true if we know that it is safe to sink the load out of the block
 /// that defines it. This means that it must be obvious the value of the load is
 /// not changed from the point of the load to the end of the block it is in.
 ///
Instruction *InstCombiner::FoldPHIArgLoadIntoPHI(PHINode &PN) {
 
   // If this was a volatile load that we are merging, make sure to loop through
   // and mark all the input loads as non-volatile.  If we don't do this, we will
   // insert a new volatile load and the old ones will not be deletable.
   if (isVolatile)
     for (Value *IncValue : PN.incoming_values())
       cast<LoadInst>(IncValue)->setVolatile(false);
 
-  NewLI->setDebugLoc(PHIArgMergedDebugLoc(PN));
+  PHIArgMergedDebugLoc(NewLI, PN);
   return NewLI;
 }
 
 /// TODO: This function could handle other cast types, but then it might
 /// require special-casing a cast from the 'i1' type. See the comment in
 /// FoldPHIArgOpIntoPHI() about pessimizing illegal integer types.
 Instruction *InstCombiner::FoldPHIArgZextsIntoPHI(PHINode &Phi) {
   // We cannot create a new instruction after the PHI if the terminator is an
if (InVal) {
     InsertNewInstBefore(NewPN, PN);
     PhiVal = NewPN;
   }
 
   // Insert and return the new operation.
   if (CastInst *FirstCI = dyn_cast<CastInst>(FirstInst)) {
     CastInst *NewCI = CastInst::Create(FirstCI->getOpcode(), PhiVal,
                                        PN.getType());
-    NewCI->setDebugLoc(PHIArgMergedDebugLoc(PN));
+    PHIArgMergedDebugLoc(NewCI, PN);
     return NewCI;
   }
 
   if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(FirstInst)) {
     BinOp = BinaryOperator::Create(BinOp->getOpcode(), PhiVal, ConstantOp);
     BinOp->copyIRFlags(PN.getIncomingValue(0));
 
     for (unsigned i = 1, e = PN.getNumIncomingValues(); i != e; ++i)
       BinOp->andIRFlags(PN.getIncomingValue(i));
 
-    BinOp->setDebugLoc(PHIArgMergedDebugLoc(PN));
+    PHIArgMergedDebugLoc(BinOp, PN);
     return BinOp;
   }
 
   CmpInst *CIOp = cast<CmpInst>(FirstInst);
   CmpInst *NewCI = CmpInst::Create(CIOp->getOpcode(), CIOp->getPredicate(),
                                    PhiVal, ConstantOp);
-  NewCI->setDebugLoc(PHIArgMergedDebugLoc(PN));
+  PHIArgMergedDebugLoc(NewCI, PN);
   return NewCI;
 }
 
 /// Return true if this PHI node is only used by a PHI node cycle that is dead.
 static bool DeadPHICycle(PHINode *PN,
                          SmallPtrSetImpl<PHINode*> &PotentiallyDeadPHIs) {
   if (PN->use_empty()) return true;
   if (!PN->hasOneUse()) return false;

lib/Transforms/Utils/SimplifyCFG.cpp

unsigned KnownIDs[] = {LLVMContext::MD_tbaa,
                            LLVMContext::MD_align,
                            LLVMContext::MD_dereferenceable,
                            LLVMContext::MD_dereferenceable_or_null,
                            LLVMContext::MD_mem_parallel_loop_access};
     combineMetadata(I1, I2, KnownIDs);
 
     // I1 and I2 are being combined into a single instruction.  Its debug
     // location is the merged locations of the original instructions.
-    if (!isa<CallInst>(I1))
-      I1->setDebugLoc(
-          DILocation::getMergedLocation(I1->getDebugLoc(), I2->getDebugLoc()));
+    I1->applyMergedLocation(I1->getDebugLoc(), I2->getDebugLoc());
 
     I2->eraseFromParent();
     Changed = true;
 
     I1 = &*BB1_Itr++;
     I2 = &*BB2_Itr++;
     // Skip debug info if it is not identical.
     DbgInfoIntrinsic *DBI1 = dyn_cast<DbgInfoIntrinsic>(I1);
static bool sinkLastInstruction(ArrayRef<BasicBlock*> Blocks) {
   }
 
   // Arbitrarily use I0 as the new "common" instruction; remap its operands
   // and move it to the start of the successor block.
   for (unsigned O = 0, E = I0->getNumOperands(); O != E; ++O)
     I0->getOperandUse(O).set(NewOperands[O]);
   I0->moveBefore(&*BBEnd->getFirstInsertionPt());
 
-  // The debug location for the "common" instruction is the merged locations of
-  // all the commoned instructions.  We start with the original location of the
-  // "common" instruction and iteratively merge each location in the loop below.
-  const DILocation *Loc = I0->getDebugLoc();
-
   // Update metadata and IR flags, and merge debug locations.
   for (auto *I : Insts)
     if (I != I0) {
-      Loc = DILocation::getMergedLocation(Loc, I->getDebugLoc());
+      // The debug location for the "common" instruction is the merged locations
+      // of all the commoned instructions.  We start with the original location
+      // of the "common" instruction and iteratively merge each location in the
+      // loop below.
+      // This is an N-way merge, which will be inefficient if I0 is a CallInst.
+      // However, as N-way merge for CallInst is rare, so we use simplified API
+      // instead of using complex API for N-way merge.
+      I0->applyMergedLocation(I0->getDebugLoc(), I->getDebugLoc());
       combineMetadataForCSE(I0, I);
       I0->andIRFlags(I);
     }
-  if (!isa<CallInst>(I0))
-    I0->setDebugLoc(Loc);
 
   if (!isa<StoreInst>(I0)) {
     // canSinkLastInstruction checked that all instructions were used by
     // one and only one PHI node. Find that now, RAUW it to our common
     // instruction and nuke it.
     assert(I0->hasOneUse());
     auto *PN = cast<PHINode>(*I0->user_begin());
     PN->replaceAllUsesWith(I0);
if (SpeculatedStoreValue) {
     IRBuilder<NoFolder> Builder(BI);
     Value *TrueV = SpeculatedStore->getValueOperand();
     Value *FalseV = SpeculatedStoreValue;
     if (Invert)
       std::swap(TrueV, FalseV);
     Value *S = Builder.CreateSelect(
         BrCond, TrueV, FalseV, TrueV->getName() + "." + FalseV->getName(), BI);
     SpeculatedStore->setOperand(0, S);
-    SpeculatedStore->setDebugLoc(
-        DILocation::getMergedLocation(
-          BI->getDebugLoc(), SpeculatedStore->getDebugLoc()));
+    SpeculatedStore->applyMergedLocation(BI->getDebugLoc(),
+                                         SpeculatedStore->getDebugLoc());
   }
 
   // Metadata can be dependent on the condition we are hoisting above.
   // Conservatively strip all metadata on the instruction.
   for (auto &I : *ThenBB)
     I.dropUnknownNonDebugMetadata();
 
   // Hoist the instructions.

test/Transforms/SimplifyCFG/remove-debug.ll

 ; RUN: opt < %s -simplifycfg -S | FileCheck %s
 
 ; TODO: Track the acutal DebugLoc of the hoisted instruction when no-line
 ; DebugLoc is supported (https://reviews.llvm.org/D24180)
-; CHECK: line: 6
-; CHECK-NOT: line: 7
-; CHECK: line: 8
-; CHECK: line: 9
-; CHECK-NOT: line: 10
-; CHECK: line: 11
 
-; Checks if the debug info for hoisted "x = i" is removed
+; Checks if the debug info for hoisted "x = i" is removed and
+; the debug info for hoisted "bar()" is set as line 0
 ; int x;
 ; void bar();
 ; void baz();
 ;
 ; void foo(int i) {
 ;   if (i == 0) {
 ;     x = i;
 ;     bar();
 ;   } else {
 ;     x = i;
+;     bar();
 ;     baz();
 ;   }
 ; }
 
 target triple = "x86_64-unknown-linux-gnu"
 
 @x = global i32 0, align 4
 
 ; Function Attrs: uwtable
 define void @_Z3fooi(i32) #0 !dbg !6 {
+; CHECK: load i32, i32* %2, align 4, !tbaa
+; CHECK: store i32 %5, i32* @x, align 4, !tbaa
+; CHECK: call void @_Z3barv(), !dbg ![[BAR:[0-9]+]]
+; CHECK: call void @_Z3bazv(), !dbg ![[BAZ:[0-9]+]]
   %2 = alloca i32, align 4
   store i32 %0, i32* %2, align 4, !tbaa !8
   %3 = load i32, i32* %2, align 4, !dbg !12, !tbaa !8
   %4 = icmp eq i32 %3, 0, !dbg !13
   br i1 %4, label %5, label %7, !dbg !12
 
 ; <label>:5:
   %6 = load i32, i32* %2, align 4, !dbg !14, !tbaa !8
   store i32 %6, i32* @x, align 4, !dbg !15, !tbaa !8
   call void @_Z3barv(), !dbg !16
   br label %9, !dbg !17
 
 ; <label>:7:
   %8 = load i32, i32* %2, align 4, !dbg !18, !tbaa !8
   store i32 %8, i32* @x, align 4, !dbg !19, !tbaa !8
-  call void @_Z3bazv(), !dbg !20
+  call void @_Z3barv(), !dbg !20
+  call void @_Z3bazv(), !dbg !21
   br label %9
 
 ; <label>:9:
   ret void, !dbg !21
 }
 
 declare void @_Z3barv() #1
 
 declare void @_Z3bazv() #1
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4}
 
+; CHECK: ![[BAR]] = !DILocation(line: 0
+; CHECK: ![[BAZ]] = !DILocation(line: 12, column: 5
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1)
 !1 = !DIFile(filename: "a", directory: "b/")
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{}
 !6 = distinct !DISubprogram(unit: !0)
 !7 = !DISubroutineType(types: !2)
 !8 = !{!9, !9, i64 0}
 !9 = !{!"int", !10, i64 0}
 !10 = !{!"omnipotent char", !11, i64 0}
 !11 = !{!"Simple C++ TBAA"}
 !12 = !DILocation(line: 6, column: 7, scope: !6)
 !13 = !DILocation(line: 6, column: 9, scope: !6)
 !14 = !DILocation(line: 7, column: 9, scope: !6)
 !15 = !DILocation(line: 7, column: 7, scope: !6)
 !16 = !DILocation(line: 8, column: 5, scope: !6)
 !17 = !DILocation(line: 9, column: 3, scope: !6)
 !18 = !DILocation(line: 10, column: 9, scope: !6)
 !19 = !DILocation(line: 10, column: 7, scope: !6)
 !20 = !DILocation(line: 11, column: 5, scope: !6)
-!21 = !DILocation(line: 13, column: 1, scope: !6)
+!21 = !DILocation(line: 12, column: 5, scope: !6)
+!22 = !DILocation(line: 14, column: 1, scope: !6)