03/03: .debug_types: Update of D32167 (.debug_types) on top of D51578 (section concatenation)

[jankratochvil]

Summary

I cannot update the patch of D32167 so I have created this new revision for that.

[jankratochvil]

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

268 ↗

(On Diff #174520)

I have added these 4 lines - decl_ctx copy - which fixes the -fdebug-types-section regression described before as:

There is a _dwarf -> _dwarf_type_units regression for: -f TestCppTypeLookup.test_namespace_only_dwarf_type_units

./bin/clang -o 1 ../llvm-git/tools/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/main.cpp -g -fdebug-types-section;./bin/lldb -o 'settings set target.experimental.inject-local-vars false' -o 'target create "./1"' -o 'b 66' -o r -o 'p *((in_contains_type *)&i)'

Expected:

(lldb) p *((in_contains_type *)&i)
error: use of undeclared identifier 'in_contains_type'
error: expected expression

Actual:

(lldb) p *((in_contains_type *)&i)
(in_contains_type) $0 = (aaa = 123)

The regression was due to DWARFASTParserClang::GetClangDeclContextForDIE calling ResolveType but then still GetCachedClangDeclContextForDIE was returning NULL decl_ctx. That was because in this code above the recursive ParseTypeFromDWARF call properly did set LinkDeclContextToDIE but only for the referenced DIE, not for the referring DIE. But then the caller asked for DeclContext of the referring DIE which has not been found.

  Compilation Unit @ offset 0x84:
   Signature:     0x368b3ff5e79ee8d1
 <0><9b>: Abbrev Number: 1 (DW_TAG_type_unit)
 <1><a2>: Abbrev Number: 2 (DW_TAG_namespace)
    <a3>   DW_AT_name        : (indirect string, offset: 0x149): nsp_a
 <2><a7>: Abbrev Number: 6 (DW_TAG_structure_type)
HERE: Referenced DIE.
    <a9>   DW_AT_name        : (indirect string, offset: 0x169): contains_type
  Compilation Unit @ offset 0xb2:
   Signature:     0xb27591880ea58868
 <0><c9>: Abbrev Number: 1 (DW_TAG_type_unit)
 <1><d0>: Abbrev Number: 2 (DW_TAG_namespace)
    <d1>   DW_AT_name        : (indirect string, offset: 0x149): nsp_a
 <2><d5>: Abbrev Number: 7 (DW_TAG_structure_type)
HERE: Referring DIE.
    <d6>   DW_AT_declaration : 1
    <d6>   DW_AT_signature   : signature: 0x368b3ff5e79ee8d1
 <3><de>: Abbrev Number: 3 (DW_TAG_structure_type)
    <e0>   DW_AT_name        : (indirect string, offset: 0x166): in_contains_type
 <4><e7>: Abbrev Number: 4 (DW_TAG_member)
    <e8>   DW_AT_name        : (indirect string, offset: 0x177): aaa

[jankratochvil]

@clayborg You have already approved this patchset merged with D51578 in D51578 three weeks ago. I have split it afterwards to:

1of2	D51578	the section merge which you have approved; but it is not much useful without any code using it.
2of2	this D54670	your original .debug_types patch but with my added few lines of code to fix its regression when using .debug_types. These few lines have not been approved yet.

Should I check it in as you wrote it or is it OK with those few lines of code added by me?

[clayborg]

I am definitely ready for this to go in ASAP if we are good on this!

[JDevlieghere]

Few style nits

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

44

Invert and make this an early return.

51

This auto is not entirely obvious for me, same for the next line.

53

How about if (auto tu = ...)?

59

How about

cu_offset = dwarf_cu->GetBaseObjOffset() != DW_INVALID_OFFSET ? dwarf_cu->GetBaseObjOffset() : dwarf_cu->GetOffset();

64

Move this up.

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

262

How about if (auto signature_die = ...)?

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

44

Let's make this a sentence with a full stop at the end.

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

74

///

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

942

Full sentence.

[labath]

I am still worried about the divergence from llvm's dwarf reader here. We now have a relatively nice Object API, which presents a view of the object file that everybody is used to (i.e., as a bunch of sections). This includes the llvm object and dwarf readers, and the DWARF spec (!). But now we are drilling a hole in that API, which basically reverts the sections and gives us back the a view of the object file as a stream of bytes. And if the object file happens to be compressed, then we have to mock up a new uncompressed buffer with all of the data, even though the compression is supposed to be transparent and unobtrusive (and it mostly is, if you stick to viewing the object file as a collection of sections). All because our dwarf reader cannot handle the fact that the debug info can come from multiple sections? How come nobody else has this problem?

Treating dwarf data as a single buffer with various chunks starting at random offsets should essentially be isomorphous with treating it as a collection of independent buffers. We are here introducing a function called get_debug_types_offset. Why not have get_debug_types_data_extractor() instead? That may mean some functions need to be changed so that they take an additional buffer argument, instead of just assuming everything refers to the single grand buffer, but I think that's a good thing, because it brings us closer to reality instead of continuing to fabricate ever more complicated fiction. BTW, I don't see a get_debug_info_offset(). AFAIK, there's no requirement that .debug_info has to come first in an object file. What would happen if the order of the sections in the object file is reversed?

[jankratochvil]

In D54670#1403642, @labath wrote:

I am still worried about the divergence from llvm's dwarf reader here.

I am still going to investigate your DW_FORM_* dispatching suggestion. It looks too simple to work, maybe it is the right way forward.

the debug info can come from multiple sections? How come nobody else has this problem?

Because GDB does not need to return back to DWARF after it is parsed - but then for LLDB the multiple-sections dispatching could be done only for user_id_t

Why not have get_debug_types_data_extractor() instead?

Because DataExtractor accesses always start at offset 0.

BTW, I don't see a get_debug_info_offset(). AFAIK, there's no requirement that .debug_info has to come first in an object file. What would happen if the order of the sections in the object file is reversed?

It would fall back to the section-reading (instead of section-mmapping) less performing fallback in get_debug_info_data(). If there are any such files out there sure the code could be extended to handle both orders of .debug_info and .debug_types but personally I do not think it is worth the code complication given there is the fallback anyway. I can put a warning there for such case so that it would be easily noticed in the future - but then maybe one could already rather extend the code, any suggestions what to choose?

[labath]

In D54670#1403670, @jankratochvil wrote:

In D54670#1403642, @labath wrote:

I am still worried about the divergence from llvm's dwarf reader here.

I am still going to investigate your DW_FORM_* dispatching suggestion. It looks too simple to work, maybe it is the right way forward.

Thank you for doing that. Please don't feel like I'm taking this all out to you, I know that you are following the direction that has already been set out. My comment is directed at everyone who has interest in the state of lldb's dwarf parser.

And I am fully aware that my proposal is a gross oversimplification, and that doing that might be hard, but I believe the end goal is worth it, and that we can reach it incrementally.

One of the problems we'll probably have to tackle is the encoding of the user_id_t, which is currently very wastefull. Despite it being 64 bits, we can only encode 4GB of debug info. That's still a fairly large number, but it's still not that hard to surpass it. If we slice one bit out of that, we'll get 2GB, which will be just too small. So we'll either have to increase the size of that type, use a more rational encoding (we already have compile units and dies sitting in a vector, so maybe index into that vector?), or use some concatenation scheme just for the purposes of user_id_t, but then bail out and decompose that very early on.

Why not have get_debug_types_data_extractor() instead?

Because DataExtractor accesses always start at offset 0.

Yes, that's part of the idea. :) Starting at zero is the right thing to do here, as that's the base any intra-section references will be using. (and for inter-section refs, you have to manually fiddle with the offsets anyway)

BTW, I don't see a get_debug_info_offset(). AFAIK, there's no requirement that .debug_info has to come first in an object file. What would happen if the order of the sections in the object file is reversed?

It would fall back to the section-reading (instead of section-mmapping) less performing fallback in get_debug_info_data(). If there are any such files out there sure the code could be extended to handle both orders of .debug_info and .debug_types but personally I do not think it is worth the code complication given there is the fallback anyway. I can put a warning there for such case so that it would be easily noticed in the future - but then maybe one could already rather extend the code, any suggestions what to choose?

Hm... ok, I'm glad you've thought about all of the possibilities. Though I would say that this just show that we have an incorrect abstraction here. :)

