[DebugInfo] Fix potential CU mismatch for attachRangesOrLowHighPC

[DianQK]

Summary

When a CU attaches some ranges for a subprogram or an inlined code, the CU should be that of the subprogram/inlined code that was emitted.
If not, then these emitted ranges will use the incorrect base of the CU in emitRangeList.

A reproducible example is:
When linking these two LLVM IRs, dsymutil will report no mapping for range or inconsistent range data warnings.

foo.swift

swift
import AppKit.NSLayoutConstraint

public class Foo {
    
    public var c: Int {
        get {
            Int(NSLayoutConstraint().constant)
        }
        set {
        }
    }

}

main.swift

swift
// no mapping for range
let f: Foo! = nil
// inconsistent range data
//let l: Foo = Foo()

I made an Xcode project for this example.

no-mapping-for-range.zip72 KBDownload

[dblaikie]

If we wanted to fix this whole class of errors, maybe it's time we moved most of the DIE creation operations back to DwarfDebug - and any unit-specific operations would then have to explicitly look up the right unit from the DIE before they could be used. This would reduce the chance of accidentally using the wrong unit? (it'd cause more unit lookups - which should only be walking up the DIE chain. - if we make sure every DIE is added to its parent early enough, which seems plausible)

I tried, for instance, removing the DwarfUnit lookup in getOrCreateSubprogramDIE where it calls applySubprogramAttributes and sinking that down into the places where it was needed - which was only, so far as test coverage would indicate, at the getOrCreateSourceID calls (since in LTO we do produce separate line tables for each CU - so looking up/adding the file name in the right CU is necessary). That then uncovered a few cases where that code was being used with un-parented DIEs - specifically imported entities and variables. I was able to add those to the right parents earlier with a few changes. https://reviews.llvm.org/P8297

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

450

