Implement .debug_types

[jankratochvil]

Summary

It is a rebased patch D32167 by @clayborg.

DWO still does work (no regression), .debug_types also work now but DWO+.debug_types does not work together (while it does work for example in GDB). I have a work in progress as an additional patch for that, not yet finished. DWO+.debug_types has no testcase now so there is no new FAIL testcase.

The whole patchset available for testing as: git clone -b debugtypes git://git.jankratochvil.net/lldb

[jankratochvil]

It should be obsoleted by D62073 and future @labath patches.

lldb/packages/Python/lldbsuite/test/lldbtest.py

def buildGModules(
             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
 
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildGModules(self, architecture, compiler,
                                     dictionary, testdir, testname):
             raise Exception("Don't know how to build binary with gmodules")
 
+    def buildDwarfTypeUnits(
+            self,
+            architecture=None,
+            compiler=None,
+            dictionary=None):
+        """Platform specific way to build binaries with DWARF type units."""
+        testdir = self.mydir
+        testname = self.getBuildDirBasename()
+        if self.getDebugInfo() != "dwarf_type_units":
+            raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
+
+        module = builder_module()
+        dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
+        if not module.buildDwarfTypeUnits(self, architecture, compiler,
+                                          dictionary, testdir, testname):
+            raise Exception("Don't know how to build binary with DWARF type units")
+
     def signBinary(self, binary_path):
         if sys.platform.startswith("darwin"):
             codesign_cmd = "codesign --force --sign \"%s\" %s" % (
                 lldbtest_config.codesign_identity, binary_path)
             call(codesign_cmd, shell=True)
 
     def findBuiltClang(self):
         """Tries to find and use Clang from the build directory as the compiler (instead of the system compiler)."""
def build(
         elif self.getDebugInfo() == "dsym":
             return self.buildDsym(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "dwarf":
             return self.buildDwarf(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "dwo":
             return self.buildDwo(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "gmodules":
             return self.buildGModules(architecture, compiler, dictionary)
+        elif self.getDebugInfo() == "dwarf_type_units":
+            return self.buildDwarfTypeUnits(architecture, compiler, dictionary)
         else:
             self.fail("Can't build for debug info: %s" % self.getDebugInfo())
 
     def run_platform_command(self, cmd):
         platform = self.dbg.GetSelectedPlatform()
         shell_command = lldb.SBPlatformShellCommand(cmd)
         err = platform.Run(shell_command)
         return (err, shell_command.GetStatus(), shell_command.GetOutput())

lldb/packages/Python/lldbsuite/test/make/Makefile.rules

ifeq "$(OS)" "Darwin"
   MANDATORY_MODULE_BUILD_CFLAGS += -fcxx-modules
 endif
 
 ifeq "$(MAKE_GMODULES)" "YES"
   CFLAGS += $(MANDATORY_MODULE_BUILD_CFLAGS)
   CXXFLAGS += $(MANDATORY_MODULE_BUILD_CFLAGS)
 endif
 
+MANDATORY_DWARF_TYPE_UNITS_CFLAGS := -fdebug-types-section
+
+ifeq "$(DWARF_TYPE_UNITS)" "YES"
+  CFLAGS += $(MANDATORY_DWARF_TYPE_UNITS_CFLAGS)
+endif
+
 CXXFLAGS += -std=c++11 $(CFLAGS) $(ARCH_CXXFLAGS)
 LD = $(CC)
 LDFLAGS ?= $(CFLAGS)
 LDFLAGS += $(LD_EXTRAS) $(ARCH_LDFLAGS)
 ifneq (,$(LLVM_LIBS_DIR))
   ifeq ($(OS),NetBSD)
     LDFLAGS += -L$(LLVM_LIBS_DIR) -Wl,-rpath,$(LLVM_LIBS_DIR)
   endif

lldb/packages/Python/lldbsuite/test/plugins/builder_base.py

commands.append(getMake(testdir, testname) +
                      getCCSpec(compiler),
                      getCmdLine(dictionary)])
 
     lldbtest.system(commands, sender=sender)
     # True signifies that we can handle building with gmodules.
     return True
 
 
+def buildDwarfTypeUnits(
+        sender=None,
+        architecture=None,
+        compiler=None,
+        dictionary=None,
+        testdir=None,
+        testname=None):
+    """Build the binaries with type units (type in  a .debug_types section)."""
+    commands = []
+    commands.append(getMake(testdir, testname) +
+                    ["MAKE_DSYM=NO",
+                     "DWARF_TYPE_UNITS=YES",
+                     getArchSpec(architecture),
+                     getCCSpec(compiler),
+                     getCmdLine(dictionary)])
+
+    lldbtest.system(commands, sender=sender)
+    # True signifies that we can handle building with type units.
+    return True
+
+
 def cleanup(sender=None, dictionary=None):
     """Perform a platform-specific cleanup after the test."""
     return True

lldb/packages/Python/lldbsuite/test/test_categories.py

 
 # Third-party modules
 
 # LLDB modules
 from lldbsuite.support import gmodules
 
 
 debug_info_categories = [
-    'dwarf', 'dwo', 'dsym', 'gmodules'
+    'dwarf', 'dwo', 'dsym', 'gmodules', 'dwarf_type_units'
 ]
 
 all_categories = {
     'dataformatters': 'Tests related to the type command and the data formatters subsystem',
     'dwarf': 'Tests that can be run with DWARF debug information',
     'dwo': 'Tests that can be run with DWO debug information',
     'dsym': 'Tests that can be run with DSYM debug information',
     'gmodules': 'Tests that can be run with -gmodules debug information',
+    'dwarf_type_units' : 'Tests that can be run with DWARF type units',
     'expression': 'Tests related to the expression parser',
     'libc++': 'Test for libc++ data formatters',
     'libstdcxx': 'Test for libstdcxx data formatters',
     'objc': 'Tests related to the Objective-C programming language support',
     'pyapi': 'Tests related to the Python API',
     'basic_process': 'Basic process execution sniff tests.',
     'cmdline': 'Tests related to the LLDB command-line interface',
     'dyntype': 'Tests related to dynamic type support',
if category == "dwo":
         return platform in ["linux", "freebsd"]
     elif category == "dsym":
         return platform in ["darwin", "macosx", "ios", "watchos", "tvos", "bridgeos"]
     elif category == "gmodules":
         # First, check to see if the platform can even support gmodules.
         if platform not in ["freebsd", "darwin", "macosx", "ios", "watchos", "tvos", "bridgeos"]:
             return False
         return gmodules.is_compiler_clang_with_gmodules(compiler_path)
+    elif category == "dwarf_type_units":
+        return platform in ["linux"]
     return True
 
 
 def validate(categories, exact_match):
     """
     For each category in categories, ensure that it's a valid category (if exact_match is false,
     unique prefixes are also accepted). If a category is invalid, print a message and quit.
        If all categories are valid, return the list of categories. Prefixes are expanded in the

lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt

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

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (log) {
 
       dwarf->GetObjectFile()->GetModule()->LogMessage(
           log, "SymbolFileDWARF::ParseType (die = 0x%8.8x, decl_ctx = %p (die "
                "0x%8.8x)) %s name = '%s')",
           die.GetOffset(), static_cast<void *>(context),
           context_die.GetOffset(), die.GetTagAsCString(), die.GetName());
     }
     Type *type_ptr = dwarf->GetDIEToType().lookup(die.GetDIE());
-    TypeList *type_list = dwarf->GetTypeList();
     if (type_ptr == NULL) {
+
+      // If we have .debug_types defer to the complete version in the
+      // .debug_types section, not the broken incomplete definition in real
+      // compile units that are only there so addresses can be assigned to
+      // static values.
+      auto signature_die = die.GetAttributeValueAsReferenceDIE(DW_AT_signature);
+      if (signature_die) {
+        type_sp = ParseTypeFromDWARF(sc, signature_die, log, type_is_new_ptr);
+        if (type_sp) {
+          dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+          clang::DeclContext *decl_ctx =
+              GetCachedClangDeclContextForDIE(signature_die);
+          if (decl_ctx)
+            LinkDeclContextToDIE(decl_ctx, die);
+          return type_sp;
+        }
+      }
+
       if (type_is_new_ptr)
         *type_is_new_ptr = true;
 
       const dw_tag_t tag = die.Tag();
 
       bool is_forward_declaration = false;
       DWARFAttributes attributes;
       const char *type_name_cstr = NULL;

         }
 
         if (symbol_context_scope != NULL) {
           type_sp->SetSymbolContextScope(symbol_context_scope);
         }
 
         // We are ready to put this type into the uniqued list up at the module
         // level
-        type_list->Insert(type_sp);
+        dwarf->GetTypeList()->Insert(type_sp);
 
         dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
       }
     } else if (type_ptr != DIE_IS_BEING_PARSED) {
       type_sp = type_ptr->shared_from_this();
     }
   }
   return type_sp;

lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 
 llvm::Expected<DWARFUnitSP>
 DWARFCompileUnit::extract(SymbolFileDWARF *dwarf2Data,
                           const DWARFDataExtractor &debug_info,
                           lldb::offset_t *offset_ptr) {
   assert(debug_info.ValidOffset(*offset_ptr));
 
   // std::make_shared would require the ctor to be public.
-  std::shared_ptr<DWARFCompileUnit> cu_sp(new DWARFCompileUnit(dwarf2Data));
-
-  cu_sp->m_offset = *offset_ptr;
-
-  dw_offset_t abbr_offset;
-  const DWARFDebugAbbrev *abbr = dwarf2Data->DebugAbbrev();
-  if (!abbr)
-    return llvm::make_error<llvm::object::GenericBinaryError>(
-        "No debug_abbrev data");
-
-  cu_sp->m_length = debug_info.GetDWARFInitialLength(offset_ptr);
-  cu_sp->m_version = debug_info.GetU16(offset_ptr);
-
-  if (cu_sp->m_version == 5) {
-    cu_sp->m_unit_type = debug_info.GetU8(offset_ptr);
-    cu_sp->m_addr_size = debug_info.GetU8(offset_ptr);
-    abbr_offset = debug_info.GetDWARFOffset(offset_ptr);
-
-    if (cu_sp->m_unit_type == llvm::dwarf::DW_UT_skeleton)
-      cu_sp->m_dwo_id = debug_info.GetU64(offset_ptr);
-  } else {
-    abbr_offset = debug_info.GetDWARFOffset(offset_ptr);
-    cu_sp->m_addr_size = debug_info.GetU8(offset_ptr);
-  }
-
-  bool length_OK = debug_info.ValidOffset(cu_sp->GetNextUnitOffset() - 1);
-  bool version_OK = SymbolFileDWARF::SupportedVersion(cu_sp->m_version);
-  bool abbr_offset_OK =
-      dwarf2Data->get_debug_abbrev_data().ValidOffset(abbr_offset);
-  bool addr_size_OK = (cu_sp->m_addr_size == 4) || (cu_sp->m_addr_size == 8);
-
-  if (!length_OK)
-    return llvm::make_error<llvm::object::GenericBinaryError>(
-        "Invalid compile unit length");
-  if (!version_OK)
-    return llvm::make_error<llvm::object::GenericBinaryError>(
-        "Unsupported compile unit version");
-  if (!abbr_offset_OK)
-    return llvm::make_error<llvm::object::GenericBinaryError>(
-        "Abbreviation offset for compile unit is not valid");
-  if (!addr_size_OK)
-    return llvm::make_error<llvm::object::GenericBinaryError>(
-        "Invalid compile unit address size");
-
-  cu_sp->m_abbrevs = abbr->GetAbbreviationDeclarationSet(abbr_offset);
-  if (!cu_sp->m_abbrevs)
-    return llvm::make_error<llvm::object::GenericBinaryError>(
-        "No abbrev exists at the specified offset.");
-
+  DWARFCompileUnitSP cu_sp(new DWARFCompileUnit(dwarf2Data));
+  auto err = cu_sp->ExtractHeader(dwarf2Data, debug_info, offset_ptr);
+  if (err)
+    return std::move(err);
   return cu_sp;
 }
 
 void DWARFCompileUnit::Dump(Stream *s) const {
   s->Printf("0x%8.8x: Compile 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",
             m_offset, m_length, m_version, GetAbbrevOffset(), m_addr_size,

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

public:
 
   llvm::Expected<DWARFDebugAranges &> GetCompileUnitAranges();
 
 protected:
   static bool OffsetLessThanUnitOffset(dw_offset_t offset,
                                        const DWARFUnitSP &cu_sp);
 
   typedef std::vector<DWARFUnitSP> UnitColl;
+  typedef llvm::DenseMap<uint64_t, uint32_t> TypeSignatureMap;
 
   // Member variables
   SymbolFileDWARF *m_dwarf2Data;
   lldb_private::DWARFContext &m_context;
   UnitColl m_compile_units, m_type_units;
+  TypeSignatureMap m_type_sig_to_cu_index;
   std::unique_ptr<DWARFDebugAranges>
       m_cu_aranges_up; // A quick address to compile unit table
 
 private:
   // All parsing needs to be done partially any managed by this class as
   // accessors are called.
   void ParseUnitHeadersIfNeeded();
 

lldb/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_compile_units(), m_type_units(),
while (debug_info_data.ValidOffset(offset)) {
       // DWARFCompileUnit.
       assert(*cu_sp);
 
       m_compile_units.push_back(*cu_sp);
 
       offset = (*cu_sp)->GetNextUnitOffset();
     }
   }
+
+  {
+    lldb::offset_t offset = 0;
+    const auto &debug_types_data = m_dwarf2Data->get_debug_types_data();
+    while (debug_types_data.ValidOffset(offset)) {
+      llvm::Expected<DWARFUnitSP> tu_sp =
+          DWARFTypeUnit::extract(m_dwarf2Data, debug_types_data, &offset);
+
+      if (!tu_sp) {
+        // FIXME: Propagate this error up.
+        llvm::consumeError(tu_sp.takeError());
+        return;
+      }
+
+      // If it didn't return an error, then it should be returning a valid Unit.
+      assert(*tu_sp);
+
+      m_type_sig_to_cu_index[(*tu_sp)->GetAsTypeUnit()->GetTypeSignature()] =
+          m_type_units.size();
+      m_type_units.push_back(*tu_sp);
+
+      offset = (*tu_sp)->GetNextUnitOffset();
+    }
+  }
 }
 
 size_t DWARFDebugInfo::GetNumUnits() {
   ParseUnitHeadersIfNeeded();
   return m_compile_units.size() + m_type_units.size();
 }
 
 size_t DWARFDebugInfo::GetNumOnlyCompileUnits() {

 DWARFDIE
 DWARFDebugInfo::GetDIE(const DIERef &die_ref) {
   DWARFUnit *cu = GetUnit(die_ref);
   if (cu)
     return cu->GetDIE(die_ref.die_offset);
   return DWARFDIE(); // Not found
 }
 
+DWARFTypeUnit *DWARFDebugInfo::GetTypeUnitForSignature(uint64_t type_sig) {
+  auto pos = m_type_sig_to_cu_index.find(type_sig);
+  if (pos != m_type_sig_to_cu_index.end())
+    return GetUnitAtIndex(GetNumOnlyCompileUnits() + pos->second)
+        ->GetAsTypeUnit();
+  return nullptr;
+}

lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

public:
   void SetValue(const ValueType &val) { m_value = val; }
 
   void Dump(lldb_private::Stream &s) const;
   bool ExtractValue(const lldb_private::DWARFDataExtractor &data,
                     lldb::offset_t *offset_ptr);
   const uint8_t *BlockData() const;
   CUDIERef Reference() const;
   uint64_t Reference(dw_offset_t offset) const;
+  DWARFDIE GetTypeSignatureDIE() const;
   bool Boolean() const { return m_value.value.uval != 0; }
   uint64_t Unsigned() const { return m_value.value.uval; }
   void SetUnsigned(uint64_t uval) { m_value.value.uval = uval; }
   int64_t Signed() const { return m_value.value.sval; }
   void SetSigned(int64_t sval) { m_value.value.sval = sval; }
   const char *AsCString() const;
   dw_addr_t Address() const;
   bool IsValid() const { return m_form != 0; }

lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

 //===-- DWARFFormValue.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 <assert.h>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
 
 #include "DWARFDebugInfo.h"
+#include "DWARFTypeUnit.h"
 #include "DWARFUnit.h"
 #include "DWARFFormValue.h"
 
-class DWARFUnit;
-
 using namespace lldb_private;
 
 static uint8_t g_form_sizes_addr4[] = {
     0, // 0x00 unused
     4, // 0x01 DW_FORM_addr
     0, // 0x02 unused
     0, // 0x03 DW_FORM_block2
     0, // 0x04 DW_FORM_block4
if (!ref_cu) {
       m_cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
           "DW_FORM_ref_addr DIE reference 0x%" PRIx64 " has no matching CU",
           value);
       return CUDIERef();
     }
     return CUDIERef(ref_cu, value);
     }
 
+  case DW_FORM_ref_sig8: {
+    assert(m_cu);
+    DWARFDebugInfo *debug_info = m_cu->GetSymbolFileDWARF()->DebugInfo();
+    DWARFTypeUnit *ref_tu = debug_info->GetTypeUnitForSignature(value);
+    if (!ref_tu) {
+      m_cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
+          "DW_FORM_ref_sig8 DIE reference 0x%" PRIx64 " has no matching TU",
+          value);
+      return CUDIERef();
+    }
+    return CUDIERef(ref_tu, ref_tu->GetTypeUnitDIEOffset());
+    }
+
   default:
     return CUDIERef();
   }
 }
 
 uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const {
   uint64_t value = m_value.value.uval;
   switch (m_form) {
uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const {
   case DW_FORM_GNU_ref_alt:
     return value;
 
   default:
     return DW_INVALID_OFFSET;
   }
 }
 
+DWARFDIE DWARFFormValue::GetTypeSignatureDIE() const {
+  if (m_form == DW_FORM_ref_sig8) {
+    // CU must be valid since we will need to back up into the debug info and
+    // find the DIE offset of the type in the type unit.
+    assert(m_cu);
+    return m_cu->FindTypeSignatureDIE(m_value.value.uval);
+  }
+
+  return DWARFDIE();
+}
+
 const uint8_t *DWARFFormValue::BlockData() const { return m_value.data; }
 
 bool DWARFFormValue::IsBlockForm(const dw_form_t form) {
   switch (form) {
   case DW_FORM_exprloc:
   case DW_FORM_block:
   case DW_FORM_block1:
   case DW_FORM_block2:

lldb/source/Plugins/SymbolFile/DWARF/DWARFTypeUnit.h

+//===-- DWARFTypeUnit.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SymbolFileDWARF_DWARFTypeUnit_h_
+#define SymbolFileDWARF_DWARFTypeUnit_h_
+
+#include "DWARFUnit.h"
+
+class DWARFTypeUnit : public DWARFUnit {
+  friend class DWARFUnit;
+
+public:
+  static llvm::Expected<DWARFUnitSP>
+  extract(SymbolFileDWARF *dwarf2Data,
+          const lldb_private::DWARFDataExtractor &debug_info,
+          lldb::offset_t *offset_ptr);
+  void Dump(lldb_private::Stream *s) const override;
+
+  //------------------------------------------------------------------
+  /// Get the size in bytes of the header.
+  ///
+  /// @return
+  ///     Byte size of the type unit header
+  //------------------------------------------------------------------
+  uint32_t GetHeaderByteSize() const override {
+    return 23;
+  }
+
+  //------------------------------------------------------------------
+  /// Get the type DIE offset if this is a type unit.
+  ///
+  /// If this unit is a type unit, return type DIE offset for the type
+  /// in this unit.
+  ///
+  /// @return
+  ///   The DIE offset that points to the type unit type if this is
+  ///   a type unit, otherwise return DW_INVALID_OFFSET.
+  //------------------------------------------------------------------
+  dw_offset_t GetTypeUnitDIEOffset() {
+    return m_offset + m_type_offset;
+  }
+  
+  //------------------------------------------------------------------
+  /// Get the type signature for the type contained in this unit.
+  ///
+  /// @return
+  ///   The 64 bit type signature for the type contained in this type
+  ///   unit. This value will not be valid if this compile unit is not
+  ///   a type unit.
+  //------------------------------------------------------------------
+  uint64_t GetTypeSignature() const { return m_type_signature; }
+
+  //------------------------------------------------------------------
+  /// Get the type DIE if this is a type unit.
+  ///
+  /// If this unit is a type unit, return type contained within it as
+  /// a DWARFDIE object.
+  ///
+  /// @return
+  ///   The DIE representing the type if this is a type unit, or an
+  ///   invalid DWARFDIE if this is not a type unit.
+  //------------------------------------------------------------------
+  DWARFDIE GetTypeUnitDIE();
+
+  //------------------------------------------------------------------
+  /// Get the data that contains the DIE information for this unit.
+  ///
+  /// \return
+  ///   The correct data (.debug_types for DWARF 4 and earlier, and
+  ///   .debug_info for DWARF 5 and later) for the DIE information in
+  ///   this unit.
+  //------------------------------------------------------------------
+  const lldb_private::DWARFDataExtractor &GetData() const override;
+
+  bool IsTypesSection() const override { return GetVersion() < 5; }
+
+protected:
+  // Type signature contained in a type unit which will be valid (non-zero)
+  // for type units only.
+  uint64_t m_type_signature = 0;
+  // Compile unit relative type offset for type units only.
+  dw_offset_t m_type_offset = DW_INVALID_OFFSET;
+
+private:
+  DWARFTypeUnit(SymbolFileDWARF *dwarf2Data);
+  DISALLOW_COPY_AND_ASSIGN(DWARFTypeUnit);
+};
+
+#endif // SymbolFileDWARF_DWARFTypeUnit_h_

lldb/source/Plugins/SymbolFile/DWARF/DWARFTypeUnit.cpp

+//===-- DWARFTypeUnit.cpp ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DWARFTypeUnit.h"
+#include "DWARFDataExtractor.h"
+#include "SymbolFileDWARF.h"
+#include "lldb/Utility/Stream.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+DWARFTypeUnit::DWARFTypeUnit(SymbolFileDWARF *dwarf2Data)
+    : DWARFUnit(dwarf2Data) {}
+
+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, "
+            "type_signature = 0x%16.16" PRIx64 ", type_offset = 0x%8.8x "
+            "(next CU at {0x%8.8x})\n",
+            m_offset, m_length, m_version, GetAbbrevOffset(), m_addr_size,
+            m_type_signature, m_type_offset, GetNextUnitOffset());
+}
+
+llvm::Expected<DWARFUnitSP>
+DWARFTypeUnit::extract(SymbolFileDWARF *dwarf2Data,
+                       const DWARFDataExtractor &debug_info,
+                       lldb::offset_t *offset_ptr) {
+  // std::make_shared would require the ctor to be public.
+  DWARFTypeUnitSP cu_sp(new DWARFTypeUnit(dwarf2Data));
+  auto err = cu_sp->ExtractHeader(dwarf2Data, debug_info, offset_ptr);
+  if (err)
+    return std::move(err);
+  cu_sp->m_type_signature = debug_info.GetU64(offset_ptr);
+  cu_sp->m_type_offset = debug_info.GetDWARFOffset(offset_ptr);
+  return cu_sp;
+}
+
+DWARFDIE DWARFTypeUnit::GetTypeUnitDIE() {
+  // The type offset is compile unit relative, so we need to add the compile
+  // unit offset to ensure we get the correct DIE.
+  return GetDIE(GetTypeUnitDIEOffset());
+}
+
+const DWARFDataExtractor &DWARFTypeUnit::GetData() const {
+  return m_dwarf->get_debug_types_data();
+}

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

 
 #include "DWARFDIE.h"
 #include "DWARFDebugInfoEntry.h"
 #include "lldb/lldb-enumerations.h"
 #include "llvm/Support/RWMutex.h"
 #include <atomic>
 
 class DWARFUnit;
+class DWARFTypeUnit;
 class DWARFCompileUnit;
 class NameToDIE;
 class SymbolFileDWARF;
 class SymbolFileDWARFDwo;
 
 typedef std::shared_ptr<DWARFUnit> DWARFUnitSP;
+typedef std::shared_ptr<DWARFTypeUnit> DWARFTypeUnitSP;
+typedef std::shared_ptr<DWARFCompileUnit> DWARFCompileUnitSP;
 
 enum DWARFProducer {
   eProducerInvalid = 0,
   eProducerClang,
   eProducerGCC,
   eProducerLLVMGCC,
   eProcucerOther
 };
 
 class DWARFUnit {
   using die_iterator_range =
       llvm::iterator_range<DWARFDebugInfoEntry::collection::iterator>;
 
 public:
   virtual ~DWARFUnit();
 
+  llvm::Error ExtractHeader(SymbolFileDWARF *dwarf2Data,
+                            const lldb_private::DWARFDataExtractor &debug_info,
+                            lldb::offset_t *offset_ptr);
+
+  DWARFTypeUnit *GetAsTypeUnit();
+  DWARFCompileUnit *GetAsCompileUnit();
   virtual bool IsTypesSection() const = 0;
   void ExtractUnitDIEIfNeeded();
   void ExtractDIEsIfNeeded();
 
   class ScopedExtractDIEs {
     DWARFUnit *m_cu;
   public:
     bool m_clear_dies = false;
public:
 
   dw_offset_t GetBaseObjOffset() const;
 
   die_iterator_range dies() {
     ExtractDIEsIfNeeded();
     return die_iterator_range(m_die_array.begin(), m_die_array.end());
   }
 
+  DWARFDIE FindTypeSignatureDIE(uint64_t type_sig) const;
+
 protected:
   DWARFUnit(SymbolFileDWARF *dwarf);
 
   SymbolFileDWARF *m_dwarf = nullptr;
   std::unique_ptr<SymbolFileDWARFDwo> m_dwo_symbol_file;
   const DWARFAbbreviationDeclarationSet *m_abbrevs = nullptr;
   void *m_user_data = nullptr;
   // The compile unit debug information entry item

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #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;
 
void DWARFUnit::ClearDIEsRWLocked() {
   m_die_array.shrink_to_fit();
 
   if (m_dwo_symbol_file)
     m_dwo_symbol_file->GetCompileUnit()->ClearDIEsRWLocked();
 }
 
 void DWARFUnit::BuildAddressRangeTable(SymbolFileDWARF *dwarf,
                                        DWARFDebugAranges *debug_aranges) {
+  // No addresses in a type unit
+  if (GetAsTypeUnit())
+    return;
+
   // 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();
if (m_func_aranges_up == NULL) {
     }
 
     const bool minimize = false;
     m_func_aranges_up->Sort(minimize);
   }
   return *m_func_aranges_up;
 }
 
+DWARFDIE DWARFUnit::FindTypeSignatureDIE(uint64_t type_sig) const {
+  if (auto cu = m_dwarf->DebugInfo()->GetTypeUnitForSignature(type_sig))
+    return cu->GetTypeUnitDIE();
+  return DWARFDIE();
+}
+
+DWARFTypeUnit *DWARFUnit::GetAsTypeUnit() {
+  if (GetUnitDIEOnly().Tag() == DW_TAG_type_unit)
+    return static_cast<DWARFTypeUnit *>(this);
+  return nullptr;
+}
+
+DWARFCompileUnit *DWARFUnit::GetAsCompileUnit() {
+  if (GetUnitDIEOnly().Tag() == DW_TAG_compile_unit)
+    return static_cast<DWARFCompileUnit *>(this);
+  return nullptr;
+}
+
+llvm::Error
+DWARFUnit::ExtractHeader(SymbolFileDWARF *dwarf2Data,
+                         const lldb_private::DWARFDataExtractor &debug_info,
+                         lldb::offset_t *offset_ptr) {
+  m_offset = *offset_ptr;
+
+  dw_offset_t abbr_offset;
+  const DWARFDebugAbbrev *abbr = dwarf2Data->DebugAbbrev();
+  if (!abbr)
+    return llvm::make_error<llvm::object::GenericBinaryError>(
+        "No debug_abbrev data");
+
+  m_length = debug_info.GetDWARFInitialLength(offset_ptr);
+  m_version = debug_info.GetU16(offset_ptr);
+
+  if (m_version == 5) {
+    m_unit_type = debug_info.GetU8(offset_ptr);
+    m_addr_size = debug_info.GetU8(offset_ptr);
+    abbr_offset = debug_info.GetDWARFOffset(offset_ptr);
+
+    if (m_unit_type == llvm::dwarf::DW_UT_skeleton)
+      m_dwo_id = debug_info.GetU64(offset_ptr);
+  } else {
+    abbr_offset = debug_info.GetDWARFOffset(offset_ptr);
+    m_addr_size = debug_info.GetU8(offset_ptr);
+  }
+
+  bool length_OK = debug_info.ValidOffset(GetNextUnitOffset() - 1);
+  bool version_OK = SymbolFileDWARF::SupportedVersion(m_version);
+  bool abbr_offset_OK =
+      dwarf2Data->get_debug_abbrev_data().ValidOffset(abbr_offset);
+  bool addr_size_OK = (m_addr_size == 4) || (m_addr_size == 8);
+
+  if (!length_OK)
+    return llvm::make_error<llvm::object::GenericBinaryError>(
+        "Invalid compile unit length");
+  if (!version_OK)
+    return llvm::make_error<llvm::object::GenericBinaryError>(
+        "Unsupported compile unit version");
+  if (!abbr_offset_OK)
+    return llvm::make_error<llvm::object::GenericBinaryError>(
+        "Abbreviation offset for compile unit is not valid");
+  if (!addr_size_OK)
+    return llvm::make_error<llvm::object::GenericBinaryError>(
+        "Invalid compile unit address size");
+
+  m_abbrevs = abbr->GetAbbreviationDeclarationSet(abbr_offset);
+  if (!m_abbrevs)
+    return llvm::make_error<llvm::object::GenericBinaryError>(
+        "No abbrev exists at the specified offset.");
+
+  return llvm::Error::success();
+}

lldb/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();
if (comp_unit) {
 
             LanguageType cu_language = DWARFUnit::LanguageTypeFromDWARF(
                 cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
 
             bool is_optimized = dwarf_cu->GetIsOptimized();
             cu_sp = std::make_shared<CompileUnit>(
                 module_sp, dwarf_cu, cu_file_spec, dwarf_cu->GetID(),
                 cu_language, is_optimized ? eLazyBoolYes : eLazyBoolNo);
-            if (cu_sp) {
+            if (dwarf_cu->GetAsCompileUnit() && cu_sp) {
               // If we just created a compile unit with an invalid file spec,
               // try and get the first entry in the supports files from the
               // line table as that should be the compile unit.
               if (!cu_file_spec) {
                 cu_file_spec = cu_sp->GetSupportFiles().GetFileSpecAtIndex(1);
                 if (cu_file_spec) {
                   (FileSpec &)(*cu_sp) = cu_file_spec;
                   // Also fix the invalid file spec which was copied from the