DWARF: Add support for type units+split dwarf combo

[labath]

Summary

With the last round of refactors, supporting type units in dwo files
becomes almost trivial. This patch contains a couple of small fixes,
which taken as a whole make type units work in the split dwarf scenario
(both DWARF4 and DWARF5):

• DWARFContext: make sure we actually read the debug_types.dwo section
• DWARFUnit: set string offsets base on all units in the dwo file, not just the main CU
• ManualDWARFIndex: index all units in the file
• SymbolFileDWARFDwo: Search for the single compile unit in the file, as we can no longer assume it will be the first one

The last part makes it obvious that there is still some work to be done
here, namely that we do not support dwo files with multiple compile
units. That is something that should be easier after the DIERef
refactors, but it still requires more work.

Tests are added for the type units+split dwarf + dwarf4/5 scenarios, as
well as a test that checks we behave reasonably in the presence of dwo
files with multiple CUs.

[JDevlieghere]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

77

Is this here to ensure that there's no two candidates? Initially I was pretty confused by this, I think it's worth a comment.

[labath]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

77

Yes, that's it. If you know of a nicer way to implement that search, I'd like to hear it. For now, I've just put some comments around this.

[labath]

Add some comments in SymbolFileDWARFDwo::ComputeCompileUnit

lit/SymbolFile/DWARF/debug-types-basic.test

 # REQUIRES: lld
 
 # Make sure DWARF v4 type units work.
 # RUN: %clangxx -target x86_64-pc-linux %S/Inputs/debug-types-basic.cpp \
-# RUN:   -g -gdwarf-4 -fdebug-types-section -c -o %t.o
-# RUN: ld.lld %t.o -o %t
-# RUN: %lldb %t -s %s -o exit | FileCheck %s
+# RUN:   -g -gdwarf-4 -fdebug-types-section -c -o %t4.o
+# RUN: ld.lld %t4.o -o %t4
+# RUN: %lldb %t4 -s %s -o exit | FileCheck %s
 
 # Now do the same for DWARF v5.
 # RUN: %clangxx -target x86_64-pc-linux %S/Inputs/debug-types-basic.cpp \
-# RUN:   -g -gdwarf-5 -fdebug-types-section -c -o %t.o
-# RUN: ld.lld %t.o -o %t
-# RUN: %lldb %t -s %s -o exit | FileCheck %s
+# RUN:   -g -gdwarf-5 -fdebug-types-section -c -o %t5.o
+# RUN: ld.lld %t5.o -o %t5
+# RUN: %lldb %t5 -s %s -o exit | FileCheck %s
+
+# Test type units in dwo files.
+# RUN: %clangxx -target x86_64-pc-linux %S/Inputs/debug-types-basic.cpp \
+# RUN:   -g -gdwarf-4 -fdebug-types-section -gsplit-dwarf -c -o %t4dwo.o
+# RUN: ld.lld %t4dwo.o -o %t4dwo
+# RUN: %lldb %t4dwo -s %s -o exit | FileCheck %s
+
+# And type units+dwo+dwarf5.
+# RUN: %clangxx -target x86_64-pc-linux %S/Inputs/debug-types-basic.cpp \
+# RUN:   -g -gdwarf-5 -fdebug-types-section -c -o %t5dwo.o
+# RUN: ld.lld %t5dwo.o -o %t5dwo
+# RUN: %lldb %t5dwo -s %s -o exit | FileCheck %s
 
 type lookup A
 # CHECK-LABEL: type lookup A
 # CHECK:      struct A {
 # CHECK-NEXT:   int i;
 # CHECK-NEXT:   long l;
 # CHECK-NEXT:   float f;
 # CHECK-NEXT:   double d;

lit/SymbolFile/DWARF/debug-types-expressions.test

 # UNSUPPORTED: system-darwin, system-windows
 
 # Make sure DWARF v4 type units work.
 # RUN: %clangxx %S/Inputs/debug-types-expressions.cpp \
-# RUN:   -g -fdebug-types-section -o %t
-# RUN: %lldb %t -s %s -o exit | FileCheck %s
+# RUN:   -g -gdwarf-4 -fdebug-types-section -o %t4
+# RUN: %lldb %t4 -s %s -o exit | FileCheck %s
 
 # Now do the same for DWARF v5.
 # RUN: %clangxx %S/Inputs/debug-types-expressions.cpp \