Could you use static_cast<DwarfCompileUnit*>(SPDie->getUnit()) here, instead of DD->lookup? (looks like that's what getOrCreateSubprogramDIE does?

& maybe that's cheap enough to use up in the caller, and avoid having to thread the ContextCU up and down through this stack?

Maybe even just build that CU change into attachRangesOrLowHighPC the same way it's built into getOrCreateSubprogramDIE?

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

231

ContextCU should probably be passed by reference-to-pointer - since you've updated the two callers so they don't pass null, there's no need for the implementation to consider whether the caller might've passed null, I think?

Alternatively, I guess, the caller could perform the lookup again, since they got the DIE back as a result, right? Maybe that's better than threading this through all the construct* abstractions to get it back out again?

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2266

Guessing this addition is basically untested - could you add a Split DWARF test to cover this? (& verify that the test fails without these changes applied)

llvm/test/DebugInfo/Generic/cross-cu-inlining-ranges.ll

4

Maybe some more detailed description of the particular circumstances where it's difficult to attach to the right context/explains why this test has the features it has?

(does it need a global variable? Does that global variable need a non-trivial type (if the global variable's necessary, but maybe it could be "int" rather than a structure type?) there's quite a few calls (both all the calls to f in main, and multiple in foo)

& maybe a snippet of source code to help explain the situation?

& I'd still be curious if this can be reproduced with C or C++/clang produced IR - might be more generally explicable/understandable by LLVM developers who all work in C++ at least.

9–13

Any particular reason you need 5 calls rather than, say, 1?

[DianQK]

Update code

[DianQK]

In D136039#3861089, @dblaikie wrote:

If we wanted to fix this whole class of errors, maybe it's time we moved most of the DIE creation operations back to DwarfDebug - and any unit-specific operations would then have to explicitly look up the right unit from the DIE before they could be used. This would reduce the chance of accidentally using the wrong unit? (it'd cause more unit lookups - which should only be walking up the DIE chain. - if we make sure every DIE is added to its parent early enough, which seems plausible)

Thank you very much for your patient and detailed comments.
I think it's a good idea.

And I solved part of the problem. The rest may need more additional time (Maybe tomorrow? I'm not sure about my free time).

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

450

Probably not, after trying your patch, I can still find some cases in attachRangesOrLowHighPC where the unit does not exist. Maybe we need more changes?

And getUnit always return DwarfCompileUnit in attachRangesOrLowHighPC? I'm not quite sure about the logic here yet.

llvm/test/DebugInfo/Generic/cross-cu-inlining-ranges.ll

4

Thanks to cross-cu-inlining-2.ll, I did it! I have removed the global variable.

The global variable is used to ensure a fixed order of DIE creation.
(Just because I found this issue from the example of global variables.)

I'm not sure if this can be reproduced with C or C++/clang produced IR. (I'll try again later.)

9–13

I use this when debugging something. I deleted those.

[DianQK]

Add more detailed description for test

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

450

Probably not, after trying your patch, I can still find some cases in attachRangesOrLowHighPC where the unit does not exist. Maybe we need more changes?

But each of the places where it doesn't have a unit is a risk that it gets attached to the wrong thing, right? (but not a guaranteed bug, so yeah, maybe not the thing we should hold this all up on)

And getUnit always return DwarfCompileUnit in attachRangesOrLowHighPC? I'm not quite sure about the logic here yet.

Yeah, that should be fine - DwarfTypeUnits can't have address ranges, so anything we're attaching ranges to should be a CU.

In any case, could we still avoid all the DwarfCompileUnit *&ContextCU additions and have the caller in DwarfDebug::endFunctionImpl lookup the DwarfCompileUnit from the returned DIE the same way it's being done here ^? It'd avoid a lot of threading things back and forth through all these construct APIs?

657

Looks like some of these sites didn't get updated to

1053

This whole chain that takes the ContextCU by pointer (rather than ref to pointer) - as an input only parameter, probably doesn't neeed to be changed. It should probably call with ContextCU as this instead, eg: somewhere up the stack, it should be ContextCU->... insntead of otherCU->...(..., ContextCU);?

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2266

Ping here ^

2266–2267

Also, I think the right thing to do here is to call constructSubprogramScopeDIE on the ContextSkelCU maybe, rather than on SkelCU?

[DianQK]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

450

But each of the places where it doesn't have a unit is a risk that it gets attached to the wrong thing, right? (but not a guaranteed bug, so yeah, maybe not the thing we should hold this all up on)

Yeah, so even if it's not a bug, bug if any DIE can have a unit (add by parent chain?) after DIE::get(DIEValueAllocator, foo), any subsequent operations on the unit will be friendly. So for this change, maybe we can create another Diff?

Yeah, that should be fine - DwarfTypeUnits can't have address ranges, so anything we're attaching ranges to should be a CU.

Thanks for your explain.

In any case, could we still avoid all the DwarfCompileUnit *&ContextCU additions and have the caller in DwarfDebug::endFunctionImpl lookup the DwarfCompileUnit from the returned DIE the same way it's being done here ^? It'd avoid a lot of threading things back and forth through all these construct APIs?

I will try later.

657

DwarfCompileUnit &ContextCU? I'll give it a try.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2266

I didn't miss it here. (I just don't have time to double-check this. During the working day, I may only have an hour on this thing.)

Maybe I also need to understand how a Split DWARF would be different.

I can check all the "Done" checkboxes to determine if I've missed something.

[DianQK]

Remove ContextCU as an argument

[DianQK]

Mark something as completed.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

1021–1024

Hmm, I'm not following - can you help me understand why this got pulled out of updateSubprogramScopeDIE?

1022–1023

Could use auto here, since the type is explicit in the static_cast on the right hand side. Might make it fit in a single line.

[DianQK]

Use auto

[DianQK]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

1021–1024

I need get SPDie to get ContextCU before attachRangesOrLowHighPC.
The attachRangesOrLowHighPC call in updateSubprogramScopeDIE and later createAndAddScopeChildren.

Maybe I could use the following code:

DIE *SPDie = getOrCreateSubprogramDIE(Sub, includeMinimalInlineScopes());
auto *ContextCU = static_cast<DwarfCompileUnit *>(SPDie->getUnit());
DIE &ScopeDIE = ContextCU->updateSubprogramScopeDIE(Sub);

I tried. It fails at cross-cu-inlining-2.ll (maybe because call getOrCreateSubprogramDIE in different CU?).

Dwarf before the change is:

0x00000038:       DW_TAG_subprogram [5] * (0x0000002b)
                    DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000010 ".text")
                    DW_AT_high_pc [DW_FORM_data4]	(0x00000001)
                    DW_AT_frame_base [DW_FORM_exprloc]	(DW_OP_reg7 RSP)
                    DW_AT_name [DW_FORM_strp]	( .debug_str[0x00000036] = "bar")
                    DW_AT_decl_file [DW_FORM_data1]	("A.swift")
                    DW_AT_decl_line [DW_FORM_data1]	(21)
                    DW_AT_external [DW_FORM_flag_present]	(true)

