DWARF: Introduce DWARFTypeUnit class

[labath]

Summary

This patch introduces the DWARFTypeUnit class, and teaches lldb to parse
type units out of both the debug_types section (DWARF v4), and from the
regular debug_info section (DWARF v5).

The most important piece of functionality - resolving DW_AT_signatures
to connect type forward declarations to their definitions - is not
implemented here, but even without that, a lot of functionality becomes
available. I've added tests for the commands that start to work after
this patch.

The changes in this patch were greatly inspired by D61505, which in turn took
over changes from D32167.

[jankratochvil]

On Fedora 29 x86_64 I get:

FAIL: LLDB :: SymbolFile/DWARF/debug-types-basic.test (123 of 1636)
******************** TEST 'LLDB :: SymbolFile/DWARF/debug-types-basic.test' FAILED ********************
Script:
--
: 'RUN: at line 3';   /home/jkratoch/redhat/llvm-monorepo-clangassert/bin/clang --driver-mode=g++ -pthread -target x86_64-pc-linux /home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/Inputs/debug-types-basic.cpp    -g -fdebug-types-section -c -o /home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/lit/SymbolFile/DWARF/Output/debug-types-basic.test.tmp.o
: 'RUN: at line 5';   /home/jkratoch/redhat/llvm-monorepo-clangassert/bin/ld.lld /home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/lit/SymbolFile/DWARF/Output/debug-types-basic.test.tmp.o -o /home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/lit/SymbolFile/DWARF/Output/debug-types-basic.test.tmp
: 'RUN: at line 6';   /home/jkratoch/redhat/llvm-monorepo-clangassert/bin/lldb --no-lldbinit -S /home/jkratoch/redhat/llvm-monorepo/lldb/lit/lit-lldb-init /home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/lit/SymbolFile/DWARF/Output/debug-types-basic.test.tmp -s /home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-basic.test -o exit | /home/jkratoch/redhat/llvm-monorepo-clangassert/bin/FileCheck /home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-basic.test
--
Exit Code: 1

Command Output (stderr):
--
ld.lld: warning: cannot find entry symbol _start; defaulting to 0x201000
warning: (x86_64) /home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/lit/SymbolFile/DWARF/Output/debug-types-basic.test.tmp lldb doesn’t support .debug_types debug info
error: use of undeclared identifier 'E'
/home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-basic.test:10:10: error: CHECK: expected string not found in input
# CHECK: struct A {
         ^
<stdin>:11:1: note: scanning from here
no type was found matching 'A'
^
<stdin>:11:11: note: possible intended match here
no type was found matching 'A'
          ^
/home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-basic.test:19:10: error: CHECK: expected string not found in input
# CHECK: enum E {
         ^
<stdin>:13:1: note: scanning from here
no type was found matching 'E'
^
<stdin>:14:15: note: possible intended match here
(lldb) type lookup EC
              ^
/home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-basic.test:27:10: error: CHECK: expected string not found in input
# CHECK: enum class EC {
         ^
<stdin>:15:1: note: scanning from here
no type was found matching 'EC'
^
<stdin>:15:24: note: possible intended match here
no type was found matching 'EC'
                       ^
/home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-basic.test:38:16: error: CHECK-LABEL: expected string not found in input
# CHECK-LABEL: print (EC) 1
               ^
<stdin>:17:1: note: scanning from here
(lldb) exit
^
<stdin>:17:8: note: possible intended match here
(lldb) exit
       ^

--

********************
FAIL: LLDB :: SymbolFile/DWARF/debug-types-expressions.test (144 of 1636)
******************** TEST 'LLDB :: SymbolFile/DWARF/debug-types-expressions.test' FAILED ********************
Script:
--
: 'RUN: at line 3';   /home/jkratoch/redhat/llvm-monorepo-clangassert/bin/clang --driver-mode=g++ -pthread /home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/Inputs/debug-types-expressions.cpp    -g -fdebug-types-section -o /home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/lit/SymbolFile/DWARF/Output/debug-types-expressions.test.tmp
: 'RUN: at line 5';   /home/jkratoch/redhat/llvm-monorepo-clangassert/bin/lldb --no-lldbinit -S /home/jkratoch/redhat/llvm-monorepo/lldb/lit/lit-lldb-init /home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/lit/SymbolFile/DWARF/Output/debug-types-expressions.test.tmp -s /home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-expressions.test -o exit | /home/jkratoch/redhat/llvm-monorepo-clangassert/bin/FileCheck /home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-expressions.test
--
Exit Code: 1

