[llvm-dwarfdump][Statistics] Handle LTO cases with cross CU referencing

[dmilosevic141]

Summary

With link-time optimizations enabled, resulting DWARF may end up containing cross CU references (through the DW_AT_abstract_origin attribute).
Consider the following example:

// sum.c
__attribute__((always_inline)) int sum(int a, int b)
{
     return a + b;
}
// main.c
extern int sum(int, int);
int main()
{
     int a = 5, b = 10, c = sum(a, b);
     return 0;
}

Compiled as follows:

$ clang -g -flto -fuse-ld=lld main.c sum.c -o main

Results in the following DWARF:

-- sum.c CU: abstract instance tree
...
0x000000b0:   DW_TAG_subprogram
                DW_AT_name	("sum")
                DW_AT_decl_file	("sum.c")
                DW_AT_decl_line	(1)
                DW_AT_prototyped	(true)
                DW_AT_type	(0x000000d3 "int")
                DW_AT_external	(true)
                DW_AT_inline	(DW_INL_inlined)

0x000000bc:     DW_TAG_formal_parameter
                  DW_AT_name	("a")
                  DW_AT_decl_file	("sum.c")
                  DW_AT_decl_line	(1)
                  DW_AT_type	(0x000000d3 "int")

0x000000c7:     DW_TAG_formal_parameter
                  DW_AT_name	("b")
                  DW_AT_decl_file	("sum.c")
                  DW_AT_decl_line	(1)
                  DW_AT_type	(0x000000d3 "int")
...
-- main.c CU: concrete inlined instance tree
...
0x0000006d:     DW_TAG_inlined_subroutine
                  DW_AT_abstract_origin	(0x00000000000000b0 "sum")
                  DW_AT_low_pc	(0x00000000002016ef)
                  DW_AT_high_pc	(0x00000000002016f1)
                  DW_AT_call_file	("main.c")
                  DW_AT_call_line	(5)
                  DW_AT_call_column	(0x19)

0x00000081:       DW_TAG_formal_parameter
                    DW_AT_location	(DW_OP_reg0 RAX)
                    DW_AT_abstract_origin	(0x00000000000000bc "a")

0x00000088:       DW_TAG_formal_parameter
                    DW_AT_location	(DW_OP_reg2 RCX)
                    DW_AT_abstract_origin	(0x00000000000000c7 "b")
...