After:

0x00000038:       DW_TAG_subprogram [5]   (0x0000002b)
                    DW_AT_name [DW_FORM_strp]	( .debug_str[0x00000036] = "bar")
                    DW_AT_decl_file [DW_FORM_data1]	("A.swift")
                    DW_AT_decl_line [DW_FORM_data1]	(21)
                    DW_AT_external [DW_FORM_flag_present]	(true)

0x0000003f:       DW_TAG_subprogram [6] * (0x0000002b)
                    DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000010 ".text")
                    DW_AT_high_pc [DW_FORM_data4]	(0x00000001)
                    DW_AT_frame_base [DW_FORM_exprloc]	(DW_OP_reg7 RSP)

I think it's ok. But the old version is better?

[dblaikie]

Looks good - thanks for your patience with the review.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

1021–1024

Right, the old version is better. It could be made to work. Something like this:

diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
index f2551e1f3419..b2fe2cf396e1 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
@@ -443,8 +443,14 @@ void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
 // and DW_AT_high_pc attributes. If there are global variables in this
 // scope then create and insert DIEs for these variables.
-DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP,
-                                                DIE *SPDie) {
+DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
+  DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
+  auto *ContextCU = static_cast<DwarfCompileUnit *>(SPDie->getUnit());
+  return ContextCU->updateSubprogramScopeDIEImpl(SP, SPDie);
+}
+
+DIE &DwarfCompileUnit::updateSubprogramScopeDIEImpl(const DISubprogram *SP, DIE *SPDie) {
+
   SmallVector<RangeSpan, 2> BB_List;
   // If basic block sections are on, ranges for each basic block section has
   // to be emitted separately.
@@ -1013,9 +1019,8 @@ sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) {
 
 DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
                                                    LexicalScope *Scope) {
-  DIE *SPDie = getOrCreateSubprogramDIE(Sub, includeMinimalInlineScopes());
-  auto *ContextCU = static_cast<DwarfCompileUnit *>(SPDie->getUnit());
-  DIE &ScopeDIE = ContextCU->updateSubprogramScopeDIE(Sub, SPDie);
+  DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
+  auto *ContextCU = static_cast<DwarfCompileUnit *>(ScopeDIE.getUnit());
 
   if (Scope) {
     assert(!Scope->getInlinedAt());
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
index 0b0d97e74bc4..d346c79b5f7b 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
@@ -191,7 +191,8 @@ public:
   /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
   /// variables in this scope then create and insert DIEs for these
   /// variables.
-  DIE &updateSubprogramScopeDIE(const DISubprogram *SP, DIE *SPDie);
+  DIE &updateSubprogramScopeDIE(const DISubprogram *SP);
+  DIE &updateSubprogramScopeDIEImpl(const DISubprogram *SP, DIE *D);
 
   void constructScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE);

But yeah, since this is the only caller, seems simpler to do it here as you've done. Thanks for walking me through it.

[DianQK]

Thank you very much for your help!

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

1021–1024

Thanks, I have a patch added a constructSubprogramScopeDIEImplused to reduce ContextCU using that was not published, Because I found some code add *Impl doing similar things.
But only two locations need ContextCU, so I removed this.

But why did I forget to use this on updateSubprogramScopeDIE? I'm being foolish.

[DianQK]

add *Impl

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

public:
   void addRange(RangeSpan Range);
 
   void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End);
 
   /// Find DIE for the given subprogram and attach appropriate
   /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
   /// variables in this scope then create and insert DIEs for these
   /// variables.
-  DIE &updateSubprogramScopeDIE(const DISubprogram *SP);
+  DIE &updateSubprogramScopeDIE(const DISubprogram *SP,
+                                DwarfCompileUnit **ContextCU);
 
-  void constructScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE);
+  void constructScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE,
+                         DwarfCompileUnit *ContextCU);
 
   /// A helper function to construct a RangeSpanList for a given
   /// lexical scope.
   void addScopeRangeList(DIE &ScopeDIE, SmallVector<RangeSpan, 2> Range);
 
   void attachRangesOrLowHighPC(DIE &D, SmallVector<RangeSpan, 2> Ranges);
 
   void attachRangesOrLowHighPC(DIE &D,
                                const SmallVectorImpl<InsnRange> &Ranges);
 
   /// This scope represents an inlined body of a function. Construct a
   /// DIE to represent this concrete inlined copy of the function.