-# RUN:   -g -gdwarf-5 -fdebug-types-section -o %t
-# RUN: %lldb %t -s %s -o exit | FileCheck %s
+# RUN:   -g -gdwarf-5 -fdebug-types-section -o %t5
+# RUN: %lldb %t5 -s %s -o exit | FileCheck %s
+
+# Test type units in dwo files.
+# RUN: %clangxx %S/Inputs/debug-types-expressions.cpp \
+# RUN:   -g -gdwarf-4 -fdebug-types-section -o %t4dwo
+# RUN: %lldb %t4dwo -s %s -o exit | FileCheck %s
+
+# And type units+dwo+dwarf5.
+# RUN: %clangxx %S/Inputs/debug-types-expressions.cpp \
+# RUN:   -g -gdwarf-5 -fdebug-types-section -o %t5dwo
+# RUN: %lldb %t5dwo -s %s -o exit | FileCheck %s
 
 breakpoint set -n foo
 process launch
 
 # CHECK: Process {{.*}} stopped
 
 frame variable a
 # CHECK-LABEL: frame variable a

lit/SymbolFile/DWARF/split-dwarf-multiple-cu.ll

+; Check handling of dwo files with multiple compile units. Right now this is not
+; supported, but it should not cause us to crash or misbehave either...
+
+; RUN: llc %s -filetype=obj -o %t.o --split-dwarf-file=%t.o
+; RUN: %lldb %t.o -o "image lookup -s x1 -v" -o "image lookup -s x2 -v" -b | FileCheck %s
+
+; CHECK: image lookup -s x1
+; CHECK: 1 symbols match 'x1'
+; CHECK-NOT: CompileUnit:
+; CHECK-NOT: Variable:
+
+; CHECK: image lookup -s x2
+; CHECK: 1 symbols match 'x2'
+; CHECK-NOT: CompileUnit:
+; CHECK-NOT: Variable:
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@x1 = dso_local global i32 42, align 4, !dbg !10
+@x2 = dso_local global i32 47, align 4, !dbg !20
+
+!llvm.dbg.cu = !{!12, !22}
+!llvm.module.flags = !{!8, !9, !1}
+
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
+!11 = distinct !DIGlobalVariable(name: "x1", scope: !12, type: !7)
+!12 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, emissionKind: FullDebug, globals: !15)
+!15 = !{!10}
+
+!20 = !DIGlobalVariableExpression(var: !21, expr: !DIExpression())
+!21 = distinct !DIGlobalVariable(name: "x2", scope: !22, type: !7)
+!22 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, emissionKind: FullDebug, globals: !25)
+!25 = !{!20}
+
+!3 = !DIFile(filename: "-", directory: "/tmp")
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = !{i32 1, !"wchar_size", i32 4}

source/Plugins/SymbolFile/DWARF/DWARFContext.cpp

 
 const DWARFDataExtractor &DWARFContext::getOrLoadStrOffsetsData() {
   return LoadOrGetSection(eSectionTypeDWARFDebugStrOffsets,
                           eSectionTypeDWARFDebugStrOffsetsDwo,
                           m_data_debug_str_offsets);
 }
 
 const DWARFDataExtractor &DWARFContext::getOrLoadDebugTypesData() {
-  return LoadOrGetSection(eSectionTypeDWARFDebugTypes, llvm::None,
-                          m_data_debug_types);
+  return LoadOrGetSection(eSectionTypeDWARFDebugTypes,
+                          eSectionTypeDWARFDebugTypesDwo, m_data_debug_types);
 }

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 
 #include "llvm/Support/LEB128.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
 
-#include "DWARFUnit.h"
+#include "DWARFCompileUnit.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
+#include "DWARFUnit.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb_private;
 using namespace std;
 extern int g_verbose;
 
 // Extract a debug info entry for a given DWARFUnit from the data