Command Output (stderr):
--
warning: (x86_64) /home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/lit/SymbolFile/DWARF/Output/debug-types-expressions.test.tmp lldb doesn’t support .debug_types debug info
error: Multiple internal symbols found for 'a'
id = {0x00000e8f}, range = [0x00001555552e2348-0x00001555552e2350), name="a"
id = {0x000003ee}, range = [0x00001555552a1c78-0x00001555552a1c80), name="a"
id = {0x00000b5d}, range = [0x00001555552e2348-0x00001555552e2350), name="a"
id = {0x00000d17}, range = [0x00001555552e2348-0x00001555552e2350), name="a"

error: use of undeclared identifier 'a'
/home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-expressions.test:14:10: error: CHECK: expected string not found in input
# CHECK: (B *) a =
         ^
<stdin>:24:1: note: scanning from here
(lldb) print a->f()
^
/home/jkratoch/redhat/llvm-monorepo/lldb/lit/SymbolFile/DWARF/debug-types-expressions.test:21:16: error: CHECK-LABEL: expected string not found in input
# CHECK-LABEL: print ns::A()
               ^
<stdin>:25:1: note: scanning from here
(lldb) exit
^
<stdin>:25:8: note: possible intended match here
(lldb) exit
       ^

--

********************
Testing Time: 88.82s
********************
Failing Tests (2):
    LLDB :: SymbolFile/DWARF/debug-types-basic.test
    LLDB :: SymbolFile/DWARF/debug-types-expressions.test

  Expected Passes    : 1587
  Expected Failures  : 1
  Unsupported Tests  : 46
  Unexpected Failures: 2

[labath]

In D62008#1504845, @jankratochvil wrote:

On Fedora 29 x86_64 I get:
...

Ah, sorry I forgot to include the part which removes the run-away-screaming-if-you-see-debug_types check. I had that in a separate commit and I didn't squash. I'll fix that in a second...

[labath]

• don't bail out if you see the debug_types section
• rename a variable in the test to work around the old "Multiple internal symbols found for 'a'" problem

[labath]

• rebase on top of the DWARFUnitHeader patch

[labath]

Replying here as this is the relevant patch.

In D62073#1507063, @clayborg wrote:

Are type units still disabled with the kill switch we had in? Or is this on top of the .debug_types patch? We have an internal .debug_types patch we have been using on an older LLVM/Clang/LLDB and we had some major performance issues regarding line tables so I am not sure where we would need to put these fixes (in this patch or in the .debug_types specific patch. This patch seems to enable parsing .debug_types already. The main issue we ran into were:

• only search actual compile unit line tables for breakpoints as many .debug_type units will point to existing line tables from real compile units
• don't add address ranges to type unit DWARFUnits from the line tables
• re-work how support files are parsed by sharing the line tables within a SymbolFileDWARF. .debug_types has type units that reuse line tables from real compile units (thousands of times) and we ended up seeing the same line table being parsed over and over and over. Another way to fix this is to no vend a lldb_private::CompileUnit for any units that aren't really compile units (DW_UT_type and DW_UT_split_type).

So if this patch is enabling all this, we will need to fix this patch to avoid all of the above mentioned issues. Let me know your thoughts.

Thanks for the heads up. This is a pretty good to-do list. I was aware of some of these things already (like the address ranges thing), but in the spirit of the incremental development policy, I deliberately tried to keep this patch small. I already have a patch for to stop adding address ranges for type units, but I didn't upload it yet, as I am still working on the test (that's the reason I side-stepped into dwarf5 a bit, because I believe it will make creating the test easier). Another thing, which this patch does not enable yet is the resolution of DW_AT_signatures, so with this patch alone you will be able to look up types, but not link them to variables. I also put that in a separate patch, because it was possible to do so. One more big feature, which is completely broken right now, is the combination of dwo+type units. For that I don't have a patch yet, and making that work is probably going to take a bit longer.