-  DIE *constructInlinedScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE);
+  DIE *constructInlinedScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE,
+                                DwarfCompileUnit *ContextCU);
 
   /// Construct new DW_TAG_lexical_block for this scope and
   /// attach DW_AT_low_pc/DW_AT_high_pc labels.
   DIE *constructLexicalScopeDIE(LexicalScope *Scope);
 
   /// constructVariableDIE - Construct a DIE for the given DbgVariable.
   DIE *constructVariableDIE(DbgVariable &DV, bool Abstract = false);
 
   DIE *constructVariableDIE(DbgVariable &DV, const LexicalScope &Scope,
                             DIE *&ObjectPointer);
 
   /// Construct a DIE for the given DbgLabel.
   DIE *constructLabelDIE(DbgLabel &DL, const LexicalScope &Scope);
 
   void createBaseTypeDIEs();
 
   /// Construct a DIE for this subprogram scope.
-  DIE &constructSubprogramScopeDIE(const DISubprogram *Sub,
-                                   LexicalScope *Scope);
+  DIE &constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope,
+                                   DwarfCompileUnit **ContextCU);
 
-  DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
+  DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE,
+                                 DwarfCompileUnit *ContextCU);
 
   void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
 
   /// Whether to use the GNU analog for a DWARF5 tag, attribute, or location
   /// atom. Only applicable when emitting otherwise DWARF4-compliant debug info.
   bool useGNUAnalogForDwarf5Feature() const;
 
   /// This takes a DWARF 5 tag and returns it or a GNU analog.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

if (DD->getDwarfVersion() < 4)
     addLabelAddress(D, dwarf::DW_AT_high_pc, End);
   else
     addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
 }
 
 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
 // and DW_AT_high_pc attributes. If there are global variables in this
 // scope then create and insert DIEs for these variables.
-DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
+DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP,
+                                                DwarfCompileUnit **ContextCU) {
   DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
+  if (!*ContextCU) {
+    *ContextCU = DD->lookupCU(SPDie->getUnitDie());
+  }
 
   SmallVector<RangeSpan, 2> BB_List;
   // If basic block sections are on, ranges for each basic block section has
   // to be emitted separately.
   for (const auto &R : Asm->MBBSectionRanges)
     BB_List.push_back({R.second.BeginLabel, R.second.EndLabel});
 
-  attachRangesOrLowHighPC(*SPDie, BB_List);
+  (*ContextCU)->attachRangesOrLowHighPC(*SPDie, BB_List);
 
   if (DD->useAppleExtensionAttributes() &&
       !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
           *DD->getCurrentFunction()))
     addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
 
   // Only include DW_AT_frame_base in full debug info
   if (!includeMinimalInlineScopes()) {
DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP,
   // to have concrete versions of our DW_TAG_subprogram nodes.
   DD->addSubprogramNames(*CUNode, SP, *SPDie);
 
   return *SPDie;
 }
 
 // Construct a DIE for this scope.
 void DwarfCompileUnit::constructScopeDIE(LexicalScope *Scope,
-                                         DIE &ParentScopeDIE) {
+                                         DIE &ParentScopeDIE,
+                                         DwarfCompileUnit *ContextCU) {
   if (!Scope || !Scope->getScopeNode())
     return;
 
   auto *DS = Scope->getScopeNode();
 
   assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
          "Only handle inlined subprograms here, use "
          "constructSubprogramScopeDIE for non-inlined "
          "subprograms");
 
   // Emit inlined subprograms.
   if (Scope->getParent() && isa<DISubprogram>(DS)) {
-    DIE *ScopeDIE = constructInlinedScopeDIE(Scope, ParentScopeDIE);
+    DIE *ScopeDIE = constructInlinedScopeDIE(Scope, ParentScopeDIE, ContextCU);
     assert(ScopeDIE && "Scope DIE should not be null.");
-    createAndAddScopeChildren(Scope, *ScopeDIE);
+    createAndAddScopeChildren(Scope, *ScopeDIE, ContextCU);
     return;
   }
 
   // Early exit when we know the scope DIE is going to be null.
   if (DD->isLexicalScopeDIENull(Scope))
     return;
 
   // Emit lexical blocks.
   DIE *ScopeDIE = constructLexicalScopeDIE(Scope);
   assert(ScopeDIE && "Scope DIE should not be null.");
 
   ParentScopeDIE.addChild(ScopeDIE);
