[WIP] Support multiple compile units per OSO entry in SymbolFileDWARFDebugMap

[sgraenitz]

Summary

So far SymbolFileDWARFDebugMap did only parse one compile unit per OSO entry. Thus, LLDB failed to resolve breakpoint locations in LTO objects with embedded DWARF.

This is a first minimal patch, that primairily fixes my bug. The central issues are:

• SymbolFileDWARFDebugMap::InitOSO() -- For each OSO entry we need to parse all compile units and store their individual offsets.
• SymbolFileDWARF::ParseCompileUnit() -- Parse the compile unit that matches the given dwarf_cu. At this point there is no context information except offset, so use offset mapping from InitOSO(). (The cu_idx parameter is the default from SymbolFileDWARF::GetCompUnitForDWARFCompUnit() in this execution path.)
• DWARFUnit::BuildAddressRangeTable() -- Subsequent TAG_compile_unit's have no AT_ranges. Passing true for check_hi_lo_pc enables fallback to construct the range from AT_low/high_pc. It is not fully clear to me whether the missing tags are expected and the fallback reliable.
• SymbolFileDWARFDebugMap::HasCompileUnits() -- New function with only the subset of InitOSO() required for CalculateAbilities(). Full init should only run once we're sure this is the right plugin.

Missing in the first patch:

• tests that reproduce the issue
• cleanup of dead code I found
• refactorings for involved code and data structures

FIXMEs indicate further changes I consider necessary, but I am quite new to the code base, so please don't hesitate to point out what I failed to see.

A part of this was shortly discussed on the mailing list:
http://lists.llvm.org/pipermail/lldb-dev/2018-September/014160.html

[JDevlieghere]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

438–439

Please give this bool a name, either by assigning it to a named variable or by prefixing it with a comment like /* check_hi_lo_pc */. I think the LLDB code base prefer the former?

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

783

What is "it" here?

797

You can use llvm_unreachable here.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

1338

Yes, otherwise we have invalid DWARF, which I don't think it's worth supporting something like that here.

[sgraenitz]

Address Jonas' feedback + minor additions

[sgraenitz]

Address Jonas' feedback #2

[sgraenitz]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

438–439

@JDevlieghere Thanks for your feedback!

@everyone:
This parameter is, actually, one of the key questions in this review: If there is no DW_AT_range attribute for the compile unit, can we safely fall back to DW_AT_low/high_pc?

[clayborg]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

298–322

static constexpr uint32_t kOSOSymbolFlags = 0x660001u;

328

kOSOSymbolFlags

source/Symbol/Symtab.cpp

512–520

This function is a bit specific. Might be nice to have a method like:

void Symtab::ForEachSymbolWithType(
  lldb::SymbolType symbol_type, 
  llvm::function_ref<bool(const Symbol*)> lambda) const;

The lambda returns false, then stop iterating. Else keep going. See ModuleList::ForEach as an example. Then the code that was calling HasSymbolWithTypeAndFlags would do something like:

symtab->ForEachSymbolWithType(eSymbolTypeObjectFile, [&this->m_has_compile_unit_infos](Symbol *symbol)->bool {
  if (symbol->GetFlags() == kOSOSymbolFlags) {
    m_has_compile_unit_infos = true;
    return false; // Stop iterating
  }
  return true; // Keep iterating
});

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

438–439

I have seen DWARF where the DW_AT_ranges is incorrect and I have seen cases where the low pc is just set to zero and the high pc is set to the max address. So you might have many overlapping ranges between different CUs in the latter case. We might need to be more vigilant with high/low pc values though and that was the reason that we previously ignored high/low pc values. If the stuff is missing, it should index the DWARF and generate the address ranges table manually right? What was the reasoning behind this change?

[sgraenitz]

Revert check_hi_lo_pc and comment out call to AddOSOARanges() for now

[sgraenitz]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

438–439

I had a closer look at the individual fallbacks and you are right. After fixing SymbolFileDWARF::ParseCompileUnit() we have the correct CompileUnit pointers in DWARFUnit::m_user_data for all CUs. Thus, the below die->BuildAddressRangeTable(dwarf, this, debug_aranges); now correctly constructs the ranges! Great, with this we can keep check_hi_lo_pc=false.

I didn't notice this while testing, because of the following issue that kept my tests failing: 2 of my LTO object's CUs have no code remaining after optimization, so we step into the next fallback assuming 'a line tables only situation' and eventually call AddOSOARanges(), which adds to debug_aranges all entries of the CU's FileRangeMap with a zero offset.

Thus, my debug_aranges had 28000 entries too much and most requests would continue to return 0 as before. For now I commented out the call below.

What do you think is a good way to avoid this for empty CUs?
IIUC they should have no DW_AT_low/high_pc right? :-D

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

425

Following from inline comment below, you can abort if this CU is empty:

// If this DWARF unit has no children, we have no address ranges to add. If
// something is built with line tables only, there will still be function DIEs with
// address ranges as children.
if (!die->HasChildren())
  return;

439

Empty CUs won't have any children. Easy to skip by getting the CU die and doing:

if (!die->HasChildren())

489–490

revert if the "if (!die->hasChildren())" trick works.

[sgraenitz]

Skip AddOSOARanges() if the OSO debug map entry has multiple compile units.

[sgraenitz]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

439

Sorry if that was too unspecific. With "no code left" I meant it has no instructions. The DIE does have child DIEs for declarations (e.g. TAG_namespace, TAG_enumeration_type, TAG_imported_declaration), but nothing that would form a range.

I could traverse the DWARF and filter for DIEs with instructions (e.g. TAG_subprogram), but it seems pretty much what die->BuildAddressRangeTable() does already.

489–490

revert if the "if (!die->hasChildren())" trick works.

As noted above, unfortunately, it doesn't. The exploration below got quite verbose.

It looks like a conceptual clash to me: For OSO debug map entries with multiple CUs, we can't map between symtab entries and CUs. Thus, each CU's FileRangeMap will be populated from the entire symtab range of that OSO debug map entry and the call to AddOSOARanges() here will add all of that to debug_aranges for each CU again.

We should have one FileRangeMap per OSO debug map entry and not one per CU.

Even if I fixed AddOSOARanges() to write the current CU offset instead of dwarf2Data->GetID() and FileRangeMap existed per OSO debug map entry (or the huge number of duplicates was acceptable), it would still add entries from other CUs of that OSO debug map entry. This cannot work with the current approach in SymbolFileDWARF::ResolveSymbolContext() because we will have #CUs candidates here, but we only look for a single result:

const dw_offset_t cu_offset =
    debug_info->GetCompileUnitAranges().FindAddress(file_vm_addr);

In order to keep the current AddOSOARanges() approach and support multiple CUs per OSO debug map entry, SymbolFileDWARF::ResolveSymbolContext() must be changed to test all candidate CUs. While these changes may be important and the code may really benefit from a cleanup, it goes far beyond the scope of this bug fix.