For these reason I don't think it's reasonable to put all of these things into one big patch, and have a fully functional and optimised implementation from the start -- having things working 100% immediately is very unlikely and a large patch increases the likelyhood of breaking unrelated things. I think we should start with this patch. The address ranges patch and DW_AT_signature thingy, can come pretty much immediately after that. These are the only things (that I am aware of) which impact correctness, so we could have an implementation ready for general audience to try out as early as the end of this week. After that the road splits up a bit, and we can proceed in several directions (e.g. I'm hoping that DWO support can be mostly independent of the line table optimizations). I might even be able to get some help with that, so that we increase our velocity here, once the initial building blocks are in place.

As for the "kill switch", I am open to keeping it in, but make it conditional on some setting or environment variable, until the implementation is more stable. However, I also don't think it's really necessary, as I believe we will have something sufficiently functional very quickly. (and even a slightly wonky experience is better than just refusing to debug a binary outright, imo)

[clayborg]

Ok, as long as we get things in soon, some functionality is better than none.

[aprantl]

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

29

[This is more a meta-point and I don't care very strongly about it]
For a test of the DWARF parser, is it necessary to actually attach to a running process, or could we statically inspect the types of, e.g., global variables with target var or something?

[labath]

Thanks. We can always re-add the check if things take longer than expected.

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

29

Yes and no. :)

I believe a lot of things can be tested without a running process, and I've tried to make use of that as much as possible. However, it is my understanding (though it's still a fairly fuzzy one) that target/frame variable and the expression evaluator use the debug info differently.

That's why I've created two tests here. The "basic" one does not require a running process and can run anywhere. I think of this as the first line of defense. Then, if anything slips past that, there's the "expression" test, which will try to use the debug info from the expression evaluator. That one requires us to be able to generate type units for the target platform (i.e., elf only at the moment).

lit/SymbolFile/DWARF/Inputs/debug-types-basic.cpp

+struct A {
+  int i;
+  long l;
+  float f;
+  double d;
+};
+
+enum E { e1, e2, e3 };
+enum class EC { e1, e2, e3 };
+
+extern constexpr A a{42, 47l, 4.2f, 4.7};
+extern constexpr E e(e2);
+extern constexpr EC ec(EC::e2);

lit/SymbolFile/DWARF/Inputs/debug-types-expressions.cpp

+struct A {
+  int i = 47;
+  int f() { return i; }
+  virtual ~A() = default;
+};
+
+struct B: public A {
+  int j = 42;
+};
+
+namespace ns {
+struct A {
+  int i = 147;
+  A();
+};
+A::A() = default;
+}
+
+int foo(A *a) {
+  return a->f();
+}
+
+int main() {
+  return foo(new B);
+}

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
+
+# 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
+
+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;
+# CHECK-NEXT: }
+
+type lookup E
+# CHECK-LABEL: type lookup E
+# CHECK:      enum E {
+# CHECK-NEXT:   e1,
+# CHECK-NEXT:   e2,
+# CHECK-NEXT:   e3
+# CHECK-NEXT: }
+
+type lookup EC
+# CHECK-LABEL: type lookup EC
+# CHECK:      enum class EC {
+# CHECK-NEXT:   e1,
+# CHECK-NEXT:   e2,
+# CHECK-NEXT:   e3
+# CHECK-NEXT: }
+
+print (E) 1
+# CHECK-LABEL: print (E) 1
+# CHECK: (E) $0 = e2
+
+print (EC) 1
+# CHECK-LABEL: print (EC) 1
+# CHECK: (EC) $1 = e2

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
+
+# 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
+
+breakpoint set -n foo
+process launch
+
+# CHECK: Process {{.*}} stopped
+
+frame variable a
+# CHECK-LABEL: frame variable a
+# CHECK: (B *) a =
+
+print a->f()
+# CHECK-LABEL: print a->f()
+# CHECK: (int) $0 = 47
+
+print ns::A()
+# CHECK-LABEL: print ns::A()
+# CHECK: (ns::A) $1 = (i = 147)