-  createAndAddScopeChildren(Scope, *ScopeDIE);
+  createAndAddScopeChildren(Scope, *ScopeDIE, ContextCU);
 }
 
 void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
                                          SmallVector<RangeSpan, 2> Range) {
 
   HasRangeLists = true;
 
   // Add the range list to the set of ranges to be emitted.
do {
         break;
       MBB = MBB->getNextNode();
     } while (true);
   }
   attachRangesOrLowHighPC(Die, std::move(List));
 }
 
 DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope,
-                                                DIE &ParentScopeDIE) {
+                                                DIE &ParentScopeDIE,
+                                                DwarfCompileUnit *ContextCU) {
   assert(Scope->getScopeNode());
   auto *DS = Scope->getScopeNode();
   auto *InlinedSP = getDISubprogram(DS);
   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
   // was inlined from another compile unit.
   DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
   assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
 
   auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
   ParentScopeDIE.addChild(ScopeDIE);
   addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
 
-  attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
+  ContextCU->attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
 
   // Add the call site information to the DIE.
   const DILocation *IA = Scope->getInlinedAt();
   addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
           getOrCreateSourceID(IA->getFile()));
   addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
   if (IA->getColumn())
     addUInt(*ScopeDIE, dwarf::DW_AT_call_column, None, IA->getColumn());
for (const auto *Dependency : dependencies(Var)) {
       if (const auto *Dep = dyn_cast<const DILocalVariable>(Dependency))
         if (DbgVariable *Var = DbgVar.lookup(Dep))
           WorkList.push_back({Var, 0});
     }
   }
   return Result;
 }
 
-DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
-                                                   LexicalScope *Scope) {
-  DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
+DIE &DwarfCompileUnit::constructSubprogramScopeDIE(
+    const DISubprogram *Sub, LexicalScope *Scope,
+    DwarfCompileUnit **ContextCU) {
+  DIE &ScopeDIE = updateSubprogramScopeDIE(Sub, ContextCU);
 
   if (Scope) {
     assert(!Scope->getInlinedAt());
     assert(!Scope->isAbstractScope());
     // Collect lexical scope children first.
     // ObjectPointer might be a local (non-argument) local variable if it's a
     // block's synthetic this pointer.
-    if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
+    if (DIE *ObjectPointer =
+            createAndAddScopeChildren(Scope, ScopeDIE, *ContextCU))
       addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
   }
 
   // If this is a variadic function, add an unspecified parameter.
   DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
 
   // If we have a single element of null, it is a function that returns void.
   // If we have more than one elements and the last one is null, it is a
   // variadic function.
   if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
       !includeMinimalInlineScopes())
     ScopeDIE.addChild(
         DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));
 
   return ScopeDIE;
 }
 
 DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
-                                                 DIE &ScopeDIE) {
+                                                 DIE &ScopeDIE,
+                                                 DwarfCompileUnit *ContextCU) {
   DIE *ObjectPointer = nullptr;
 
   // Emit function arguments (order is significant).
   auto Vars = DU->getScopeVariables().lookup(Scope);
   for (auto &DV : Vars.Args)
     ScopeDIE.addChild(constructVariableDIE(*DV.second, *Scope, ObjectPointer));
 
   // Emit local variables.
if (!includeMinimalInlineScopes() &&
         !ImportedEntities[LS->getScopeNode()].empty())
       return true;
     return false;
   };
   for (LexicalScope *LS : Scope->getChildren()) {
     // If the lexical block doesn't have non-scope children, skip
     // its emission and put its children directly to the parent scope.
     if (needToEmitLexicalScope(LS))
-      constructScopeDIE(LS, ScopeDIE);
+      constructScopeDIE(LS, ScopeDIE, ContextCU);
     else
-      createAndAddScopeChildren(LS, ScopeDIE);
+      createAndAddScopeChildren(LS, ScopeDIE, ContextCU);
   }
 
   return ObjectPointer;
 }
 
 void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
     LexicalScope *Scope) {
   DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];
void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
   // Passing null as the associated node because the abstract definition
   // shouldn't be found by lookup.
   AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
   ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);
   ContextCU->addSInt(*AbsDef, dwarf::DW_AT_inline,
                      DD->getDwarfVersion() <= 4 ? Optional<dwarf::Form>()
                                                 : dwarf::DW_FORM_implicit_const,
                      dwarf::DW_INL_inlined);