The only reasonable alternative I see is to skip AddOSOARanges() for OSO debug map entries with multiple CUs.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

1531

Skipping AddOSOARanges() here.

[vsk]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

438–439

+1 to @clayborg's suggestion here that we either use AT_ranges, or build up the ranges by parsing the low/high pc's in subprograms. ISTM that it'd be acceptable to implement the fallback path as a follow-up, provided that doing so isn't a regression.

490

Could you leave an in-source comment explaining why this is commented out?

[sgraenitz]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

1531

Could you leave an in-source comment explaining why this is commented out?

@vsk AddOSOARanges() was commented out only temporarily. I reverted it in the latest patch and added these lines with a comment. Is that what you were asking for?

[vsk]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

1531

Ah sure sure, sorry, I missed the broader context of the change.

[sgraenitz]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

468

@clayborg Any idea how to reproduce this code path? I expected test_lt as below would do, but debug_aranges is read from DIE even there. Is it (only) for backwards compatibility?

clang -c -gline-tables-only -o main_lt.o main.c
clang -c -gline-tables-only -o cu1_lt.o cu1.c
clang -gline-tables-only main_lt.o cu1_lt.o -o test_lt

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

1531

No worries, thanks for having a look.

[sgraenitz]

Add test for breakpoint resolution in DWARF debug map, exercising different LTO and line-tables-only combinations

[clayborg]

source/Symbol/Symtab.cpp

520

This function is still pretty specific. Any comments on my above inlined comment?

[sgraenitz]

source/Symbol/Symtab.cpp

520

Yes absolutely, but the same holds for most functions around here. This one is just a stripped-down version of the above AppendSymbolIndexesWithTypeAndFlagsValue(). Both of them are used exactly once (in CalculateAbilities() and InitOSO() respectively).

Of course this is all overly specific. Instead it should be HasSymbol(Predicate) and AppendSymbol(Predicate, Collection&), but I don't think we gain anything here by making one of them generic.

My fix is very loosely connected to Symtab at all. IMHO it's preferable to keep the existing practice here. This code should be improved consistently in a refactoring commit with no semantic changes.

[clayborg]

Looks good then as long as all tests pass on Darwin.

[sgraenitz]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

468

Found repros in the test suite. Some _dwarf and _gmodule variants seem to be failing due to my fix. Will investigate and post changes if necessary. Thanks for the review.

[aprantl]

packages/Python/lldbsuite/test/macosx/debug_map/Makefile

14

This is a noop. You can remove it without affecting anything.

23

same here, just remove it

25

If you do this, then you should also the NO_DEBUG_INFO_TESTCASE=True otherwise you're going to build dwarf and dsym variants of the test and they will be identical.

26

this was for debugging? Also remove it

31

$(CC) -c $(CFLAGS) $(CFLAGS_MAIN) -o $@ $^

-g should already be part of CFLAGS, no?

43

$(LD) $^ -L. $(LDFLAGS) -o a.out

or even shorter, remove the entire line and just declare the dependencies, because the default rule from Makefile.rules will kick in then.

[dexonsmith]

packages/Python/lldbsuite/test/macosx/debug_map/Makefile

23

I haven't read the full patch to see if this is relevant, but my maybe-out-of-date-Makefile-fu says this is not no-op. It defines C_SOURCES as a variable, as opposed to a function-like macro (which would be C_SOURCES =, no colon). IIRC, with the former, any changes to C_SOURCES (like C_SOURCES += ...) are evaluated immediately when it's a variable, lazily (on use) when it's a macro. Usually the behaviour you want is a variable.

[aprantl]

packages/Python/lldbsuite/test/macosx/debug_map/Makefile

23

What Duncan says is correct. For this particular Makefile though, that difference shouldn't matter and it would be better to keep the file short and simple.

[sgraenitz]

Address feedback from Adrian and Duncan

packages/Python/lldbsuite/test/macosx/debug_map/Makefile

14

It was meant to indicate that the python script can override these parameters, but you are right. It's probably more confusing than helpful. Above comment should be enough.

31

-g should already be part of CFLAGS, no?

Yes, right.

$(CC) -c $(CFLAGS) $(CFLAGS_MAIN) -o $@ $^

Actually, I'd prefer my version with -o main.o $(SRCDIR)/main.c. It's more verbose, but clearly states what happens here. $@ $^ is hard-to-read Makefile magic (to me).

43

Not sure why, but removing the line causes a lot of compile errors, like
clang-8: error: no input files and
Undefined symbols for architecture x86_64: "_main", ...

I guess I had to declare my OBJECTS then, but it's cleared in Makefile.rules. In the end, it's one line more, but it's not unreasonable right? Maybe I could just keep it.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

400

It turned out, that adding the actual number of compile units to this vector, has a number of scary side effects, which fail tests on the other side of LLDB. I had a closer look at one issue (parsing variables in stack frames for expression evaluation). I could fix this one, but it needs extra code changes. I can imagine these to introduce new silent failures, etc.

I will try again to get the patch more conservative, but it looks more and more like this needs a comprehensive refactoring.

[aprantl]

packages/Python/lldbsuite/test/macosx/debug_map/Makefile

31

One benefit of $^ over spelling the filename out is that it automatically works with the VPATH environment those Makefiles are run in by dotest:

main.o: main.c
    $(CC) -c main.c -o main.o # doesn't work, you need to say $(SRCDIR)/main.c