lit/SymbolFile/DWARF/lit.local.cfg

-config.suffixes = ['.cpp', '.s']
+config.suffixes = ['.cpp', '.s', '.test']

source/Plugins/SymbolFile/DWARF/CMakeLists.txt

add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
   DWARFDebugLine.cpp
   DWARFDebugMacro.cpp
   DWARFDebugRanges.cpp
   DWARFDeclContext.cpp
   DWARFDefines.cpp
   DWARFDIE.cpp
   DWARFFormValue.cpp
   DWARFIndex.cpp
+  DWARFTypeUnit.cpp
   DWARFUnit.cpp
   HashedNameToDIE.cpp
   LogChannelDWARF.cpp
   ManualDWARFIndex.cpp
   NameToDIE.cpp
   SymbolFileDWARF.cpp
   SymbolFileDWARFDwo.cpp
   SymbolFileDWARFDwoDwp.cpp

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

 
 #include "DWARFUnit.h"
 #include "llvm/Support/Error.h"
 
 class DWARFCompileUnit : public DWARFUnit {
 public:
   void Dump(lldb_private::Stream *s) const override;
 
-  DIERef::Section GetDebugSection() const override {
-    return DIERef::Section::DebugInfo;
-  }
-
 private:
   DWARFCompileUnit(SymbolFileDWARF *dwarf, lldb::user_id_t uid,
                    const DWARFUnitHeader &header,
-                   const DWARFAbbreviationDeclarationSet &abbrevs)
-      : DWARFUnit(dwarf, uid, header, abbrevs) {}
+                   const DWARFAbbreviationDeclarationSet &abbrevs,
+                   DIERef::Section section)
+      : DWARFUnit(dwarf, uid, header, abbrevs, section) {}
 
   DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
 
   friend class DWARFUnit;
 };
 
 #endif // SymbolFileDWARF_DWARFCompileUnit_h_

source/Plugins/SymbolFile/DWARF/DWARFContext.h

private:
   llvm::Optional<DWARFDataExtractor> m_data_debug_addr;
   llvm::Optional<DWARFDataExtractor> m_data_debug_aranges;
   llvm::Optional<DWARFDataExtractor> m_data_debug_info;
   llvm::Optional<DWARFDataExtractor> m_data_debug_line;
   llvm::Optional<DWARFDataExtractor> m_data_debug_line_str;
   llvm::Optional<DWARFDataExtractor> m_data_debug_macro;
   llvm::Optional<DWARFDataExtractor> m_data_debug_str;
   llvm::Optional<DWARFDataExtractor> m_data_debug_str_offsets;
+  llvm::Optional<DWARFDataExtractor> m_data_debug_types;
 
   bool isDwo() { return m_dwo_section_list != nullptr; }
 
 public:
   explicit DWARFContext(SectionList *main_section_list,
                         SectionList *dwo_section_list)
       : m_main_section_list(main_section_list),
         m_dwo_section_list(dwo_section_list) {}
 
   const DWARFDataExtractor &getOrLoadAbbrevData();
   const DWARFDataExtractor &getOrLoadAddrData();
   const DWARFDataExtractor &getOrLoadArangesData();
   const DWARFDataExtractor &getOrLoadDebugInfoData();
   const DWARFDataExtractor &getOrLoadLineData();
   const DWARFDataExtractor &getOrLoadLineStrData();
   const DWARFDataExtractor &getOrLoadMacroData();
   const DWARFDataExtractor &getOrLoadStrData();
   const DWARFDataExtractor &getOrLoadStrOffsetsData();
+  const DWARFDataExtractor &getOrLoadDebugTypesData();
 };
 } // namespace lldb_private
 
 #endif