dw_offset_t DWARFDebugInfoEntry::GetAttributeValue(
 
   // If we're a unit DIE, also check the attributes of the dwo unit (if any).
   if (GetParent())
     return 0;
   SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
   if (!dwo_symbol_file)
     return 0;
 
-  DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
+  DWARFCompileUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
   if (!dwo_cu)
     return 0;
 
   DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
   if (!dwo_cu_die.IsValid())
     return 0;
 
   return dwo_cu_die.GetDIE()->GetAttributeValue(

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

void DWARFUnit::AddUnitDIE(const DWARFDebugInfoEntry &cu_die) {
   else if (gnu_addr_base)
     dwo_cu->SetAddrBase(*gnu_addr_base);
 
   if (ranges_base)
     dwo_cu->SetRangesBase(*ranges_base);
   else if (gnu_ranges_base)
     dwo_cu->SetRangesBase(*gnu_ranges_base);
 
-  SetDwoStrOffsetsBase(dwo_cu);
+  for(size_t i = 0; i < m_dwo_symbol_file->DebugInfo()->GetNumUnits(); ++i) {
+    DWARFUnit *unit = m_dwo_symbol_file->DebugInfo()->GetUnitAtIndex(i);
+    SetDwoStrOffsetsBase(unit);
+  }
 }
 
 DWARFDIE DWARFUnit::LookupAddress(const dw_addr_t address) {
   if (DIE()) {
     const DWARFDebugAranges &func_aranges = GetFunctionAranges();
 
     // Re-check the aranges auto pointer contents in case it was created above
     if (!func_aranges.IsEmpty())

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

m_module.LogMessage(
         log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[0x%8.8x]",
         unit.GetOffset());
   }
 
   const LanguageType cu_language = unit.GetLanguageType();
 
   IndexUnitImpl(unit, cu_language, set);
 
-  SymbolFileDWARFDwo *dwo_symbol_file = unit.GetDwoSymbolFile();
-  if (dwo_symbol_file && dwo_symbol_file->GetCompileUnit()) {
-    IndexUnitImpl(*dwo_symbol_file->GetCompileUnit(), cu_language, set);
+  if (SymbolFileDWARFDwo *dwo_symbol_file = unit.GetDwoSymbolFile()) {
+    DWARFDebugInfo &dwo_info = *dwo_symbol_file->DebugInfo();
+    for (size_t i = 0; i < dwo_info.GetNumUnits(); ++i)
+      IndexUnitImpl(*dwo_info.GetUnitAtIndex(i), cu_language, set);
   }
 }
 
 void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit,
                                      const LanguageType cu_language,
                                      IndexSet &set) {
   for (const DWARFDebugInfoEntry &die : unit.dies()) {
     const dw_tag_t tag = die.Tag();

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

 class SymbolFileDWARFDwo : public SymbolFileDWARF {
 public:
   SymbolFileDWARFDwo(lldb::ObjectFileSP objfile, DWARFCompileUnit &dwarf_cu);
 
   ~SymbolFileDWARFDwo() override = default;
 
   lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit &dwarf_cu) override;
 
-  DWARFUnit *GetCompileUnit();
+  DWARFCompileUnit *GetCompileUnit();
 
   DWARFUnit *
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) override;
 
   lldb_private::DWARFExpression::LocationListFormat
   GetLocationListFormat() const override;
 
   size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
lldb::TypeSP FindDefinitionTypeForDWARFDeclContext(
       const DWARFDeclContext &die_decl_ctx) override;
 
   lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, lldb_private::ConstString type_name,
       bool must_be_implementation) override;
 
   SymbolFileDWARF &GetBaseSymbolFile();
 
+  DWARFCompileUnit *ComputeCompileUnit();
+
   lldb::ObjectFileSP m_obj_file_sp;
   DWARFCompileUnit &m_base_dwarf_cu;
+  DWARFCompileUnit *m_cu = nullptr;
 };
 
 #endif // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

 //===-- SymbolFileDWARFDwo.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileDWARFDwo.h"
 
 #include "lldb/Core/Section.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/LLDBAssert.h"
+#include "llvm/Support/Casting.h"
 
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFUnit.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

 lldb::CompUnitSP
 SymbolFileDWARFDwo::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) {
   assert(GetCompileUnit() == &dwarf_cu &&
          "SymbolFileDWARFDwo::ParseCompileUnit called with incompatible "
          "compile unit");
   return GetBaseSymbolFile().ParseCompileUnit(m_base_dwarf_cu);
 }
 
-DWARFUnit *SymbolFileDWARFDwo::GetCompileUnit() {
-  // Only dwo files with 1 compile unit is supported
-  if (GetNumCompileUnits() == 1)
-    return DebugInfo()->GetUnitAtIndex(0);
-  else
+DWARFCompileUnit *SymbolFileDWARFDwo::GetCompileUnit() {
+  if (!m_cu)
+    m_cu = ComputeCompileUnit();
+  return m_cu;
+}
+
+DWARFCompileUnit *SymbolFileDWARFDwo::ComputeCompileUnit() {
+  // Only dwo files with 1 compile unit are supported
+  DWARFDebugInfo *debug_info = DebugInfo();
+  if (!debug_info)
     return nullptr;
+
+  if (!debug_info->ContainsTypeUnits() && debug_info->GetNumUnits() == 1)
+    return llvm::cast<DWARFCompileUnit>(debug_info->GetUnitAtIndex(0));
+
+  DWARFCompileUnit *cu = nullptr;
+  for (size_t i = 0; i < debug_info->GetNumUnits(); ++i) {
+    if (auto *candidate =
+            llvm::dyn_cast<DWARFCompileUnit>(debug_info->GetUnitAtIndex(i))) {
+      if (cu)
+        return nullptr;
+      cu = candidate;
+    }
+  }
+  return cu;
 }
 
 DWARFUnit *
 SymbolFileDWARFDwo::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) {
   return GetCompileUnit();
 }
 
 SymbolFileDWARF::DIEToTypePtr &SymbolFileDWARFDwo::GetDIEToType() {