-  if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
-    ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
+  if (DIE *ObjectPointer =
+          ContextCU->createAndAddScopeChildren(Scope, *AbsDef, ContextCU))
+    ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer,
+                           *ObjectPointer);
 }
 
 bool DwarfCompileUnit::useGNUAnalogForDwarf5Feature() const {
   return DD->getDwarfVersion() == 4 && !DD->tuneForLLDB();
 }
 
 dwarf::Tag DwarfCompileUnit::getDwarf5OrGNUTag(dwarf::Tag Tag) const {
   if (!useGNUAnalogForDwarf5Feature())

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (const DINode *DN : SP->getRetainedNodes()) {
       ensureAbstractEntityIsCreated(TheCU, DN, Scope);
       assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
              && "ensureAbstractEntityIsCreated inserted abstract scopes");
     }
     constructAbstractSubprogramScopeDIE(TheCU, AScope);
   }
 
   ProcessedSPNodes.insert(SP);
-  DIE &ScopeDIE = TheCU.constructSubprogramScopeDIE(SP, FnScope);
-  if (auto *SkelCU = TheCU.getSkeleton())
+  DwarfCompileUnit *ContextCU = nullptr;
+  DIE &ScopeDIE = TheCU.constructSubprogramScopeDIE(SP, FnScope, &ContextCU);
+  if (auto *SkelCU = TheCU.getSkeleton()) {
+    DwarfCompileUnit *ContextSkelCU = ContextCU->getSkeleton();
     if (!LScopes.getAbstractScopesList().empty() &&
         TheCU.getCUNode()->getSplitDebugInlining())
-      SkelCU->constructSubprogramScopeDIE(SP, FnScope);
+      SkelCU->constructSubprogramScopeDIE(SP, FnScope, &ContextSkelCU);
+  }
 
   // Construct call site entries.
   constructCallSiteEntryDIEs(*SP, TheCU, ScopeDIE, *MF);
 
   // Clear debug info
   // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
   // DbgVariables except those that are also in AbstractVariables (since they
   // can be used cross-function)

llvm/test/DebugInfo/Generic/cross-cu-inlining-ranges.ll

+; RUN: %llc_dwarf %s -filetype=obj -o %t
+; RUN: llvm-dwarfdump --verify %t
+
+; We want to check that when the CU attaches ranges use the correct ContextCU.
+
+declare void @f()
+
+define void @main() {
+  call void @f()
+  call void @f()
+  call void @f()
+  call void @f()
+  call void @f()
+  ret void
+}
+
+define void @foo() !dbg !10 {
+  call void @f(), !dbg !13
+  call void @f(), !dbg !18
+  ret void, !dbg !13
+}
+
+define void @bar() !dbg !19 {
+  ret void
+}
+
+!llvm.dbg.cu = !{!0, !2}
+!llvm.module.flags = !{!8, !9}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_Swift, file: !1, producer: "foo", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
+!1 = !DIFile(filename: "foo.swift", directory: "")
+!2 = distinct !DICompileUnit(language: DW_LANG_Swift, file: !3, producer: "bar", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4)
+!3 = !DIFile(filename: "bar.swift", directory: "")
+!4 = !{!5}
+!5 = !DIGlobalVariableExpression(var: !6, expr: !DIExpression())
+!6 = distinct !DIGlobalVariable(name: "global", linkageName: "global", scope: null, file: !3, line: 2, type: !7, isLocal: false, isDefinition: true)
+!7 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "struct", file: !1, runtimeLang: DW_LANG_Swift, identifier: "struct")
+!8 = !{i32 7, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = distinct !DISubprogram(name: "foo", linkageName: "_foo", scope: !7, type: !11, spFlags: DISPFlagDefinition, unit: !0)
+!11 = !DISubroutineType(types: !12)
+!12 = !{}
+!13 = !DILocation(line: 0, scope: !14, inlinedAt: !16)
+!14 = distinct !DILexicalBlock(scope: !15, file: !1)
+!15 = distinct !DISubprogram(name: "inlined_baz", linkageName: "_inlined_baz", scope: !7, file: !1, line: 7, type: !11, scopeLine: 7, spFlags: DISPFlagDefinition, unit: !0)
+!16 = !DILocation(line: 0, scope: !17)
+!17 = distinct !DILexicalBlock(scope: !10, file: !1)
+!18 = !DILocation(line: 0, scope: !10)
+!19 = distinct !DISubprogram(name: "bar", linkageName: "bar", scope: !2, type: !11, spFlags: DISPFlagDefinition, unit: !2)