source/Plugins/SymbolFile/DWARF/DWARFContext.cpp

 
 const DWARFDataExtractor &DWARFContext::getOrLoadStrOffsetsData() {
   if (isDwo())
     return LoadOrGetSection(m_dwo_section_list, eSectionTypeDWARFDebugStrOffsetsDwo,
                             m_data_debug_str_offsets);
   return LoadOrGetSection(m_main_section_list, eSectionTypeDWARFDebugStrOffsets,
                           m_data_debug_str_offsets);
 }
+
+const DWARFDataExtractor &DWARFContext::getOrLoadDebugTypesData() {
+  return LoadOrGetSection(m_main_section_list, eSectionTypeDWARFDebugTypes,
+                          m_data_debug_types);
+}

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

 #include "lldb/Utility/Stream.h"
 
 #include "DWARFCompileUnit.h"
 #include "DWARFContext.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFFormValue.h"
+#include "DWARFTypeUnit.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 // Constructor
 DWARFDebugInfo::DWARFDebugInfo(lldb_private::DWARFContext &context)
     : m_dwarf2Data(NULL), m_context(context), m_units(), m_cu_aranges_up() {}
if (cus_with_data.find(offset) == cus_with_data.end())
       cu->BuildAddressRangeTable(m_cu_aranges_up.get());
   }
 
   const bool minimize = true;
   m_cu_aranges_up->Sort(minimize);
   return *m_cu_aranges_up;
 }
 