SRCDIR is a Makefile.rules implementation detail that you need to know about to make sense of the rule, whereas $^ is a automatic variable (https://www.gnu.org/software/make/manual/html_node/Automatic-Variables.html) whose meaning is understandable to everyone familiar with make.

I understand that it looks more cryptic at first, but it keeps the rules shorter and less error-prone in the environment the Makefile is being evaluated in.

include/lldb/Symbol/Symtab.h

public:
   uint32_t GetIndexForSymbol(const Symbol *symbol) const;
   std::recursive_mutex &GetMutex() { return m_mutex; }
   Symbol *FindSymbolByID(lldb::user_id_t uid) const;
   Symbol *SymbolAtIndex(size_t idx);
   const Symbol *SymbolAtIndex(size_t idx) const;
   Symbol *FindSymbolWithType(lldb::SymbolType symbol_type,
                              Debug symbol_debug_type,
                              Visibility symbol_visibility, uint32_t &start_idx);
+
+  bool HasSymbolWithTypeAndFlags(lldb::SymbolType symbol_type,
+                                 uint32_t flags_value) const;
+
   //----------------------------------------------------------------------
   /// Get the parent symbol for the given symbol.
   ///
   /// Many symbols in symbol tables are scoped by other symbols that
   /// contain one or more symbol. This function will look for such a
   /// containing symbol and return it if there is one.
   //----------------------------------------------------------------------
   const Symbol *GetParent(Symbol *symbol) const;

packages/Python/lldbsuite/test/macosx/debug_map/Makefile

+LEVEL = ../../make
+
+# Python script can pass parameters CFLAGS, CFLAGS_CUx, CFLAGS_MAIN and 
+# LD_EXTRAS. For example:
+#
+#     self.build(dictionary={ 
+#       'CFLAGS_CU1': '-flto',
+#       'CFLAGS_CU2': '-flto',
+#       'LD_EXTRAS': '-flto -Xlinker -object_path_lto -Xlinker test_lt12_lto.o'
+#     })
+
+include $(LEVEL)/Makefile.rules
+
+main.o: main.c
+  $(CC) -c $(CFLAGS) $(CFLAGS_MAIN) -o main.o $(SRCDIR)/main.c
+
+cu1.o: cu1.c
+  $(CC) -c $(CFLAGS) $(CFLAGS_CU1) -o cu1.o $(SRCDIR)/cu1.c
+
+cu2.o: cu2.c
+  $(CC) -c $(CFLAGS) $(CFLAGS_CU2) -o cu2.o $(SRCDIR)/cu2.c
+
+cu3.o: cu3.c
+  $(CC) -c $(CFLAGS) $(CFLAGS_CU3) -o cu3.o $(SRCDIR)/cu3.c
+
+a.out: main.o cu1.o cu2.o cu3.o
+  $(LD) main.o cu1.o cu2.o cu3.o -L. $(LDFLAGS) -o a.out

packages/Python/lldbsuite/test/macosx/debug_map/TestDebugMap.py

+"""
+Test breakpoint resolution in DWARF debug map for different LTO and line-tables-only combinations
+"""
+
+from __future__ import print_function
+
+import os
+import time
+import re
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class DebugMapTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    # If your test case doesn't stress debug info, set this to true.
+    # That way it won't be run once for each debug info format.
+    NO_DEBUG_INFO_TESTCASE = False
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def run_to_bp(self, file_name):
+        file = lldb.SBFileSpec(file_name)
+        line_hint = "Set a breakpoint here"
+        return lldbutil.run_to_source_breakpoint(self, line_hint, file)
+
+    def assertFunctionIs(self, halt, name):
+        # halt = (target, process, thread, bkpt)
+        self.assertTrue(halt[2].GetFrameAtIndex(0).GetFunctionName(), name)
+        self.runCmd("continue")
+
+    def check_all_breakpoints(self):
+        halt1 = self.run_to_bp("cu1.c")
+        self.assertFunctionIs(halt1, "cu1_main")
+
+        halt2 = self.run_to_bp("cu2.c")
+        self.assertFunctionIs(halt2, "cu2_main")
+
+        halt3 = self.run_to_bp("cu3.c")
+        self.assertFunctionIs(halt3, "cu3_main")
+
+    def test_bc(self):
+        """Debug map with full debug info and all CUs in one entry"""
+        self.build(dictionary={ 
+            'CFLAGS': '-flto',
+            'LD_EXTRAS': '-flto -Xlinker -object_path_lto -Xlinker test_bc_lto.o'
+        })
+        self.check_all_breakpoints()
+
+    def test_lt(self):
+        """Debug map with line tables only and one CU per entry"""
+        self.build(dictionary={ 
+            'CFLAGS': '-gline-tables-only',
+            'LD_EXTRAS': '-gline-tables-only'
+        })
+        self.check_all_breakpoints()
+
+    def test_bc12(self):
+        """Debug map with full debug info and order of entries: main.o, test_lt12_lto.o, cu3.o"""
+        # Note: actual order of entries is expected to become: main.o, cu3.o, test_lt12_lto.o
+        self.build(dictionary={ 
+            'CFLAGS_CU1': '-flto',
+            'CFLAGS_CU2': '-flto',
+            'LD_EXTRAS': '-flto -Xlinker -object_path_lto -Xlinker test_lt12_lto.o'
+        })
+        self.check_all_breakpoints()
+
+    def test_bc23(self):
+        """Debug map with full debug info and order of entries: test_lt01_lto.o, cu2.o, cu3.o"""
+        # Note: actual order of entries is expected to become: cu2.o, cu3.o, test_lt01_lto.o
+        self.build(dictionary={ 
+            'CFLAGS_CU1': '-flto',
+            'CFLAGS_MAIN': '-flto',
+            'LD_EXTRAS': '-flto -Xlinker -object_path_lto -Xlinker test_lt01_lto.o'
+        })
+        self.check_all_breakpoints()
+
+    def test_bc12_lt12(self):
+        """Debug map with line tables only in LTO sources"""
+        self.build(dictionary={
+            'CFLAGS_CU1': '-flto -gline-tables-only',
+            'CFLAGS_CU2': '-flto -gline-tables-only',
+            'LD_EXTRAS': '-flto -Xlinker -object_path_lto -Xlinker test_bc12_lt12_lto.o'
+        })
+        self.check_all_breakpoints()
+
+    def test_bc12_lt2(self):
+        """Debug map with line tables only in one of the LTO sources"""
+        self.build(dictionary={
+            'CFLAGS_CU1': '-flto',
+            'CFLAGS_CU2': '-flto -gline-tables-only',
+            'LD_EXTRAS': '-flto -Xlinker -object_path_lto -Xlinker test_bc12_lt2_lto.o'
+        })
+        self.check_all_breakpoints()
+
+    def test_bc12_lt3(self):
+        """Debug map with line tables only in a non-LTO entry"""
+        self.build(dictionary={
+            'CFLAGS_CU1': '-flto',
+            'CFLAGS_CU2': '-flto',
+            'CFLAGS_CU3': '-gline-tables-only',
+            'LD_EXTRAS': '-flto -Xlinker -object_path_lto -Xlinker test_bc12_lt3_lto.o'
+        })
+        self.check_all_breakpoints()
+
+    def test_bc12_stripped(self):
+        """Debug map with missing LTO sources"""
+        self.build(dictionary={
+            'CFLAGS_CU1': '-flto',
+            'CFLAGS_CU2': '-flto',
+            'LD_EXTRAS': '-flto'
+        })
+        only_halt = self.run_to_bp("cu3.c")
+        self.assertFunctionIs(only_halt, "cu3_main")

packages/Python/lldbsuite/test/macosx/debug_map/cu1.h

+int cu1_main(int n);

packages/Python/lldbsuite/test/macosx/debug_map/cu1.c

+#include "cu1.h"
+
+int cu1_main(int n) {
+  return n + 1; // Set a breakpoint here
+}

packages/Python/lldbsuite/test/macosx/debug_map/cu2.h

+int cu2_main(int n);

packages/Python/lldbsuite/test/macosx/debug_map/cu2.c

+#include "cu2.h"
+
+int cu2_main(int n) {
+  return n + 2; // Set a breakpoint here
+}

packages/Python/lldbsuite/test/macosx/debug_map/cu3.h

+int cu3_main(int n);

packages/Python/lldbsuite/test/macosx/debug_map/cu3.c

+#include "cu3.h"
+
+int cu3_main(int n) {
+  return n - 3; // Set a breakpoint here
+}

packages/Python/lldbsuite/test/macosx/debug_map/main.c

+#include "cu1.h"
+#include "cu2.h"
+#include "cu3.h"
+
+int main(int argc, char **argv) {
+  int cu1_res = cu1_main(argc - 1); // +1
+  int cu2_res = cu2_main(cu1_res); //  +2
+  int cu3_res = cu3_main(cu2_res); //  -3
+  return cu3_res;
+}

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

void DWARFUnit::BuildAddressRangeTable(SymbolFileDWARF *dwarf,
   // This function is usually called if there in no .debug_aranges section in
   // order to produce a compile unit level set of address ranges that is
   // accurate.
 
   size_t num_debug_aranges = debug_aranges->GetNumRanges();
 
   // First get the compile unit DIE only and check if it has a DW_AT_ranges
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
 
   const dw_offset_t cu_offset = GetOffset();
   if (die) {
     DWARFRangeList ranges;
+
+    // DW_AT_low/high_pc attributes of DW_TAG_compile_unit are no suitable
+    // fallback for deducing code address ranges. It can have outdated data or
+    // result in overlapping ranges, e.g. if the CUs actual code is interleaved.
+    // Instead BuildAddressRangeTable() below will index the DWARF and generate
+    // the address ranges table manually, based on DW_AT_low/high_pc attributes
+    // of nested DW_TAG_subprogram tags.
+    static constexpr bool check_hi_lo_pc = false;
     const size_t num_ranges =
-        die->GetAttributeAddressRanges(dwarf, this, ranges, false);
+        die->GetAttributeAddressRanges(dwarf, this, ranges, check_hi_lo_pc);
+
     if (num_ranges > 0) {
       // This compile unit has DW_AT_ranges, assume this is correct if it is
       // present since clang no longer makes .debug_aranges by default and it
       // emits DW_AT_ranges for DW_TAG_compile_units. GCC also does this with
       // recent GCC builds.
       for (size_t i = 0; i < num_ranges; ++i) {
         const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
         debug_aranges->AppendRange(cu_offset, range.GetRangeBase(),
void DWARFUnit::BuildAddressRangeTable(SymbolFileDWARF *dwarf,
 
   die = DIEPtr();
   if (die)
     die->BuildAddressRangeTable(dwarf, this, debug_aranges);
 
   if (debug_aranges->GetNumRanges() == num_debug_aranges) {
     // We got nothing from the functions, maybe we have a line tables only
     // situation. Check the line tables and build the arange table from this.
     SymbolContext sc;
     sc.comp_unit = dwarf->GetCompUnitForDWARFCompUnit(this);
     if (sc.comp_unit) {
       SymbolFileDWARFDebugMap *debug_map_sym_file =
           m_dwarf->GetDebugMapSymfile();
       if (debug_map_sym_file == NULL) {
         LineTable *line_table = sc.comp_unit->GetLineTable();
 
         if (line_table) {
           LineTable::FileAddressRanges file_ranges;
           const bool append = true;
           const size_t num_ranges =
               line_table->GetContiguousFileAddressRanges(file_ranges, append);
           for (uint32_t idx = 0; idx < num_ranges; ++idx) {
             const LineTable::FileAddressRanges::Entry &range =
                 file_ranges.GetEntryRef(idx);
             debug_aranges->AppendRange(cu_offset, range.GetRangeBase(),
                                        range.GetRangeEnd());
           }
         }
       } else
-        debug_map_sym_file->AddOSOARanges(dwarf, debug_aranges);
+        debug_map_sym_file->AddOSOARanges(dwarf, cu_offset, debug_aranges);
     }
   }
 
   if (debug_aranges->GetNumRanges() == num_debug_aranges) {
     // We got nothing from the functions, maybe we have a line tables only
     // situation. Check the line tables and build the arange table from this.
     SymbolContext sc;
     sc.comp_unit = dwarf->GetCompUnitForDWARFCompUnit(this);
     if (sc.comp_unit) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   DWARFDIE
   GetDeclContextDIEContainingDIE(const DWARFDIE &die);
 
   bool
   HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type);
 
   lldb_private::CompileUnit *
   GetCompUnitForDWARFCompUnit(DWARFUnit *dwarf_cu,
-                              uint32_t cu_idx = UINT32_MAX);
+                              uint32_t cu_idx = DW_INVALID_INDEX);
 
   virtual size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
                                          DIEArray &method_die_offsets);
 
   bool Supports_DW_AT_APPLE_objc_complete_type(DWARFUnit *cu);
 
   lldb_private::DebugMacrosSP ParseDebugMacros(lldb::offset_t *offset);
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (dwarf_cu) {
     CompileUnit *comp_unit = (CompileUnit *)dwarf_cu->GetUserData();
     if (comp_unit) {
       // We already parsed this compile unit, had out a shared pointer to it
       cu_sp = comp_unit->shared_from_this();
     } else {
       if (dwarf_cu->GetSymbolFileDWARF() != this) {
         return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu,
                                                                 cu_idx);
-      } else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile()) {
+      } else if (SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile()) {
+        assert(debug_map == m_debug_map_symfile &&
+               "debug_map is a nested instance derived from SymbolFile, "
+               "NOT SymbolFileDWARF");
+
         // Let the debug map create the compile unit
-        cu_sp = m_debug_map_symfile->GetCompileUnit(this);
+        if (debug_map->GetNumCompileUnits() == 1) {
+          cu_sp = debug_map->GetCompileUnit(this);
+        } else if (cu_idx != UINT32_MAX) {
+          cu_sp = debug_map->GetCompileUnitByIndex(this, cu_idx);
+        } else {
+          lldb::offset_t cu_offset = dwarf_cu->GetOffset();
+          if (cu_offset != DW_INVALID_OFFSET) {
+            cu_sp = debug_map->GetCompileUnitByOffset(this, cu_offset);
+          } else {
+            llvm_unreachable("Need more info to find the correct CU");
+          }
+        }
+
         dwarf_cu->SetUserData(cu_sp.get());
       } else {
         ModuleSP module_sp(m_obj_file->GetModule());
         if (module_sp) {
           const DWARFDIE cu_die = dwarf_cu->DIE();
           if (cu_die) {
             FileSpec cu_file_spec{cu_die.GetName(), false};
             if (cu_file_spec) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
 protected:
-  enum { kHaveInitializedOSOs = (1 << 0), kNumFlags };
+  enum {
+    kHaveInitializedOSOs = (1 << 0),
+    kHaveCheckedCUInfos = (1 << 1),
+    kNumFlags
+  };
 
   friend class DebugMapModule;
   friend struct DIERef;
   friend class DWARFASTParserClang;
   friend class DWARFUnit;
   friend class SymbolFileDWARF;
   struct OSOInfo {
     lldb::ModuleSP module_sp;
struct CompileUnitInfo {
     bool file_range_map_valid;
 
     CompileUnitInfo()
         : so_file(), oso_path(), oso_mod_time(), oso_sp(), compile_unit_sp(),
           first_symbol_index(UINT32_MAX), last_symbol_index(UINT32_MAX),
           first_symbol_id(UINT32_MAX), last_symbol_id(UINT32_MAX),
           file_range_map(), file_range_map_valid(false) {}
 
+    bool Init(lldb_private::Symbol *so, lldb_private::Symbol *oso);
     const FileRangeMap &GetFileRangeMap(SymbolFileDWARFDebugMap *exe_symfile);
   };
 
   //------------------------------------------------------------------
   // Protected Member Functions
   //------------------------------------------------------------------
   void InitOSO();
+  bool HasCompileUnits();
+  void ReportErrorInitOSO(lldb_private::Symbol *so_symbol,
+                          lldb_private::Symbol *oso_symbol, uint32_t oso_idx);
 
   static uint32_t GetOSOIndexFromUserID(lldb::user_id_t uid) {
     return (uint32_t)((uid >> 32ull) - 1ull);
   }
 
   static SymbolFileDWARF *GetSymbolFileAsSymbolFileDWARF(SymbolFile *sym_file);
 
   bool GetFileSpecForSO(uint32_t oso_idx, lldb_private::FileSpec &file_spec);
uint32_t PrivateFindGlobalVariables(
       const std::vector<uint32_t> &name_symbol_indexes, uint32_t max_matches,
       lldb_private::VariableList &variables);
 
   void SetCompileUnit(SymbolFileDWARF *oso_dwarf,
                       const lldb::CompUnitSP &cu_sp);
 
   lldb::CompUnitSP GetCompileUnit(SymbolFileDWARF *oso_dwarf);
 
+  lldb::CompUnitSP GetCompileUnitByIndex(SymbolFileDWARF *oso_dwarf,
+                                         uint32_t cu_idx);
+  lldb::CompUnitSP GetCompileUnitByOffset(SymbolFileDWARF *oso_dwarf,
+                                          dw_offset_t cu_offset);
+
   CompileUnitInfo *GetCompileUnitInfo(SymbolFileDWARF *oso_dwarf);
 
   lldb::TypeSP
   FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx);
 
   bool Supports_DW_AT_APPLE_objc_complete_type(SymbolFileDWARF *skip_dwarf_oso);
 
   lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
protected:
 
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, OSOEntry>
       DebugMap;
 
   //------------------------------------------------------------------
   // Member Variables
   //------------------------------------------------------------------
   std::bitset<kNumFlags> m_flags;
+  bool m_has_compile_unit_infos;
+  std::vector<lldb::offset_t> m_oso_compile_unit_offset;
   std::vector<CompileUnitInfo> m_compile_unit_infos;
   std::vector<uint32_t> m_func_indexes; // Sorted by address
   std::vector<uint32_t> m_glob_indexes;
   std::map<std::pair<lldb_private::ConstString, llvm::sys::TimePoint<>>,
            OSOInfoSP>
       m_oso_map;
   UniqueDWARFASTTypeMap m_unique_ast_type_map;
   lldb_private::LazyBool m_supports_DW_AT_APPLE_objc_complete_type;
protected:
   ///     Returns a valid line table full of linked addresses, or NULL
   ///     if none of the line table addresses exist in the main
   ///     executable.
   //------------------------------------------------------------------
   lldb_private::LineTable *
   LinkOSOLineTable(SymbolFileDWARF *oso_symfile,
                    lldb_private::LineTable *line_table);
 
-  size_t AddOSOARanges(SymbolFileDWARF *dwarf2Data,
+  size_t AddOSOARanges(SymbolFileDWARF *dwarf2Data, dw_offset_t cu_offset,
                        DWARFDebugAranges *debug_aranges);
 };
 
 #endif // #ifndef SymbolFileDWARF_SymbolFileDWARFDebugMap_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/VariableList.h"
 #include "llvm/Support/ScopedPrinter.h"
 
+#include "DWARFCompileUnit.h"
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARF.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // Subclass lldb_private::Module so we can intercept the
 // "Module::GetObjectFile()" (so we can fixup the object file sections) and
for (auto comp_unit_info : cu_infos) {
       exe_symfile->FinalizeOSOFileRanges(this);
       // We don't need the symbols anymore for the .o files
       oso_objfile->ClearSymtab();
     }
   }
   return file_range_map;
 }
 
+bool SymbolFileDWARFDebugMap::CompileUnitInfo::Init(Symbol *so, Symbol *oso) {
+  if (!so || so->GetType() != eSymbolTypeSourceFile)
+    return false;
+
+  if (!oso || oso->GetType() != eSymbolTypeObjectFile)
+    return false;
+
+  if (so->GetSiblingIndex() == UINT32_MAX)
+    return false;
+
+  llvm::StringRef so_file_name = so->GetName().GetStringRef();
+  so_file.SetFile(so_file_name, false, FileSpec::Style::native);
+  oso_mod_time = llvm::sys::toTimePoint(oso->GetIntegerValue(0));
+  oso_path = oso->GetName();
+  return true;
+}
+
 class DebugMapModule : public Module {
 public:
   DebugMapModule(const ModuleSP &exe_module_sp, uint32_t cu_idx,
                  const FileSpec &file_spec, const ArchSpec &arch,
                  const ConstString *object_name, off_t object_offset,
                  const llvm::sys::TimePoint<> object_mod_time)
       : Module(file_spec, arch, object_name, object_offset, object_mod_time),
         m_exe_module_wp(exe_module_sp), m_cu_idx(cu_idx) {}
const char *SymbolFileDWARFDebugMap::GetPluginDescriptionStatic() {
   return "DWARF and DWARF3 debug symbol file reader (debug map).";
 }
 
 SymbolFile *SymbolFileDWARFDebugMap::CreateInstance(ObjectFile *obj_file) {
   return new SymbolFileDWARFDebugMap(obj_file);
 }
 
 SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap(ObjectFile *ofile)
-    : SymbolFile(ofile), m_flags(), m_compile_unit_infos(), m_func_indexes(),
-      m_glob_indexes(),
+    : SymbolFile(ofile), m_flags(), m_has_compile_unit_infos(false),
+      m_compile_unit_infos(), m_func_indexes(), m_glob_indexes(),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
 
 SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap() {}
 
 void SymbolFileDWARFDebugMap::InitializeObject() {}
 
-void SymbolFileDWARFDebugMap::InitOSO() {
-  if (m_flags.test(kHaveInitializedOSOs))
-    return;
-
-  m_flags.set(kHaveInitializedOSOs);
-
-  // If the object file has been stripped, there is no sense in looking further
-  // as all of the debug symbols for the debug map will not be available
-  if (m_obj_file->IsStripped())
-    return;
-
-  // Also make sure the file type is some sort of executable. Core files, debug
-  // info files (dSYM), object files (.o files), and stub libraries all can
-  switch (m_obj_file->GetType()) {
+static bool IsExecutableType(ObjectFile::Type type) {
+  switch (type) {
   case ObjectFile::eTypeInvalid:
   case ObjectFile::eTypeCoreFile:
   case ObjectFile::eTypeDebugInfo:
   case ObjectFile::eTypeObjectFile:
   case ObjectFile::eTypeStubLibrary:
   case ObjectFile::eTypeUnknown:
   case ObjectFile::eTypeJIT:
-    return;
+    return false;
 
   case ObjectFile::eTypeExecutable:
   case ObjectFile::eTypeDynamicLinker:
   case ObjectFile::eTypeSharedLibrary:
-    break;
-  }
+    return true;
+  }
 
-  // In order to get the abilities of this plug-in, we look at the list of
-  // N_OSO entries (object files) from the symbol table and make sure that
-  // these files exist and also contain valid DWARF. If we get any of that then
-  // we return the abilities of the first N_OSO's DWARF.
+static uint32_t GetOSOSymbolFlags() {
+  // When a mach-o symbol is encoded, the n_type field is encoded in bits
+  // 23:16, and the n_desc field is encoded in bits 15:0.
+  //
+  // N_OSO object file symbols have a flags value as follows:
+  // bits 23:16 == 0x66 (N_OSO)
+  // bits 15: 0 == 0x0001 (specifies this is a debug map object file)
+  return 0x660001u;
+}
+
+void SymbolFileDWARFDebugMap::InitOSO() {
+  if (m_flags.test(kHaveInitializedOSOs))
+    return;
+
+  m_flags.set(kHaveInitializedOSOs);
+
+  // If the object file has been stripped, there is no sense in looking further
+  // as all of the debug symbols for the debug map will not be available
+  if (m_obj_file->IsStripped())
+    return;
+
+  // Also make sure the file type is some sort of executable.
+  if (!IsExecutableType(m_obj_file->GetType()))
+    return;
 
   Symtab *symtab = m_obj_file->GetSymtab();
   if (symtab) {
     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
 
     std::vector<uint32_t> oso_indexes;
-    // When a mach-o symbol is encoded, the n_type field is encoded in bits
-    // 23:16, and the n_desc field is encoded in bits 15:0.
-    //
-    // To find all N_OSO entries that are part of the DWARF + debug map we find
-    // only object file symbols with the flags value as follows: bits 23:16 ==
-    // 0x66 (N_OSO) bits 15: 0 == 0x0001 (specifies this is a debug map object
-    // file)
-    const uint32_t k_oso_symbol_flags_value = 0x660001u;
+    const uint32_t k_oso_symbol_flags_value = GetOSOSymbolFlags();
 
     const uint32_t oso_index_count =
         symtab->AppendSymbolIndexesWithTypeAndFlagsValue(
             eSymbolTypeObjectFile, k_oso_symbol_flags_value, oso_indexes);
 
     if (oso_index_count > 0) {
       symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugYes,
                                           Symtab::eVisibilityAny,
if (oso_index_count > 0) {
         lldb::addr_t file_addr = symbol->GetAddressRef().GetFileAddress();
         lldb::addr_t byte_size = symbol->GetByteSize();
         DebugMap::Entry debug_map_entry(
             file_addr, byte_size, OSOEntry(sym_idx, LLDB_INVALID_ADDRESS));
         m_debug_map.Append(debug_map_entry);
       }
       m_debug_map.Sort();
 
-      m_compile_unit_infos.resize(oso_index_count);
+      assert(m_compile_unit_infos.empty());
+      assert(m_oso_compile_unit_offset.empty());
 
       for (uint32_t i = 0; i < oso_index_count; ++i) {
         const uint32_t so_idx = oso_indexes[i] - 1;
         const uint32_t oso_idx = oso_indexes[i];
-        const Symbol *so_symbol = symtab->SymbolAtIndex(so_idx);
-        const Symbol *oso_symbol = symtab->SymbolAtIndex(oso_idx);
-        if (so_symbol && oso_symbol &&
-            so_symbol->GetType() == eSymbolTypeSourceFile &&
-            oso_symbol->GetType() == eSymbolTypeObjectFile) {
-          m_compile_unit_infos[i].so_file.SetFile(
-              so_symbol->GetName().AsCString(), false, FileSpec::Style::native);
-          m_compile_unit_infos[i].oso_path = oso_symbol->GetName();
-          m_compile_unit_infos[i].oso_mod_time =
-              llvm::sys::toTimePoint(oso_symbol->GetIntegerValue(0));
+        Symbol *so_symbol = symtab->SymbolAtIndex(so_idx);
+        Symbol *oso_symbol = symtab->SymbolAtIndex(oso_idx);
+
+        // oso_info is the basis for the individual cu_infos below.
+        CompileUnitInfo oso_info;
+        if (!oso_info.Init(so_symbol, oso_symbol)) {
+          ReportErrorInitOSO(so_symbol, oso_symbol, oso_idx);
+          continue;
+        }
+
+        SymbolFileDWARF *sym_file = GetSymbolFileByCompUnitInfo(&oso_info);
+        if (!sym_file)
+          continue;
+
+        const auto &debug_info_data = sym_file->get_debug_info_data();
+        auto ExtractNext = [sym_file, &debug_info_data](lldb::offset_t offs) {
+          return DWARFCompileUnit::Extract(sym_file, debug_info_data, &offs);
+        };
+
+        for (DWARFUnitSP cu_sp = ExtractNext(0); cu_sp != nullptr;
+             cu_sp = ExtractNext(cu_sp->GetNextCompileUnitOffset())) {
+          // FIXME: Multiple OSO entries with multiple CUs may be a rare, but
+          // while I am here, I should store CU OFFSETS BY OSO ENTRY! It may
+          // move to m_oso_entry_info.
+          m_oso_compile_unit_offset.push_back(cu_sp->GetOffset());
+
+          // Make a copy of the oso_info and add compile unit specific data.
+          //
+          // FIXME: There is no CU-specific data currently, because symbol
+          // ranges are the same for all CUs and the offset is stored
+          // separately. It may be turned into a m_oso_entry_info.
+          m_compile_unit_infos.push_back(oso_info);
+          CompileUnitInfo &cu_info = m_compile_unit_infos.back();
+
           uint32_t sibling_idx = so_symbol->GetSiblingIndex();
-          // The sibling index can't be less that or equal to the current index
-          // "i"
-          if (sibling_idx == UINT32_MAX) {
-            m_obj_file->GetModule()->ReportError(
-                "N_SO in symbol with UID %u has invalid sibling in debug map, "
-                "please file a bug and attach the binary listed in this error",
-                so_symbol->GetID());
-          } else {
-            const Symbol *last_symbol = symtab->SymbolAtIndex(sibling_idx - 1);
-            m_compile_unit_infos[i].first_symbol_index = so_idx;
-            m_compile_unit_infos[i].last_symbol_index = sibling_idx - 1;
-            m_compile_unit_infos[i].first_symbol_id = so_symbol->GetID();
-            m_compile_unit_infos[i].last_symbol_id = last_symbol->GetID();
+
+          // For (regular) objects with only one compile unit, there is a
+          // bidirectional mapping between a symtab slice and a compile unit.
+          // LTO objects do not allow such a mapping and so we assign the full
+          // symtab range to all compile units of the same oso_entry.
+          cu_info.first_symbol_index = so_idx;
+          cu_info.last_symbol_index = sibling_idx - 1;
+          cu_info.first_symbol_id = so_symbol->GetID();
+          cu_info.last_symbol_id = last_symbol->GetID();
+        }
 
-            if (log)
-              log->Printf("Initialized OSO 0x%8.8x: file=%s", i,
-                          oso_symbol->GetName().GetCString());
-          }
-        } else {
-          if (oso_symbol == NULL)
-            m_obj_file->GetModule()->ReportError(
-                "N_OSO symbol[%u] can't be found, please file a bug and attach "
-                "the binary listed in this error",
-                oso_idx);
-          else if (so_symbol == NULL)
-            m_obj_file->GetModule()->ReportError(
-                "N_SO not found for N_OSO symbol[%u], please file a bug and "
-                "attach the binary listed in this error",
-                oso_idx);
-          else if (so_symbol->GetType() != eSymbolTypeSourceFile)
-            m_obj_file->GetModule()->ReportError(
-                "N_SO has incorrect symbol type (%u) for N_OSO symbol[%u], "
-                "please file a bug and attach the binary listed in this error",
-                so_symbol->GetType(), oso_idx);
-          else if (oso_symbol->GetType() != eSymbolTypeSourceFile)
-            m_obj_file->GetModule()->ReportError(
-                "N_OSO has incorrect symbol type (%u) for N_OSO symbol[%u], "
-                "please file a bug and attach the binary listed in this error",
-                oso_symbol->GetType(), oso_idx);
-        }
-      }
-    }
-  }
+    }
+  }
+}
+
+void SymbolFileDWARFDebugMap::ReportErrorInitOSO(Symbol *so_symbol,
+                                                 Symbol *oso_symbol,
+                                                 uint32_t oso_idx) {
+  else if (so_symbol->GetSiblingIndex() == UINT32_MAX)
+    m_obj_file->GetModule()->ReportError(
+        "N_SO in symbol with UID %u has invalid sibling in debug map, "
+        "please file a bug and attach the binary listed in this error",
+        so_symbol->GetID());
 }
 
 Module *SymbolFileDWARFDebugMap::GetModuleByOSOIndex(uint32_t oso_idx) {
   const uint32_t cu_count = GetNumCompileUnits();
   if (oso_idx < cu_count)
     return GetModuleByCompUnitInfo(&m_compile_unit_infos[oso_idx]);
   return NULL;
 }
SymbolFileDWARF *SymbolFileDWARFDebugMap::GetSymbolFileByCompUnitInfo(
   return NULL;
 }
 
 uint32_t SymbolFileDWARFDebugMap::CalculateAbilities() {
   // In order to get the abilities of this plug-in, we look at the list of
   // N_OSO entries (object files) from the symbol table and make sure that
   // these files exist and also contain valid DWARF. If we get any of that then
   // we return the abilities of the first N_OSO's DWARF.
-
-  const uint32_t oso_index_count = GetNumCompileUnits();
-  if (oso_index_count > 0) {
-    InitOSO();
-    if (!m_compile_unit_infos.empty()) {
-      return SymbolFile::CompileUnits | SymbolFile::Functions |
-             SymbolFile::Blocks | SymbolFile::GlobalVariables |
-             SymbolFile::LocalVariables | SymbolFile::VariableTypes |
-             SymbolFile::LineTables;
-    }
-  }
+  if (HasCompileUnits())
+
   return 0;
 }
 
+bool SymbolFileDWARFDebugMap::HasCompileUnits() {
+  if (m_flags.test(kHaveCheckedCUInfos))
+    return m_has_compile_unit_infos;
+
+  m_flags.set(kHaveCheckedCUInfos);
+
+  // If the object file has been stripped, there is no sense in looking further
+  // as all of the debug symbols for the debug map will not be available.
+  //
+  // FIXME: This should be renamed to IsStrippedOrMissing()
+  if (m_obj_file->IsStripped())
+    return false;
+
+  if (!IsExecutableType(m_obj_file->GetType()))
+    return false;
+
+  assert(m_has_compile_unit_infos == false && "Arrive here only once");
+
+  if (Symtab *symtab = m_obj_file->GetSymtab())
+    m_has_compile_unit_infos = symtab->HasSymbolWithTypeAndFlags(
+        eSymbolTypeObjectFile, GetOSOSymbolFlags());
+
+  return m_has_compile_unit_infos;
+}
+
 uint32_t SymbolFileDWARFDebugMap::GetNumCompileUnits() {
   InitOSO();
   return m_compile_unit_infos.size();
 }
 
 CompUnitSP SymbolFileDWARFDebugMap::ParseCompileUnitAtIndex(uint32_t cu_idx) {
   CompUnitSP comp_unit_sp;
   const uint32_t cu_count = GetNumCompileUnits();
 
   if (cu_idx < cu_count) {
     Module *oso_module = GetModuleByCompUnitInfo(&m_compile_unit_infos[cu_idx]);
     if (oso_module) {
       FileSpec so_file_spec;
       if (GetFileSpecForSO(cu_idx, so_file_spec)) {
-        // User zero as the ID to match the compile unit at offset zero in each
-        // .o file since each .o file can only have one compile unit for now.
-        lldb::user_id_t cu_id = 0;
-        m_compile_unit_infos[cu_idx].compile_unit_sp.reset(
-            new CompileUnit(m_obj_file->GetModule(), NULL, so_file_spec, cu_id,
-                            eLanguageTypeUnknown, eLazyBoolCalculate));
+        lldb::user_id_t cu_offset = m_oso_compile_unit_offset[cu_idx];
+        m_compile_unit_infos[cu_idx].compile_unit_sp.reset(new CompileUnit(
+            m_obj_file->GetModule(), NULL, so_file_spec, cu_offset,
 
         if (m_compile_unit_infos[cu_idx].compile_unit_sp) {
           // Let our symbol vendor know about this compile unit
           m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
               cu_idx, m_compile_unit_infos[cu_idx].compile_unit_sp);
         }
       }
     }
if (symtab) {
     if (debug_map_entry) {
 
       sc.symbol =
           symtab->SymbolAtIndex(debug_map_entry->data.GetExeSymbolIndex());
 
       if (sc.symbol != NULL) {
         resolved_flags |= eSymbolContextSymbol;
 
+        // FIXME: Search by symbol Index/ID will NOT return the correct info for
+        // objects with multiple compile units. We cannot safely match slices of
+        // the symtab with individual units (it's very likely that optimization
+        // mixed it up), and so all compile units from such objects share the
+        // full symbol range.
+        //
+        // For the moment this is not a problem here, because we only use the
+        // compile unit info to find the module, which is invariant across all
+        // compile units of one object file.
         uint32_t oso_idx = 0;
         CompileUnitInfo *comp_unit_info =
             GetCompileUnitInfoForSymbolWithID(sc.symbol->GetID(), &oso_idx);
         if (comp_unit_info) {
           comp_unit_info->GetFileRangeMap(this);
           Module *oso_module = GetModuleByCompUnitInfo(comp_unit_info);
           if (oso_module) {
             lldb::addr_t oso_file_addr =
for (uint32_t cu_idx = 0; cu_idx < cu_count; ++cu_idx) {
 
         return m_compile_unit_infos[cu_idx].compile_unit_sp;
       }
     }
   }
   llvm_unreachable("this shouldn't happen");
 }
 
+lldb::CompUnitSP
+SymbolFileDWARFDebugMap::GetCompileUnitByIndex(SymbolFileDWARF *oso_dwarf,
+                                               uint32_t cu_idx) {
+  assert(cu_idx < GetNumCompileUnits() && "CU index out of range");
+  auto &cu_info = m_compile_unit_infos[cu_idx];
+  if (!cu_info.compile_unit_sp)
+    cu_info.compile_unit_sp = ParseCompileUnitAtIndex(cu_idx);
+
+  return cu_info.compile_unit_sp;
+}
+
+lldb::CompUnitSP
+SymbolFileDWARFDebugMap::GetCompileUnitByOffset(SymbolFileDWARF *oso_dwarf,
+                                                dw_offset_t cu_offset) {
+  auto begin = m_oso_compile_unit_offset.begin();
+  auto end = m_oso_compile_unit_offset.end();
+  auto it = std::lower_bound(begin, end, cu_offset);
+
+  if (it != end) {
+    uint32_t cu_idx = std::distance(begin, it);
+    return GetCompileUnitByIndex(oso_dwarf, cu_idx);
+  }
+
+  return nullptr;
+}
+
 SymbolFileDWARFDebugMap::CompileUnitInfo *
 SymbolFileDWARFDebugMap::GetCompileUnitInfo(SymbolFileDWARF *oso_dwarf) {
   if (oso_dwarf) {
     const uint32_t cu_count = GetNumCompileUnits();
     for (uint32_t cu_idx = 0; cu_idx < cu_count; ++cu_idx) {
       SymbolFileDWARF *oso_symfile =
           GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[cu_idx]);
       if (oso_symfile == oso_dwarf) {
bool SymbolFileDWARFDebugMap::LinkOSOAddress(Address &addr) {
   Module *addr_module = addr.GetModule().get();
   if (addr_module == exe_module)
     return true; // Address is already in terms of the main executable module
 
   CompileUnitInfo *cu_info = GetCompileUnitInfo(GetSymbolFileAsSymbolFileDWARF(
       addr_module->GetSymbolVendor()->GetSymbolFile()));
   if (cu_info) {
     const lldb::addr_t oso_file_addr = addr.GetFileAddress();
+
+    // FIXME: Search by symbol Index/ID will NOT return the correct info for
+    // objects with multiple compile units. We cannot safely match slices of
+    // the symtab with individual units (it's very likely that optimization
+    // mixed it up), and so all compile units from such objects share the
+    // full symbol range.
+    //
+    // For the moment this is not a problem here, because we only use the
+    // compile unit info to find the module, which is invariant across all
+    // compile units of one object file.
     const FileRangeMap::Entry *oso_range_entry =
         cu_info->GetFileRangeMap(this).FindEntryThatContains(oso_file_addr);
     if (oso_range_entry) {
       const DebugMap::Entry *debug_map_entry =
           m_debug_map.FindEntryThatContains(oso_range_entry->data);
       if (debug_map_entry) {
         const lldb::addr_t offset =
             oso_file_addr - oso_range_entry->GetRangeBase();
LineTable *SymbolFileDWARFDebugMap::LinkOSOLineTable(SymbolFileDWARF *oso_dwarf,
   CompileUnitInfo *cu_info = GetCompileUnitInfo(oso_dwarf);
   if (cu_info)
     return line_table->LinkLineTable(cu_info->GetFileRangeMap(this));
   return NULL;
 }
 
 size_t
 SymbolFileDWARFDebugMap::AddOSOARanges(SymbolFileDWARF *dwarf2Data,
+                                       dw_offset_t cu_offset,
                                        DWARFDebugAranges *debug_aranges) {
+  // For OSO debug map entries with multiple CUs, we can't map between symtab
+  // entries and CUs. Thus, each CU's FileRangeMap will be populated from the
+  // entire symtab range of that OSO debug map entry. The loop below would add
+  // invalid entries (from other CUs of this OSO debug map entry) and we had to
+  // test each of them in SymbolFileDWARF::ResolveSymbolContext().
+  if (m_compile_unit_infos.size() > 1)
+    return 0;
+
   size_t num_line_entries_added = 0;
   if (debug_aranges && dwarf2Data) {
     CompileUnitInfo *compile_unit_info = GetCompileUnitInfo(dwarf2Data);
     if (compile_unit_info) {
       const FileRangeMap &file_range_map =
           compile_unit_info->GetFileRangeMap(this);
       for (size_t idx = 0; idx < file_range_map.GetSize(); idx++) {
         const FileRangeMap::Entry *entry = file_range_map.GetEntryAtIndex(idx);
         if (entry) {
-          debug_aranges->AppendRange(dwarf2Data->GetID(), entry->GetRangeBase(),
+          debug_aranges->AppendRange(cu_offset, entry->GetRangeBase(),
                                      entry->GetRangeEnd());
           num_line_entries_added++;
         }
       }
     }
   }
   return num_line_entries_added;
 }

source/Symbol/Symtab.cpp

if ((symbol_type == eSymbolTypeAny ||
          m_symbols[i].GetType() == symbol_type) &&
         m_symbols[i].GetFlags() == flags_value)
       indexes.push_back(i);
   }
 
   return indexes.size() - prev_size;
 }
 
+bool Symtab::HasSymbolWithTypeAndFlags(lldb::SymbolType symbol_type,
+                                       uint32_t flags_value) const {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  for (const Symbol &symbol : m_symbols)
+    if (symbol.GetType() == symbol_type && symbol.GetFlags() == flags_value)
+      return true;
+
+  return false;
+}
+
 uint32_t Symtab::AppendSymbolIndexesWithType(SymbolType symbol_type,
                                              Debug symbol_debug_type,
                                              Visibility symbol_visibility,
                                              std::vector<uint32_t> &indexes,
                                              uint32_t start_idx,
                                              uint32_t end_index) const {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);