Of the two options I would say only adding the warning makes sense, since I believe making everything aware of the fact that .debug_info can start at a non-zero offset is equivalent to teaching it that it can start in a different section.

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 "$(MAKE_GMODULES)" "YES"
   CFLAGS += $(MANDATORY_MODULE_BUILD_CFLAGS)
   CXXFLAGS += $(MANDATORY_MODULE_BUILD_CFLAGS)
   ifeq "$(OS)" "Darwin"
     CXXFLAGS += -fcxx-modules
   endif
 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)
 ifeq (,$(filter $(OS), Windows_NT Android Darwin))
   ifneq (,$(filter YES,$(ENABLE_THREADS)))
     LDFLAGS += -pthread
   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
   DWARFDebugRanges.cpp
   DWARFDeclContext.cpp
   DWARFDefines.cpp
   DWARFDIE.cpp
   DWARFDIECollection.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/DIERef.cpp

 //===-- DIERef.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 "DIERef.h"
 #include "DWARFUnit.h"
+#include "DWARFTypeUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFFormValue.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDebugMap.h"
 
 DIERef::DIERef(lldb::user_id_t uid, SymbolFileDWARF *dwarf)
     : cu_offset(DW_INVALID_OFFSET), die_offset(uid & 0xffffffff) {
   SymbolFileDWARFDebugMap *debug_map = dwarf->GetDebugMapSymfile();
if (debug_map) {
     cu_offset = uid >> 32;
   }
 }
 
 DIERef::DIERef(const DWARFFormValue &form_value)
     : cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET) {
   if (form_value.IsValid()) {
     const DWARFUnit *dwarf_cu = form_value.GetCompileUnit();
     if (dwarf_cu) {
+      // Replace the compile unit with the type signature compile unit
+      // and DIE for the type signature. When a type is referred to by a
+      // DW_FORM_ref_sig8 form, the real information for the type in
+      // contained in a DW_TAG_type_unit.
+      if (form_value.Form() == DW_FORM_ref_sig8) {
+        uint64_t type_sig = form_value.Unsigned();
+        auto debug_info = dwarf_cu->GetSymbolFileDWARF()->DebugInfo();
+        auto tu = debug_info->GetTypeUnitForSignature(type_sig);
+        if (tu) {
+          cu_offset = tu->GetOffset();
+          die_offset = tu->GetTypeUnitDIEOffset();
+        }
+      } else {
         if (dwarf_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
           cu_offset = dwarf_cu->GetBaseObjOffset();
         else
           cu_offset = dwarf_cu->GetOffset();
       }
+    }
     die_offset = form_value.Reference();
   }
 }
 
 lldb::user_id_t DIERef::GetUID(SymbolFileDWARF *dwarf) const {
   //----------------------------------------------------------------------
   // Each SymbolFileDWARF will set its ID to what is expected.
   //
   // SymbolFileDWARF, when used for DWARF with .o files on MacOSX, has the

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.h

 //===-- DWARFCompileUnit.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_DWARFCompileUnit_h_
 #define SymbolFileDWARF_DWARFCompileUnit_h_
 
 #include "DWARFUnit.h"
 
 class DWARFCompileUnit : public DWARFUnit {
 public:
-  static DWARFUnitSP Extract(SymbolFileDWARF *dwarf2Data,
-                             const lldb_private::DWARFDataExtractor &debug_info,
-                             lldb::offset_t *offset_ptr);
+  static DWARFCompileUnitSP Extract(SymbolFileDWARF *dwarf2Data,
   void Dump(lldb_private::Stream *s) const override;
 
   //------------------------------------------------------------------
   /// Get the size in bytes of the header.
   ///
   /// @return
   ///     Byte size of the compile unit header
   //------------------------------------------------------------------
   uint32_t GetHeaderByteSize() const override;
 
 private:
   DWARFCompileUnit(SymbolFileDWARF *dwarf2Data);
   DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
 };
 
 #endif // SymbolFileDWARF_DWARFCompileUnit_h_

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

 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF *dwarf2Data)
     : DWARFUnit(dwarf2Data) {}
 
-DWARFUnitSP DWARFCompileUnit::Extract(SymbolFileDWARF *dwarf2Data,
+DWARFCompileUnitSP DWARFCompileUnit::Extract(SymbolFileDWARF *dwarf2Data,
                                       const DWARFDataExtractor &debug_info,
                                       lldb::offset_t *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;
-
-  if (debug_info.ValidOffset(*offset_ptr)) {
-    dw_offset_t abbr_offset;
-    const DWARFDebugAbbrev *abbr = dwarf2Data->DebugAbbrev();
-    cu_sp->m_length = debug_info.GetDWARFInitialLength(offset_ptr);
-    cu_sp->m_is_dwarf64 = debug_info.IsDWARF64();
-    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->GetNextCompileUnitOffset() - 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 && version_OK && addr_size_OK && abbr_offset_OK &&
-        abbr != NULL) {
-      cu_sp->m_abbrevs = abbr->GetAbbreviationDeclarationSet(abbr_offset);
-      return cu_sp;
-    }
-
-    // reset the offset to where we tried to parse from if anything went wrong
-    *offset_ptr = cu_sp->m_offset;
-  }
-
-  return nullptr;
+  DWARFCompileUnitSP cu_sp(new DWARFCompileUnit(dwarf2Data));
+  if (cu_sp->ExtractHeader(dwarf2Data, debug_info, offset_ptr))
+  return DWARFCompileUnitSP();
 }
 
 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,
             GetNextCompileUnitOffset());

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

 //===-- DWARFDebugInfo.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_DWARFDebugInfo_h_
 #define SymbolFileDWARF_DWARFDebugInfo_h_
 
 #include <map>
+#include <unordered_map>
 #include <vector>
 
 #include "DWARFUnit.h"
 #include "DWARFDIE.h"
 #include "SymbolFileDWARF.h"
 #include "lldb/Core/STLUtils.h"
 #include "lldb/lldb-private.h"
 
+class DWARFTypeUnit;
+
 typedef std::multimap<const char *, dw_offset_t, CStringCompareFunctionObject>
     CStringToDIEMap;
 typedef CStringToDIEMap::iterator CStringToDIEMapIter;
 typedef CStringToDIEMap::const_iterator CStringToDIEMapConstIter;
 
 class DWARFDebugInfo {
 public:
   typedef dw_offset_t (*Callback)(SymbolFileDWARF *dwarf2Data,
                                   DWARFUnit *cu,
                                   DWARFDebugInfoEntry *die,
                                   const dw_offset_t next_offset,
                                   const uint32_t depth, void *userData);
 
   DWARFDebugInfo();
   void SetDwarfData(SymbolFileDWARF *dwarf2Data);
 
   size_t GetNumCompileUnits();
   bool ContainsCompileUnit(const DWARFUnit *cu) const;
   DWARFUnit *GetCompileUnitAtIndex(uint32_t idx);
+  DWARFTypeUnit *GetTypeUnitForSignature(uint64_t type_sig);
   DWARFUnit *GetCompileUnit(dw_offset_t cu_offset, uint32_t *idx_ptr = NULL);
   DWARFUnit *GetCompileUnitContainingDIEOffset(dw_offset_t die_offset);
   DWARFUnit *GetCompileUnit(const DIERef &die_ref);
   DWARFDIE GetDIEForDIEOffset(dw_offset_t die_offset);
   DWARFDIE GetDIE(const DIERef &die_ref);
 
   enum {
     eDumpFlag_Verbose = (1 << 0),  // Verbose dumping
     eDumpFlag_ShowForm = (1 << 1), // Show the DW_form type
     eDumpFlag_ShowAncestors =
         (1 << 2) // Show all parent DIEs when dumping single DIEs
   };
 
   DWARFDebugAranges &GetCompileUnitAranges();
 
 protected:
   static bool OffsetLessThanCompileUnitOffset(dw_offset_t offset,
                                               const DWARFUnitSP &cu_sp);
 
   typedef std::vector<DWARFUnitSP> CompileUnitColl;
+  typedef llvm::DenseMap<uint64_t, uint32_t> TypeSignatureMap;
 
   //----------------------------------------------------------------------
   // Member variables
   //----------------------------------------------------------------------
   SymbolFileDWARF *m_dwarf2Data;
   CompileUnitColl m_compile_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 ParseCompileUnitHeadersIfNeeded();
 
   DISALLOW_COPY_AND_ASSIGN(DWARFDebugInfo);
 };
 
 #endif // SymbolFileDWARF_DWARFDebugInfo_h_

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

 #include "lldb/Utility/Stream.h"
 
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFFormValue.h"
+#include "DWARFTypeUnit.h"
 #include "LogChannelDWARF.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 //----------------------------------------------------------------------
 // Constructor
if (m_cu_aranges_up == NULL && m_dwarf2Data) {
 
     const bool minimize = true;
     m_cu_aranges_up->Sort(minimize);
   }
   return *m_cu_aranges_up;
 }
 
 void DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded() {
-  if (m_compile_units.empty()) {
-    if (m_dwarf2Data != NULL) {
-      lldb::offset_t offset = 0;
-      DWARFUnitSP cu_sp;
-      const auto &debug_info_data = m_dwarf2Data->get_debug_info_data();
-      while (offset < m_dwarf2Data->get_debug_info_size()
-          && (cu_sp = DWARFCompileUnit::Extract(m_dwarf2Data, debug_info_data,
-                                                &offset))) {
-        m_compile_units.push_back(cu_sp);
-
-        offset = cu_sp->GetNextCompileUnitOffset();
-      }
-    }
+  if (!m_compile_units.empty())
+    return;
+  
+  if (m_dwarf2Data == nullptr)
+    return;
+
+  DWARFCompileUnitSP cu_sp;
+  
+  // If we have a separate .debug_types section, it means we are using DWARF4
+  // or earlier where type units are a separate section. All data in the
+  // .debug_types section doesn't refer directly to any other DIEs, all
+  // references are done via type signatures. With this in mind, we can support
+  // parsing .debug_types by pretending that the data in .debug_types
+  // follows all data in the .debug_info section. This allows all
+  // types in the .debug_types to have a unique DIE offset that is:
+  //    offset = sizeof(.debug_info) + (possible gap) + debug_type_offset
+  offset = m_dwarf2Data->get_debug_types_offset();
+  DWARFTypeUnitSP tu_sp;
+  while ((tu_sp = DWARFTypeUnit::Extract(m_dwarf2Data, debug_info_data,
+                                         &offset))) {
+    m_type_sig_to_cu_index[tu_sp->GetTypeSignature()] = m_compile_units.size();
+    m_compile_units.push_back(tu_sp);
+    offset = tu_sp->GetNextCompileUnitOffset();
   }
 }
 
 size_t DWARFDebugInfo::GetNumCompileUnits() {
   ParseCompileUnitHeadersIfNeeded();
   return m_compile_units.size();
 }
 

 DWARFDIE
 DWARFDebugInfo::GetDIE(const DIERef &die_ref) {
   DWARFUnit *cu = GetCompileUnit(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 GetCompileUnitAtIndex(pos->second)->GetAsTypeUnit();
+  return nullptr;
+}

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

 //===-- DWARFFormValue.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_DWARFFormValue_h_
 #define SymbolFileDWARF_DWARFFormValue_h_
 
+#include "DWARFDIE.h"
 #include "DWARFDataExtractor.h"
 #include <stddef.h>
 
 class DWARFUnit;
 class SymbolFileDWARF;
 
 class DWARFFormValue {
 public:
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;
   uint64_t 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

uint64_t DWARFFormValue::Reference() const {
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata:
     assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
                   // unit relative or we will get this wrong
     return value + m_cu->GetOffset();
 
   case DW_FORM_ref_addr:
-  case DW_FORM_ref_sig8:
   case DW_FORM_GNU_ref_alt:
     return value;
 
+  case 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->FindTypeSignatureDIEOffset(m_value.value.uval);
+    break;
+
   default:
     return DW_INVALID_OFFSET;
   }
 }
 
 uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const {
   uint64_t value = m_value.value.uval;
   switch (m_form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata:
     return value + base_offset;
 
   case DW_FORM_ref_addr:
-  case DW_FORM_ref_sig8:
   case DW_FORM_GNU_ref_alt:
     return value;
 
+  case 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->FindTypeSignatureDIEOffset(m_value.value.uval) + base_offset;
+    break;
+
   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:
+  virtual ~DWARFTypeUnit();
+
+  static DWARFTypeUnitSP Extract(SymbolFileDWARF *dwarf2Data,
+                                 const lldb_private::DWARFDataExtractor &data,
+                                 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 m_is_dwarf64 ? 39 : 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();
+
+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) {}
+
+DWARFTypeUnit::~DWARFTypeUnit() {}
+
+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, GetNextCompileUnitOffset());
+}
+
+DWARFTypeUnitSP DWARFTypeUnit::Extract(SymbolFileDWARF *dwarf,
+    const lldb_private::DWARFDataExtractor &data, lldb::offset_t *offset_ptr) {
+  // std::make_shared would require the ctor to be public.
+  std::shared_ptr<DWARFTypeUnit> cu_sp(new DWARFTypeUnit(dwarf));
+  // Out of memory?
+  if (!cu_sp)
+    return nullptr;
+  if (cu_sp->ExtractHeader(dwarf, data, offset_ptr)) {
+    cu_sp->m_type_signature = data.GetU64(offset_ptr);
+    cu_sp->m_type_offset = data.GetDWARFOffset(offset_ptr);
+    return cu_sp;
+  }
+  // reset the offset to where we tried to parse from if anything went wrong
+  *offset_ptr = cu_sp->m_offset;
+  return nullptr;
+}
+
+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());
+}

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();
 