Note that each entry within the concrete inlined instance tree in the main.c CU has a DW_AT_abstract_origin attribute which refers to a corresponding entry within the abstract instance tree in the sum.c CU.
llvm-dwarfdump --statistics did not properly report DW_TAG_formal_parameters/DW_TAG_variables from concrete inlined instance trees which had 0% location coverage and which referred to a different CU, mainly because information about abstract instance trees and their parameters/variables was stored locally - just for the currently processed CU, rather than globally - for all CUs.
In particular, if the concrete inlined instance tree from the example above was to look like this (i.e. parameter b has 0% location coverage, hence why it's missing):

0x0000006d:     DW_TAG_inlined_subroutine
                  DW_AT_abstract_origin	(0x00000000000000b0 "sum")
                  DW_AT_low_pc	(0x00000000002016ef)
                  DW_AT_high_pc	(0x00000000002016f1)
                  DW_AT_call_file	("main.c")
                  DW_AT_call_line	(5)
                  DW_AT_call_column	(0x19)

0x00000081:       DW_TAG_formal_parameter
                    DW_AT_location	(DW_OP_reg0 RAX)
                    DW_AT_abstract_origin	(0x00000000000000bc "a")

llvm-dwarfdump --statistics would have not reported b as such.

[djtodoro]

Thanks for this! Some initial comments inline.

llvm/test/tools/llvm-dwarfdump/X86/LTO_CCU_zero_loc_cov.ll

88–91

I think we don't need these attributes, so we can get rid of them.

97

we can get rid of the " (https://github.com/dmilosevic141/llvm-project.git 16083be64e5aa8ae2b32be0dbfb3b383b3c562ea)" part.

100

here as well

101

102

130–132

all these three locations can be replaced with just one (and also all the other locations with the same scope could be removed/replaced)

llvm/tools/llvm-dwarfdump/Statistics.cpp

50

is this clang-formatted?

[djtodoro]

Please also be clear in the patch title that we are fixing the statistics part of the llvm-dwarfdump.

[dmilosevic141]

Thanks for the suggestions!

I've updated the following:

• Changed the title so that it is clear that we're fixing the --statistics part of the llvm-dwarfdump and slightly updated the summary.
• clang-formatted the missed line within Statistics.cpp. Thanks!
• Removed the unnecessary git links and hashes, as well as the paths towards the source files within the .ll file.
• Reduced the number of function attributes, so that the .ll file only contains the necessary ones.
• Reduced the number of DILocations, so that the .ll file only contains the necessary ones.

[Orlando]

Hi,

Note that each entry within the concrete inlined instance tree in the main.c CU has a DW_AT_abstract_origin attribute which refers to a corresponding entry within the abstract instance tree in the sum.c CU.
llvm-dwarfdump (its --statistics option, to be precise) did not properly report DW_TAG_formal_parameters/DW_TAG_variables which had 0% location coverage, mainly because information about abstract instance trees and their parameters/variables was stored locally - just for the currently processed CU, rather than globally - for all CUs.

You state that the variables should have "0% location coverage", but the variables in your example each have a location that covers the entirety of its inlined scope (100% coverage):

0x0000006d:     DW_TAG_inlined_subroutine
                  DW_AT_abstract_origin	(0x00000000000000b0 "sum")
                  DW_AT_low_pc	(0x00000000002016ef)
                  DW_AT_high_pc	(0x00000000002016f1)
                  DW_AT_call_file	("main.c")
                  DW_AT_call_line	(5)
                  DW_AT_call_column	(0x19)

0x00000081:       DW_TAG_formal_parameter
                    DW_AT_location	(DW_OP_reg0 RAX)
                    DW_AT_abstract_origin	(0x00000000000000bc "a")

Am I missing something?

I added just one inline nit/question but I haven't fully reviewed this - please don't let my questions block the review process.

llvm/tools/llvm-dwarfdump/Statistics.cpp

51

Is there a reason that this cannot be just llvm::SmallVector<DIELocation> (i.e. drop the unique_ptr wrapper)?

[dmilosevic141]

Thanks @Orlando!
As far as the example in the summary goes, it was meant to showcase cross CU referencing in general, hence why the variables in the concrete inlined instance tree had full location coverage. I've updated the summary by adding a concrete example of what it looks like when a variable in a concrete inlined instance tree has 0% location coverage, which is what this patch actually fixes.
I've also dropped the std::unique_ptr wrapper around CrossCUReferencingDIELocationTy as there really was no reason for it.

[djtodoro]

llvm/tools/llvm-dwarfdump/Statistics.cpp

787

This actually fixes this TODO.

[dmilosevic141]

Removed a trailing whitespace within the .ll file which prevented patch application in pre-merge checks.

[djtodoro]

Some extra nits included. I'll take another look into the functionality itself.

llvm/test/tools/llvm-dwarfdump/X86/LTO_CCU_zero_loc_cov.ll

14–30

All these should also start with double ';;'

64

The comment as well should also start with double ';;'

[dmilosevic141]

• Rebased.
• Updated comments within the .ll file. Thanks @djtodoro!

[dmilosevic141]

Ran git-clang-format so that changes made match latest clang-format style.

[Orlando]

In D113465#3121246, @dmilosevic141 wrote:

Thanks @Orlando!
As far as the example in the summary goes, it was meant to showcase cross CU referencing in general, hence why the variables in the concrete inlined instance tree had full location coverage. I've updated the summary by adding a concrete example of what it looks like when a variable in a concrete inlined instance tree has 0% location coverage, which is what this patch actually fixes.

Thanks for the explanation, that clears up my confusion!

[djtodoro]

LGTM. Please leave this for a couple of days, to see if someone has additional comments.

llvm/test/tools/llvm-dwarfdump/X86/LTO_CCU_zero_loc_cov.ll

+;; llc will generate additional 'empty' DW_TAG_subroutine in sum.c's CU.
+;; It will not be considered by the statistics.
+; RUN: llc %s -o - -filetype=obj \
+; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
+
+;; Instructions to regenerate IR:
+;; clang -g -flto -emit-llvm -S -o main.ll -c main.c
+;; clang -g -flto -emit-llvm -S -o sum.ll -c sum.c
+;; llvm-link -S -o linked.ll main.ll sum.ll
+;; opt -O1 linked.ll -S -o merged.ll
+;; Hard coded a call to llvm.dbg.value intrinsic, replacing %10 argument with undef, in order to have 0% location coverage for a CCU referencing DIE.
+
+;; Source files:
+;;main.c:
+;;extern int sum(int a, int b);
+;;
+;;int main()
+;;{
+;;  int a = 10, b = 5;
+;;  int c = sum(a,b);
+;; int d = c + sum(c,2);
+;;  return 0;
+;;}
+;;sum.c:
+;;__attribute__((always_inline)) int sum(int a, int b)
+;;{
+;;  int result = a + b;
+;;  return result;
+;;}
+
+; CHECK:      "#source variables with location": 10,
+; CHECK:      "#variables with 0% of parent scope covered by DW_AT_location": 1,
+; CHECK:      "#params with 0% of parent scope covered by DW_AT_location": 1,
+
+; ModuleID = 'linked.ll'
+source_filename = "llvm-link"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local i32 @main() local_unnamed_addr #0 !dbg !11 {
+  %1 = alloca i32, align 4
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  %4 = alloca i32, align 4
+  %5 = alloca i32, align 4
+  store i32 0, i32* %1, align 4
+  call void @llvm.dbg.declare(metadata i32* %2, metadata !15, metadata !DIExpression()), !dbg !16
+  store i32 10, i32* %2, align 4, !dbg !16
+  call void @llvm.dbg.declare(metadata i32* %3, metadata !17, metadata !DIExpression()), !dbg !16
+  store i32 5, i32* %3, align 4, !dbg !16
+  call void @llvm.dbg.declare(metadata i32* %4, metadata !19, metadata !DIExpression()), !dbg !16
+  %6 = load i32, i32* %2, align 4, !dbg !16
+  %7 = load i32, i32* %3, align 4, !dbg !16
+  call void @llvm.dbg.value(metadata i32 %6, metadata !23, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %7, metadata !29, metadata !DIExpression()), !dbg !27
+  %8 = add nsw i32 %7, %6, !dbg !27
+  call void @llvm.dbg.value(metadata i32 %8, metadata !31, metadata !DIExpression()), !dbg !27
+  store i32 %8, i32* %4, align 4, !dbg !16
+  call void @llvm.dbg.declare(metadata i32* %5, metadata !32, metadata !DIExpression()), !dbg !16
+  %9 = load i32, i32* %4, align 4, !dbg !16
+  %10 = load i32, i32* %4, align 4, !dbg !16
+  call void @llvm.dbg.value(metadata i32 undef, metadata !23, metadata !DIExpression()), !dbg !36 ;; Hard coded line: There was %10 instead of undef.
+  call void @llvm.dbg.value(metadata i32 2, metadata !29, metadata !DIExpression()), !dbg !36
+  %11 = add nsw i32 2, %10, !dbg !36
+  call void @llvm.dbg.value(metadata i32 %11, metadata !31, metadata !DIExpression()), !dbg !36
+  %12 = add nsw i32 %9, %11, !dbg !16
+  store i32 %12, i32* %5, align 4, !dbg !16
+  ret i32 0, !dbg !16
+}
+
+; Function Attrs: mustprogress nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+; Function Attrs: alwaysinline mustprogress nofree norecurse nosync nounwind readnone uwtable willreturn
+define dso_local i32 @sum(i32 %0, i32 %1) local_unnamed_addr #2 !dbg !24 {
+  call void @llvm.dbg.value(metadata i32 %0, metadata !23, metadata !DIExpression()), !dbg !41
+  call void @llvm.dbg.value(metadata i32 %1, metadata !29, metadata !DIExpression()), !dbg !41
+  %3 = add nsw i32 %1, %0, !dbg !41
+  call void @llvm.dbg.value(metadata i32 %3, metadata !31, metadata !DIExpression()), !dbg !41
+  ret i32 %3, !dbg !41
+}
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+attributes #0 = { noinline nounwind optnone uwtable }
+attributes #2 = { alwaysinline mustprogress nofree norecurse nosync nounwind readnone uwtable willreturn }
+
+!llvm.dbg.cu = !{!0, !3}
+!llvm.ident = !{!5, !5}
+!llvm.module.flags = !{!6, !7, !8, !9, !10}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "main.c", directory: "/dir")
+!2 = !{}
+!3 = distinct !DICompileUnit(language: DW_LANG_C99, file: !4, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!4 = !DIFile(filename: "sum.c", directory: "/dir")
+!5 = !{!"clang version 14.0.0"}
+!6 = !{i32 7, !"Dwarf Version", i32 4}
+!7 = !{i32 2, !"Debug Info Version", i32 3}
+!8 = !{i32 1, !"wchar_size", i32 4}
+!9 = !{i32 7, !"uwtable", i32 1}
+!10 = !{i32 7, !"frame-pointer", i32 2}
+!11 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 3, type: !12, scopeLine: 4, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!12 = !DISubroutineType(types: !13)
+!13 = !{!14}
+!14 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!15 = !DILocalVariable(name: "a", scope: !11, file: !1, line: 5, type: !14)
+!16 = !DILocation(line: 5, column: 6, scope: !11)
+!17 = !DILocalVariable(name: "b", scope: !11, file: !1, line: 5, type: !14)
+!19 = !DILocalVariable(name: "c", scope: !11, file: !1, line: 6, type: !14)
+!23 = !DILocalVariable(name: "a", arg: 1, scope: !24, file: !4, line: 1, type: !14)
+!24 = distinct !DISubprogram(name: "sum", scope: !4, file: !4, line: 1, type: !25, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !3, retainedNodes: !2)
+!25 = !DISubroutineType(types: !26)
+!26 = !{!14, !14, !14}
+!27 = !DILocation(line: 0, scope: !24, inlinedAt: !28)
+!28 = distinct !DILocation(line: 6, column: 10, scope: !11)
+!29 = !DILocalVariable(name: "b", arg: 2, scope: !24, file: !4, line: 1, type: !14)
+!31 = !DILocalVariable(name: "result", scope: !24, file: !4, line: 3, type: !14)
+!32 = !DILocalVariable(name: "d", scope: !11, file: !1, line: 7, type: !14)
+!36 = !DILocation(line: 0, scope: !24, inlinedAt: !37)
+!37 = distinct !DILocation(line: 7, column: 14, scope: !11)
+!41 = !DILocation(line: 0, scope: !24)

llvm/tools/llvm-dwarfdump/Statistics.cpp

 /// This represents a data type for the stats and it helps us to
 /// detect an overflow.
 /// NOTE: This can be implemented as a template if there is an another type
 /// needing this.
 struct SaturatingUINT64 {
   /// Number that represents the stats.
   uint64_t Value;
 
   SaturatingUINT64(uint64_t Value_) : Value(Value_) {}
 
   void operator++(int) { return *this += 1; }
   void operator+=(uint64_t Value_) {
     if (Value != OverflowValue) {
       if (Value < OverflowValue - Value_)
         Value += Value_;
       else
         Value = OverflowValue;
     }
   }
 };
 
+/// Utility struct to store the full location of a DIE - its CU and offset.
+struct DIELocation {
+  DWARFUnit *DwUnit;
+  uint64_t DIEOffset;
+  DIELocation(DWARFUnit *_DwUnit, uint64_t _DIEOffset)
+      : DwUnit(_DwUnit), DIEOffset(_DIEOffset) {}
+};
+/// This represents DWARF locations of CrossCU referencing DIEs.
+using CrossCUReferencingDIELocationTy = llvm::SmallVector<DIELocation>;
+
+/// This maps function DIE offset to its DWARF CU.
+using FunctionDIECUTyMap = llvm::DenseMap<uint64_t, DWARFUnit *>;
+
 /// Holds statistics for one function (or other entity that has a PC range and
 /// contains variables, such as a compile unit).
 struct PerFunctionStats {
   /// Number of inlined instances of this function.
   uint64_t NumFnInlined = 0;
   /// Number of out-of-line instances of this function.
   uint64_t NumFnOutOfLine = 0;
   /// Number of inlined instances that have abstract origins.
if (IsParam) {
     if (HasLoc)
       FnStats.NumLocalVarLocations++;
   }
 }
 
 /// Recursively collect variables from subprogram with DW_AT_inline attribute.
 static void collectAbstractOriginFnInfo(
     DWARFDie Die, uint64_t SPOffset,
-    AbstractOriginVarsTyMap &GlobalAbstractOriginFnInfo) {
+    AbstractOriginVarsTyMap &GlobalAbstractOriginFnInfo,
+    AbstractOriginVarsTyMap &LocalAbstractOriginFnInfo) {
   DWARFDie Child = Die.getFirstChild();
   while (Child) {
     const dwarf::Tag ChildTag = Child.getTag();
     if (ChildTag == dwarf::DW_TAG_formal_parameter ||
-        ChildTag == dwarf::DW_TAG_variable)
+        ChildTag == dwarf::DW_TAG_variable) {
       GlobalAbstractOriginFnInfo[SPOffset].push_back(Child.getOffset());
-    else if (ChildTag == dwarf::DW_TAG_lexical_block)
-      collectAbstractOriginFnInfo(Child, SPOffset, GlobalAbstractOriginFnInfo);
+      LocalAbstractOriginFnInfo[SPOffset].push_back(Child.getOffset());
+    } else if (ChildTag == dwarf::DW_TAG_lexical_block)
+      collectAbstractOriginFnInfo(Child, SPOffset, GlobalAbstractOriginFnInfo,
+                                  LocalAbstractOriginFnInfo);
     Child = Child.getSibling();
   }
 }
 
 /// Recursively collect debug info quality metrics.
 static void collectStatsRecursive(
     DWARFDie Die, std::string FnPrefix, std::string VarPrefix,
     uint64_t BytesInScope, uint32_t InlineDepth,
     StringMap<PerFunctionStats> &FnStatMap, GlobalStats &GlobalStats,
-    LocationStats &LocStats,
+    LocationStats &LocStats, FunctionDIECUTyMap &AbstractOriginFnCUs,
     AbstractOriginVarsTyMap &GlobalAbstractOriginFnInfo,
+    AbstractOriginVarsTyMap &LocalAbstractOriginFnInfo,
     FunctionsWithAbstractOriginTy &FnsWithAbstractOriginToBeProcessed,
     AbstractOriginVarsTy *AbstractOriginVarsPtr = nullptr) {
   // Skip NULL nodes.
   if (Die.isNULL())
     return;
 
   const dwarf::Tag Tag = Die.getTag();
   // Skip function types.
static void collectStatsRecursive(
   AbstractOriginVarsTy AbstractOriginVars;
 
   // Get the vars of the inlined fn, so the locstats
   // reports the missing vars (with coverage 0%).
   if (IsCandidateForZeroLocCovTracking) {
     auto OffsetFn = Die.find(dwarf::DW_AT_abstract_origin);
     if (OffsetFn) {
       uint64_t OffsetOfInlineFnCopy = (*OffsetFn).getRawUValue();
-      if (GlobalAbstractOriginFnInfo.count(OffsetOfInlineFnCopy)) {
-        AbstractOriginVars = GlobalAbstractOriginFnInfo[OffsetOfInlineFnCopy];
+      if (LocalAbstractOriginFnInfo.count(OffsetOfInlineFnCopy)) {
+        AbstractOriginVars = LocalAbstractOriginFnInfo[OffsetOfInlineFnCopy];
         AbstractOriginVarsPtr = &AbstractOriginVars;
       } else {
-        // This means that the DW_AT_inline fn copy is out of order,
+        // This means that the DW_AT_inline fn copy is out of order
+        // or that the abstract_origin references another CU,
         // so this abstract origin instance will be processed later.
         FnsWithAbstractOriginToBeProcessed.push_back(Die.getOffset());
         AbstractOriginVarsPtr = nullptr;
       }
     }
   }
 
   if (IsFunction || IsInlinedFunction || IsBlock) {
if (IsFunction || IsInlinedFunction || IsBlock) {
 
     // Count the function.
     if (!IsBlock) {
       // Skip over abstract origins, but collect variables
       // from it so it can be used for location statistics
       // for inlined instancies.
       if (Die.find(dwarf::DW_AT_inline)) {
         uint64_t SPOffset = Die.getOffset();
-        collectAbstractOriginFnInfo(Die, SPOffset, GlobalAbstractOriginFnInfo);
+        AbstractOriginFnCUs[SPOffset] = Die.getDwarfUnit();
+        collectAbstractOriginFnInfo(Die, SPOffset, GlobalAbstractOriginFnInfo,
+                                    LocalAbstractOriginFnInfo);
         return;
       }
 
       std::string FnID = constructDieID(Die);
       // We've seen an instance of this function.
       auto &FnStats = FnStatMap[FnID];
       FnStats.IsFunction = true;
       if (IsInlinedFunction) {
while (Child) {
     std::string ChildVarPrefix = VarPrefix;
     if (Child.getTag() == dwarf::DW_TAG_lexical_block)
       ChildVarPrefix += toHex(LexicalBlockIndex++) + '.';
     if (Child.getTag() == dwarf::DW_TAG_formal_parameter)
       ChildVarPrefix += 'p' + toHex(FormalParameterIndex++) + '.';
 
     collectStatsRecursive(
         Child, FnPrefix, ChildVarPrefix, BytesInScope, InlineDepth, FnStatMap,
-        GlobalStats, LocStats, GlobalAbstractOriginFnInfo,
-        FnsWithAbstractOriginToBeProcessed, AbstractOriginVarsPtr);
+        GlobalStats, LocStats, AbstractOriginFnCUs, GlobalAbstractOriginFnInfo,
+        LocalAbstractOriginFnInfo, FnsWithAbstractOriginToBeProcessed,
+        AbstractOriginVarsPtr);
     Child = Child.getSibling();
   }
 
   if (!IsCandidateForZeroLocCovTracking)
     return;
 
   // After we have processed all vars of the inlined function (or function with
   // an abstract_origin), we want to know how many variables have no location.

 }
 
 /// Collect zero location coverage for inlined variables which refer to
 /// a DW_AT_inline copy of subprogram that is out of order in the DWARF.
 /// Also cover the variables of a concrete function (represented with
 /// the DW_TAG_subprogram) with an abstract_origin attribute.
 static void collectZeroLocCovForVarsWithAbstractOrigin(
     DWARFUnit *DwUnit, GlobalStats &GlobalStats, LocationStats &LocStats,
-    AbstractOriginVarsTyMap &GlobalAbstractOriginFnInfo,
+    AbstractOriginVarsTyMap &LocalAbstractOriginFnInfo,
     FunctionsWithAbstractOriginTy &FnsWithAbstractOriginToBeProcessed) {
+  // The next variable is used to filter out functions that have been processed,
+  // leaving FnsWithAbstractOriginToBeProcessed with just CrossCU references.
+  FunctionsWithAbstractOriginTy ProcessedFns;
   for (auto FnOffset : FnsWithAbstractOriginToBeProcessed) {
     DWARFDie FnDieWithAbstractOrigin = DwUnit->getDIEForOffset(FnOffset);
     auto FnCopy = FnDieWithAbstractOrigin.find(dwarf::DW_AT_abstract_origin);
     AbstractOriginVarsTy AbstractOriginVars;
     if (!FnCopy)
       continue;
-
-    AbstractOriginVars = GlobalAbstractOriginFnInfo[(*FnCopy).getRawUValue()];
+    uint64_t FnCopyRawUValue = (*FnCopy).getRawUValue();
+    // If there is no entry within LocalAbstractOriginFnInfo for the given
+    // FnCopyRawUValue, function isn't out-of-order in DWARF. Rather, we have
+    // CrossCU referencing.
+    if (!LocalAbstractOriginFnInfo.count(FnCopyRawUValue))
+      continue;
+    AbstractOriginVars = LocalAbstractOriginFnInfo[FnCopyRawUValue];
     updateVarsWithAbstractOriginLocCovInfo(FnDieWithAbstractOrigin,
                                            AbstractOriginVars);
 
     for (auto Offset : AbstractOriginVars) {
       LocStats.NumVarParam++;
       LocStats.VarParamLocStats[ZeroCoverageBucket]++;
       auto Tag = DwUnit->getDIEForOffset(Offset).getTag();
       if (Tag == dwarf::DW_TAG_formal_parameter) {
         LocStats.NumParam++;
         LocStats.ParamLocStats[ZeroCoverageBucket]++;
       } else if (Tag == dwarf::DW_TAG_variable) {
         LocStats.NumVar++;
         LocStats.LocalVarLocStats[ZeroCoverageBucket]++;
       }
     }
+    ProcessedFns.push_back(FnOffset);
+  }
+  for (auto ProcessedFn : ProcessedFns)
+    llvm::erase_value(FnsWithAbstractOriginToBeProcessed, ProcessedFn);
+}
+
+/// Collect zero location coverage for inlined variables which refer to
+/// a DW_AT_inline copy of subprogram that is in a different CU.
+static void collectZeroLocCovForVarsWithCrossCUReferencingAbstractOrigin(
+    LocationStats &LocStats, FunctionDIECUTyMap AbstractOriginFnCUs,
+    AbstractOriginVarsTyMap &GlobalAbstractOriginFnInfo,
+    CrossCUReferencingDIELocationTy &CrossCUReferencesToBeResolved) {
+  for (const auto &CrossCUReferenceToBeResolved :
+       CrossCUReferencesToBeResolved) {
+    DWARFUnit *DwUnit = CrossCUReferenceToBeResolved.DwUnit;
+    DWARFDie FnDIEWithCrossCUReferencing =
+        DwUnit->getDIEForOffset(CrossCUReferenceToBeResolved.DIEOffset);
+    auto FnCopy =
+        FnDIEWithCrossCUReferencing.find(dwarf::DW_AT_abstract_origin);
+    if (!FnCopy)
+      continue;
+    uint64_t FnCopyRawUValue = (*FnCopy).getRawUValue();
+    AbstractOriginVarsTy AbstractOriginVars =
+        GlobalAbstractOriginFnInfo[FnCopyRawUValue];
+    updateVarsWithAbstractOriginLocCovInfo(FnDIEWithCrossCUReferencing,
+                                           AbstractOriginVars);
+    for (auto Offset : AbstractOriginVars) {
+      LocStats.NumVarParam++;
+      LocStats.VarParamLocStats[ZeroCoverageBucket]++;
+      auto Tag = (AbstractOriginFnCUs[FnCopyRawUValue])
+                     ->getDIEForOffset(Offset)
+                     .getTag();
+      if (Tag == dwarf::DW_TAG_formal_parameter) {
+        LocStats.NumParam++;
+        LocStats.ParamLocStats[ZeroCoverageBucket]++;
+      } else if (Tag == dwarf::DW_TAG_variable) {
+        LocStats.NumVar++;
+        LocStats.LocalVarLocStats[ZeroCoverageBucket]++;
+      }
+    }
   }
 }
 
 /// \}
 
 /// Collect debug info quality metrics for an entire DIContext.
 ///
 /// Do the impossible and reduce the quality of the debug info down to a few
 /// numbers. The idea is to condense the data into numbers that can be tracked
 /// over time to identify trends in newer compiler versions and gauge the effect
 /// of particular optimizations. The raw numbers themselves are not particularly
 /// useful, only the delta between compiling the same program with different
 /// compilers is.
 bool dwarfdump::collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
                                           const Twine &Filename,
                                           raw_ostream &OS) {
   StringRef FormatName = Obj.getFileFormatName();
   GlobalStats GlobalStats;
   LocationStats LocStats;
   StringMap<PerFunctionStats> Statistics;
+  // This variable holds variable information for functions with
+  // abstract_origin globally, across all CUs.
+  AbstractOriginVarsTyMap GlobalAbstractOriginFnInfo;
+  // This variable holds information about the CU of a function with
+  // abstract_origin.
+  FunctionDIECUTyMap AbstractOriginFnCUs;
+  CrossCUReferencingDIELocationTy CrossCUReferencesToBeResolved;
   for (const auto &CU : static_cast<DWARFContext *>(&DICtx)->compile_units()) {
     if (DWARFDie CUDie = CU->getNonSkeletonUnitDIE(false)) {
-      // These variables are being reset for each CU, since there could be
-      // a situation where we have two subprogram DIEs with the same offsets
-      // in two diferent CUs, and we can end up using wrong variables info
-      // when trying to resolve abstract_origin attribute.
-      // TODO: Handle LTO cases where the abstract origin of
-      // the function is in a different CU than the one it's
-      // referenced from or inlined into.
-      AbstractOriginVarsTyMap GlobalAbstractOriginFnInfo;
+      // This variable holds variable information for functions with
+      // abstract_origin, but just for the current CU.
+      AbstractOriginVarsTyMap LocalAbstractOriginFnInfo;
       FunctionsWithAbstractOriginTy FnsWithAbstractOriginToBeProcessed;
 
-      collectStatsRecursive(CUDie, "/", "g", 0, 0, Statistics, GlobalStats,
-                            LocStats, GlobalAbstractOriginFnInfo,
-                            FnsWithAbstractOriginToBeProcessed);
-
+      collectStatsRecursive(
+          CUDie, "/", "g", 0, 0, Statistics, GlobalStats, LocStats,
+          AbstractOriginFnCUs, GlobalAbstractOriginFnInfo,
+          LocalAbstractOriginFnInfo, FnsWithAbstractOriginToBeProcessed);
+
+      // collectZeroLocCovForVarsWithAbstractOrigin will filter out all
+      // out-of-order DWARF functions that have been processed within it,
+      // leaving FnsWithAbstractOriginToBeProcessed with only CrossCU
+      // references.
       collectZeroLocCovForVarsWithAbstractOrigin(
           CUDie.getDwarfUnit(), GlobalStats, LocStats,
-          GlobalAbstractOriginFnInfo, FnsWithAbstractOriginToBeProcessed);
+          LocalAbstractOriginFnInfo, FnsWithAbstractOriginToBeProcessed);
+
+      // Collect all CrossCU references into CrossCUReferencesToBeResolved.
+      for (auto CrossCUReferencingDIEOffset :
+           FnsWithAbstractOriginToBeProcessed)
+        CrossCUReferencesToBeResolved.push_back(
+            DIELocation(CUDie.getDwarfUnit(), CrossCUReferencingDIEOffset));
     }
   }
 
+  /// Resolve CrossCU references.
+  collectZeroLocCovForVarsWithCrossCUReferencingAbstractOrigin(
+      LocStats, AbstractOriginFnCUs, GlobalAbstractOriginFnInfo,
+      CrossCUReferencesToBeResolved);
+
   /// Collect the sizes of debug sections.
   SectionSizes Sizes;
   calculateSectionSizes(Obj, Sizes, Filename);
 
   /// The version number should be increased every time the algorithm is changed
   /// (including bug fixes). New metrics may be added without increasing the
   /// version.
   unsigned Version = 9;