-void DWARFDebugInfo::ParseUnitHeadersIfNeeded() {
-  if (!m_units.empty())
-    return;
-  if (!m_dwarf2Data)
-    return;
-
+void Parse(SymbolFileDWARF *dwarf, const DWARFDataExtractor &data,
+           DIERef::Section section, std::vector<DWARFUnitSP> &units) {
   lldb::offset_t offset = 0;
-  const auto &debug_info_data = m_context.getOrLoadDebugInfoData();
-  while (debug_info_data.ValidOffset(offset)) {
-    llvm::Expected<DWARFUnitSP> unit_sp = DWARFUnit::extract(
-        m_dwarf2Data, m_units.size(), debug_info_data, &offset);
+  while (data.ValidOffset(offset)) {
+    llvm::Expected<DWARFUnitSP> unit_sp =
+        DWARFUnit::extract(dwarf, units.size(), data, section, &offset);
 
     if (!unit_sp) {
       // FIXME: Propagate this error up.
       llvm::consumeError(unit_sp.takeError());
       return;
     }
 
     // If it didn't return an error, then it should be returning a valid Unit.
     assert(*unit_sp);
 
-    m_units.push_back(*unit_sp);
+    units.push_back(*unit_sp);
 
     offset = (*unit_sp)->GetNextUnitOffset();
   }
 }
 
+void DWARFDebugInfo::ParseUnitHeadersIfNeeded() {
+  if (!m_units.empty())
+    return;
+  if (!m_dwarf2Data)
+    return;
+
+  Parse(m_dwarf2Data, m_context.getOrLoadDebugInfoData(),
+        DIERef::Section::DebugInfo, m_units);
+  Parse(m_dwarf2Data, m_context.getOrLoadDebugTypesData(),
+        DIERef::Section::DebugTypes, m_units);
+}
+
 size_t DWARFDebugInfo::GetNumUnits() {
   ParseUnitHeadersIfNeeded();
   return m_units.size();
 }
 
 DWARFUnit *DWARFDebugInfo::GetUnitAtIndex(user_id_t idx) {
   DWARFUnit *cu = NULL;
   if (idx < GetNumUnits())

source/Plugins/SymbolFile/DWARF/DWARFTypeUnit.h

+//===-- DWARFTypeUnit.h -----------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SymbolFileDWARF_DWARFTypeUnit_h_
+#define SymbolFileDWARF_DWARFTypeUnit_h_
+
+#include "DWARFUnit.h"
+#include "llvm/Support/Error.h"
+
+class DWARFTypeUnit : public DWARFUnit {
+public:
+  void Dump(lldb_private::Stream *s) const override;
+
+private:
+  DWARFTypeUnit(SymbolFileDWARF *dwarf, lldb::user_id_t uid,
+                const DWARFUnitHeader &header,
+                const DWARFAbbreviationDeclarationSet &abbrevs,
+                DIERef::Section section)
+      : DWARFUnit(dwarf, uid, header, abbrevs, section) {}
+
+  friend class DWARFUnit;
+};
+
+#endif // SymbolFileDWARF_DWARFTypeUnit_h_

source/Plugins/SymbolFile/DWARF/DWARFTypeUnit.cpp

+//===-- DWARFTypeUnit.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 "DWARFTypeUnit.h"
+
+#include "SymbolFileDWARF.h"
+#include "lldb/Utility/Stream.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+
+void DWARFTypeUnit::Dump(Stream *s) const {
+  s->Printf("0x%8.8x: Type Unit: length = 0x%8.8x, version = 0x%4.4x, "
+            "abbr_offset = 0x%8.8x, addr_size = 0x%2.2x (next CU at "
+            "{0x%8.8x})\n",
+            GetOffset(), GetLength(), GetVersion(), GetAbbrevOffset(),
+            GetAddressByteSize(), GetNextUnitOffset());
+}

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   dw_offset_t GetAbbrOffset() const { return m_abbr_offset; }
   uint8_t GetUnitType() const { return m_unit_type; }
   bool IsTypeUnit() const {
     return m_unit_type == DW_UT_type || m_unit_type == DW_UT_split_type;
   }
   uint32_t GetNextUnitOffset() const { return m_offset + m_length + 4; }
 
   static llvm::Expected<DWARFUnitHeader>
-  extract(const lldb_private::DWARFDataExtractor &data,
+  extract(const lldb_private::DWARFDataExtractor &data, DIERef::Section section,
           lldb::offset_t *offset_ptr);
 };
 
 class DWARFUnit : public lldb_private::UserID {
   using die_iterator_range =
       llvm::iterator_range<DWARFDebugInfoEntry::collection::iterator>;
 
 public:
   static llvm::Expected<DWARFUnitSP>
   extract(SymbolFileDWARF *dwarf2Data, lldb::user_id_t uid,
           const lldb_private::DWARFDataExtractor &debug_info,
-          lldb::offset_t *offset_ptr);
+          DIERef::Section section, lldb::offset_t *offset_ptr);
   virtual ~DWARFUnit();
 
   void ExtractUnitDIEIfNeeded();
   void ExtractDIEsIfNeeded();
 
   class ScopedExtractDIEs {
     DWARFUnit *m_cu;
   public:
public:
 
   dw_offset_t GetBaseObjOffset() const;
 
   die_iterator_range dies() {
     ExtractDIEsIfNeeded();
     return die_iterator_range(m_die_array.begin(), m_die_array.end());
   }
 
-  virtual DIERef::Section GetDebugSection() const = 0;
+  DIERef::Section GetDebugSection() const { return m_section; }
 
 protected:
   DWARFUnit(SymbolFileDWARF *dwarf, lldb::user_id_t uid,
             const DWARFUnitHeader &header,
-            const DWARFAbbreviationDeclarationSet &abbrevs);
+            const DWARFAbbreviationDeclarationSet &abbrevs,
+            DIERef::Section section);
+
+  llvm::Error ExtractHeader(SymbolFileDWARF *dwarf,
+                            const lldb_private::DWARFDataExtractor &data,
+                            lldb::offset_t *offset_ptr);
 
   SymbolFileDWARF *m_dwarf = nullptr;
   std::unique_ptr<SymbolFileDWARFDwo> m_dwo_symbol_file;
   DWARFUnitHeader m_header;
   const DWARFAbbreviationDeclarationSet *m_abbrevs = nullptr;
   void *m_user_data = nullptr;
   // The compile unit debug information entry item
   DWARFDebugInfoEntry::collection m_die_array;
protected:
   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
   llvm::Optional<lldb_private::FileSpec> m_comp_dir;
   dw_addr_t m_addr_base = 0;   // Value of DW_AT_addr_base
   dw_addr_t m_ranges_base = 0; // Value of DW_AT_ranges_base
   // If this is a dwo compile unit this is the offset of the base compile unit
   // in the main object file
   dw_offset_t m_base_obj_offset = DW_INVALID_OFFSET;
   dw_offset_t m_str_offsets_base = 0; // Value of DW_AT_str_offsets_base.
+  const DIERef::Section m_section;
 
 private:
   void ParseProducerInfo();
   void ExtractDIEsRWLocked();
   void ClearDIEsRWLocked();
 
   // Get the DWARF unit DWARF debug informration entry. Parse the single DIE
   // if needed.

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/Object/Error.h"
 
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
+#include "DWARFTypeUnit.h"
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 extern int g_verbose;
 
 DWARFUnit::DWARFUnit(SymbolFileDWARF *dwarf, lldb::user_id_t uid,
                      const DWARFUnitHeader &header,
-                     const DWARFAbbreviationDeclarationSet &abbrevs)
+                     const DWARFAbbreviationDeclarationSet &abbrevs,
+                     DIERef::Section section)
     : UserID(uid), m_dwarf(dwarf), m_header(header), m_abbrevs(&abbrevs),
-      m_cancel_scopes(false) {}
+      m_cancel_scopes(false), m_section(section) {}
 
 DWARFUnit::~DWARFUnit() = default;
 
 // Parses first DIE of a compile unit.
 void DWARFUnit::ExtractUnitDIEIfNeeded() {
   {
     llvm::sys::ScopedReader lock(m_first_die_mutex);
     if (m_first_die)
if (m_func_aranges_up == NULL) {
 
     const bool minimize = false;
     m_func_aranges_up->Sort(minimize);
   }
   return *m_func_aranges_up;
 }
 
 llvm::Expected<DWARFUnitHeader>
-DWARFUnitHeader::extract(const DWARFDataExtractor &data,
+DWARFUnitHeader::extract(const DWARFDataExtractor &data, DIERef::Section section,
                          lldb::offset_t *offset_ptr) {
   DWARFUnitHeader header;
   header.m_offset = *offset_ptr;
   header.m_length = data.GetDWARFInitialLength(offset_ptr);
   header.m_version = data.GetU16(offset_ptr);
   if (header.m_version == 5) {
     header.m_unit_type = data.GetU8(offset_ptr);
     header.m_addr_size = data.GetU8(offset_ptr);
     header.m_abbr_offset = data.GetDWARFOffset(offset_ptr);
     if (header.m_unit_type == llvm::dwarf::DW_UT_skeleton)
       header.m_dwo_id = data.GetU64(offset_ptr);
   } else {
     header.m_abbr_offset = data.GetDWARFOffset(offset_ptr);
     header.m_addr_size = data.GetU8(offset_ptr);
-    // Only compile units supported so far.
-    header.m_unit_type = DW_UT_compile;
+    header.m_unit_type =
+        section == DIERef::Section::DebugTypes ? DW_UT_type : DW_UT_compile;
   }
 
   bool length_OK = data.ValidOffset(header.GetNextUnitOffset() - 1);
   bool version_OK = SymbolFileDWARF::SupportedVersion(header.m_version);
   bool addr_size_OK = (header.m_addr_size == 4) || (header.m_addr_size == 8);
 
   if (!length_OK)
     return llvm::make_error<llvm::object::GenericBinaryError>(
         "Invalid unit length");
   if (!version_OK)
     return llvm::make_error<llvm::object::GenericBinaryError>(
         "Unsupported unit version");
   if (!addr_size_OK)
     return llvm::make_error<llvm::object::GenericBinaryError>(
         "Invalid unit address size");
 
   return header;
 }
 
 llvm::Expected<DWARFUnitSP>
 DWARFUnit::extract(SymbolFileDWARF *dwarf, user_id_t uid,
-                   const DWARFDataExtractor &debug_info,
+                   const DWARFDataExtractor &debug_info, DIERef::Section section,
                    lldb::offset_t *offset_ptr) {
   assert(debug_info.ValidOffset(*offset_ptr));
 
-  auto expected_header = DWARFUnitHeader::extract(debug_info, offset_ptr);
+  auto expected_header =
+      DWARFUnitHeader::extract(debug_info, section, offset_ptr);
   if (!expected_header)
     return expected_header.takeError();
 
   const DWARFDebugAbbrev *abbr = dwarf->DebugAbbrev();
   if (!abbr)
     return llvm::make_error<llvm::object::GenericBinaryError>(
         "No debug_abbrev data");
 
   bool abbr_offset_OK =
       dwarf->GetDWARFContext().getOrLoadAbbrevData().ValidOffset(
           expected_header->GetAbbrOffset());
   if (!abbr_offset_OK)
     return llvm::make_error<llvm::object::GenericBinaryError>(
         "Abbreviation offset for unit is not valid");
 
   const DWARFAbbreviationDeclarationSet *abbrevs =
       abbr->GetAbbreviationDeclarationSet(expected_header->GetAbbrOffset());
   if (!abbrevs)
     return llvm::make_error<llvm::object::GenericBinaryError>(
         "No abbrev exists at the specified offset.");
 
-  DWARFUnitSP unit_sp(
-      new DWARFCompileUnit(dwarf, uid, *expected_header, *abbrevs));
-
-  return unit_sp;
+  if (expected_header->IsTypeUnit())
+    return DWARFUnitSP(
+        new DWARFTypeUnit(dwarf, uid, *expected_header, *abbrevs, section));
+  return DWARFUnitSP(
+      new DWARFCompileUnit(dwarf, uid, *expected_header, *abbrevs, section));
 }
 
 const lldb_private::DWARFDataExtractor &DWARFUnit::GetData() const {
-  return m_dwarf->GetDWARFContext().getOrLoadDebugInfoData();
+  return m_section == DIERef::Section::DebugTypes
+             ? m_dwarf->GetDWARFContext().getOrLoadDebugTypesData()
+             : m_dwarf->GetDWARFContext().getOrLoadDebugInfoData();
 }
 
 uint32_t DWARFUnit::GetHeaderByteSize() const {
   switch (m_header.GetUnitType()) {
   case llvm::dwarf::DW_UT_compile:
   case llvm::dwarf::DW_UT_partial:
     return GetVersion() < 5 ? 11 : 12;
   case llvm::dwarf::DW_UT_skeleton:
   case llvm::dwarf::DW_UT_split_compile:
     return 20;
   case llvm::dwarf::DW_UT_type:
   case llvm::dwarf::DW_UT_split_type:
     return GetVersion() < 5 ? 23 : 24;
   }
   llvm_unreachable("invalid UnitType.");
 }

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 uint32_t SymbolFileDWARF::CalculateAbilities() {
   uint32_t abilities = 0;
   if (m_obj_file != NULL) {
     const Section *section = NULL;
     const SectionList *section_list = m_obj_file->GetSectionList();
     if (section_list == NULL)
       return 0;
 
-    // On non Apple platforms we might have .debug_types debug info that is
-    // created by using "-fdebug-types-section". LLDB currently will try to
-    // load this debug info, but it causes crashes during debugging when types
-    // are missing since it doesn't know how to parse the info in the
-    // .debug_types type units. This causes all complex debug info types to be
-    // unresolved. Because this causes LLDB to crash and since it really
-    // doesn't provide a solid debuggiung experience, we should disable trying
-    // to debug this kind of DWARF until support gets added or deprecated.
-    if (section_list->FindSectionByName(ConstString(".debug_types"))) {
-      m_obj_file->GetModule()->ReportWarning(
-        "lldb doesn’t support .debug_types debug info");
-      return 0;
-    }
-
     uint64_t debug_abbrev_file_size = 0;
     uint64_t debug_info_file_size = 0;
     uint64_t debug_line_file_size = 0;
 
     section = section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();
 
     if (section)
       section_list = &section->GetChildren();