+  bool ExtractHeader(SymbolFileDWARF *dwarf,
+                     const lldb_private::DWARFDataExtractor &data,
+                     lldb::offset_t *offset_ptr);
+
+  DWARFTypeUnit *GetAsTypeUnit();
+  DWARFCompileUnit *GetAsCompileUnit();
   void ExtractUnitDIEIfNeeded();
   void ExtractDIEsIfNeeded();
 
   class ScopedExtractDIEs {
     DWARFUnit *m_cu;
   public:
     bool m_clear_dies = false;
     ScopedExtractDIEs(DWARFUnit *cu);
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;
+
+  dw_offset_t FindTypeSignatureDIEOffset(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/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 "DWARFCompileUnit.h"
 #include "DWARFDIECollection.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();
+}
+
+dw_offset_t
+DWARFUnit::FindTypeSignatureDIEOffset(uint64_t type_sig) const {
+  if (auto cu = m_dwarf->DebugInfo()->GetTypeUnitForSignature(type_sig))
+    return cu->GetTypeUnitDIEOffset();
+  return DW_INVALID_OFFSET;
+}
+
+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;
+}
+
+bool
+DWARFUnit::ExtractHeader(SymbolFileDWARF *dwarf,
+                         const lldb_private::DWARFDataExtractor &data,
+                         lldb::offset_t *offset_ptr) {
+  m_offset = *offset_ptr;
+
+  if (data.ValidOffset(*offset_ptr)) {
+    dw_offset_t abbr_offset;
+    const DWARFDebugAbbrev *abbr = dwarf->DebugAbbrev();
+    m_length = data.GetDWARFInitialLength(offset_ptr);
+    m_is_dwarf64 = data.IsDWARF64();
+    m_version = data.GetU16(offset_ptr);
+    if (m_version == 5) {
+      m_unit_type = data.GetU8(offset_ptr);
+      m_addr_size = data.GetU8(offset_ptr);
+      abbr_offset = data.GetDWARFOffset(offset_ptr);
+
+      if (m_unit_type == llvm::dwarf::DW_UT_skeleton)
+        m_dwo_id = data.GetU64(offset_ptr);
+    } else {
+      abbr_offset = data.GetDWARFOffset(offset_ptr);
+      m_addr_size = data.GetU8(offset_ptr);
+    }
+
+    bool length_OK = data.ValidOffset(GetNextCompileUnitOffset() - 1);
+    bool version_OK = SymbolFileDWARF::SupportedVersion(m_version);
+    bool abbr_offset_OK =
+        dwarf->get_debug_abbrev_data().ValidOffset(abbr_offset);
+    bool addr_size_OK = (m_addr_size == 4) || (m_addr_size == 8);
+
+    if (length_OK && version_OK && addr_size_OK && abbr_offset_OK && abbr) {
+      m_abbrevs = abbr->GetAbbreviationDeclarationSet(abbr_offset);
+      return m_abbrevs != nullptr;
+    }
+
+    // reset the offset to where we tried to parse from if anything went wrong
+    *offset_ptr = m_offset;
+  }
+  return false;
+}
+
 const lldb_private::DWARFDataExtractor &DWARFUnit::GetData() const {
   return m_dwarf->get_debug_info_data();
 }

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
                   // compile unit.
                   cu_sp->GetSupportFiles().Replace(0, cu_file_spec);
                 }
               }
+            }
 
-              dwarf_cu->SetUserData(cu_sp.get());
 
-              // Figure out the compile unit index if we weren't given one
-              if (cu_idx == UINT32_MAX)
-                DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx);
 
-              m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
-                  cu_idx, cu_sp);
-            }
-          }
-        }
-      }
-    }
-  }
   return cu_sp;
 }
 
 uint32_t SymbolFileDWARF::GetNumCompileUnits() {
   DWARFDebugInfo *info = DebugInfo();
   if (info)
     return info->GetNumCompileUnits();
   return 0;