DWARF: Share line tables of type units

[labath]

Summary

This patch creates a cache of file lists in line tables referenced by
type units. This cache is used to avoid parsing a line table twice
(since a file list will generally be shared by many type units).

It also sets things up in a way that parsing of DW_AT_decl_file
attributes will keep working even when we stop creating lldb compile
units for dwarf type units, but it stops short of actually doing that.
This means that the request for files now go directly to SymbolFileDWARF
instead of being routed there indirectly via the
lldb_private::CompileUnit class.

As a result of this, a number of occurences of SymbolContext variables
in DWARFASTParserClang have become unused, so I remove them.

This patch reduces the number of times a file list is being parsed, but
the situation is still suboptimal, as the parsed list is being copied
multiple times. This will be fixed when we stop creating CompileUnits
for DWARF type units.

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

309

Maybe make a "FileSpec DWARFDie::GetFile(uint32_t idx);" function?

388

Maybe:

std::string result = "<missing DWARF unit path>";

392–395

Maybe create a DWARFUnit function?:

const lldb_private::FileSpec &DWARFUnit::GetFileSpec();

393

Does this do the right thing if DW_AT_name is absolute?

2266–2267

Use new DWARFDie::GetFile()

2424–2425

Use new DWARFDie::GetFile()

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

286–306

Many attributes being individually fetched here. This is slow. We should probably iterate over all attributes?

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

812–813

why are these checks needed? Remove? Maybe left over from previous approach?

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

303

Can probably just be named GetFile

[aprantl]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

814

return {}; ?

[labath]

• Implement code review suggestions (except the Die::GetName, and return {})
• Add a test for the error message which is printed when we encounter an incomplete class (this is motivated by the bug in the printing of the name of the compile unit)

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

309

I'm trying to avoid diverging llvm and lldb DWARFDies more than they already are. As llvm DWARFDie will not be returning a FileSpec, I think going through the symbol file makes sense (that's the level at which the sharing happens anyway.

But even without that, the api doesn't seem right, as this is not a query that can be answered by the DWARFDie class alone.

392–395

Sounds good. This also diverges from llvm DWARFUnit, but OTOH, it fits in nicely with the GetCompilationDirectory function we have there already, so these two can be resolved later at the same time.

393

Woops. No, it doesn't.

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

286–306

Sounds good.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

812–813

The offset is going to be used as a key in a DenseMap, and DenseMap reserves two values of each type for the "empty" and "tombstone" keys. These are something like 0xff..ff and 0xff.ffe, so valid DWARF will not contain those values, but malformed can (and if it did, this code would crash when trying to insert those keys).

814

That wouldn't work, because {} is a temporary, and this function is returning a reference. Returning by reference saves a copy in the common case where DW_AT_stmt_list is valid, but I also need to handle the invalid case somehow. I could have this function return a pointer and return a nullptr in the invalid case (or something equivalent), but this saves the caller from checking that.

[JDevlieghere]

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

148

Nit: move this next to GetAbbrevOffset

200

Given the implementation, how about GetAbsolutePath? I think the "FileSpec" of a DWARF unit is a little weird, but feel free to ignore this.

288

Let's make this a Doxygen comment with ///< or even better just /// on the line above it so it doesn't wrap.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

821

Not your responsibility but we should really get rid of this thing as it doesn't make sense anymore in > DWARF5.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

303

Should this return an optional?

[labath]

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

200

GetAbsolutePath sounds good.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

821

I'm waiting on your llvm debug_lines patch. :)

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

303

I don't know. On one hand, both the level above this function and the level below use an empty FileSpec do denote failure, so I'd have to convert it explicitly in both places. OTOH, Optional is the direction we want to move in.

I can change it if you want..

[labath]

• address code review comments

[JDevlieghere]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

303

Yeah it's a bit of a chicken & egg problem. I don't have a strong opinion, so I'm fine with keeping it as is.

[clayborg]

Still want to resolve getting files from a DWARFUnit a bit better. See inlined comment.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

309

At the very least we should be asking the unit for the file? That is why I wanted to be able to ask the DWARFDIE for the file because it contains the right unit. If we just put the API on the unit, then we have the chance someone will use the wrong unit for the file. Also, as the DWARF gets fancier as time goes on (DWO, DWZ, etc), the unit might refer to another unit. But at the very least here I would feel better if we ask the DWARFUnit for the file. The GetDWARF() will ask the DWARFUnit in the DIE for the is DWARF file, then we will call the DWARF file class (SymbolFileDWARF or DWARFContext to get a file from the unit by passing a reference? Seems convoluted. Fine not adding the API as a FileSpec if we are trying to keep the API the same as LLVM.

2267

DWARFUnit::GetFile() or what ever solution we come up with from my previous long inlined comment.

2425

DWARFUnit::GetFile() or what ever solution we come up with from my previous long inlined comment.

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

306–343

much better!

[labath]

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

309

I think asking the unit for the file is fine. I'm not sure why llvm does not do that (it does the "get the context, pass the unit to get the line table, fetch the file" dance), but it sounds like a utility function doing this could be added there. Eventually our DWARFUnit will start using DWARFContext instead of SymbolFileDWARF for the other operations, which will make the two approaches pretty similar.

I've kept the function as returning FileSpecs. Returning any other type would be a pessimization, as the values are already parsed as FileSpecs.

[labath]

• add DWARFUnit::GetFile helper function

lit/SymbolFile/DWARF/debug-types-line-tables.s

+# RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux %s -o %t
+# RUN: lldb-test symbols %t | FileCheck %s
+
+  .file 1 "/tmp" "b.cc"
+
+  .section  .debug_types,"",@progbits
+
+# CHECK: Types:
+# Type unit one: "struct A" defined at b.cc:1
+# CHECK-DAG: name = "A", size = 4, decl = b.cc:1
+1:
+  .long 4f-2f                   # Length of Unit
+2:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .quad 5390450678491038984     # Type Signature
+  .long 3f-1b                   # Type DIE Offset
+  .byte 1                       # Abbrev [1] 0x17:0x1b DW_TAG_type_unit
+  .short  4                       # DW_AT_language
+  .long .Lline_table_start0     # DW_AT_stmt_list
+3:
+  .byte 2                       # Abbrev [2] 0x1e:0xc DW_TAG_structure_type
+  .long .LA                     # DW_AT_name
+  .byte 4                       # DW_AT_byte_size
+  .byte 1                       # DW_AT_decl_file
+  .byte 1                       # DW_AT_decl_line
+  .byte 0                       # End Of Children Mark
+4:
+
+# Type unit two: "struct B" defined at b.cc:2
+# It shares the same line table as unit one.
+# CHECK-DAG: name = "B", size = 4, decl = b.cc:2
+1:
+  .long 4f-2f                   # Length of Unit
+2:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .quad 5390450678491038985     # Type Signature
+  .long 3f-1b                   # Type DIE Offset
+  .byte 1                       # Abbrev [1] 0x17:0x1b DW_TAG_type_unit
+  .short  4                       # DW_AT_language
+  .long .Lline_table_start0     # DW_AT_stmt_list
+3:
+  .byte 2                       # Abbrev [2] 0x1e:0xc DW_TAG_structure_type
+  .long .LB                     # DW_AT_name
+  .byte 4                       # DW_AT_byte_size
+  .byte 1                       # DW_AT_decl_file
+  .byte 2                       # DW_AT_decl_line
+  .byte 0                       # End Of Children Mark
+4:
+
+# Type unit three: "struct C".
+# DW_AT_stmt_list missing
+# CHECK-DAG: name = "C", size = 4, line = 3
+1:
+  .long 4f-2f                   # Length of Unit
+2:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .quad 5390450678491038986     # Type Signature
+  .long 3f-1b                   # Type DIE Offset
+  .byte 4                       # Abbrev [4] 0x17:0x1b DW_TAG_type_unit
+  .short  4                       # DW_AT_language
+3:
+  .byte 2                       # Abbrev [2] 0x1e:0xc DW_TAG_structure_type
+  .long .LC                     # DW_AT_name
+  .byte 4                       # DW_AT_byte_size
+  .byte 1                       # DW_AT_decl_file
+  .byte 3                       # DW_AT_decl_line
+  .byte 0                       # End Of Children Mark
+4:
+
+# Type unit four: "struct D".
+# DW_AT_stmt_list invalid
+# CHECK-DAG: name = "D", size = 4, line = 4
+1:
+  .long 4f-2f                   # Length of Unit
+2:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .quad 5390450678491038987     # Type Signature
+  .long 3f-1b                   # Type DIE Offset
+  .byte 1                       # Abbrev [1] 0x17:0x1b DW_TAG_type_unit
+  .short  4                       # DW_AT_language
+  .long .Lline_table_start0+47  # DW_AT_stmt_list
+3:
+  .byte 2                       # Abbrev [2] 0x1e:0xc DW_TAG_structure_type
+  .long .LD                     # DW_AT_name
+  .byte 4                       # DW_AT_byte_size
+  .byte 1                       # DW_AT_decl_file
+  .byte 4                       # DW_AT_decl_line
+  .byte 0                       # End Of Children Mark
+4:
+
+# Type unit five: "struct E".
+# DW_AT_decl_file invalid
+# CHECK-DAG: name = "E", size = 4, line = 5
+1:
+  .long 4f-2f                   # Length of Unit
+2:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .quad 5390450678491038988     # Type Signature
+  .long 3f-1b                   # Type DIE Offset
+  .byte 1                       # Abbrev [1] 0x17:0x1b DW_TAG_type_unit
+  .short  4                       # DW_AT_language
+  .long .Lline_table_start0     # DW_AT_stmt_list
+3:
+  .byte 2                       # Abbrev [2] 0x1e:0xc DW_TAG_structure_type
+  .long .LE                     # DW_AT_name
+  .byte 4                       # DW_AT_byte_size
+  .byte 47                      # DW_AT_decl_file
+  .byte 5                       # DW_AT_decl_line
+  .byte 0                       # End Of Children Mark
+4:
+
+
+  .section  .debug_str,"MS",@progbits,1
+.LA:
+  .asciz  "A"
+.LB:
+  .asciz  "B"
+.LC:
+  .asciz  "C"
+.LD:
+  .asciz  "D"
+.LE:
+  .asciz  "E"
+
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 65                      # DW_TAG_type_unit
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 2                       # Abbreviation Code
+  .byte 19                      # DW_TAG_structure_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 11                      # DW_AT_byte_size
+  .byte 11                      # DW_FORM_data1
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 3                       # Abbreviation Code
+  .byte 65                      # DW_TAG_type_unit
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 4                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end1-.Ldebug_info_start1 # Length of Unit
+.Ldebug_info_start1:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 4                       # Abbrev [4] 0xb:0x32 DW_TAG_compile_unit
+  .byte 0                       # End Of Children Mark
+.Ldebug_info_end1:
+
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

bool ParseTemplateDIE(const DWARFDIE &die,
                         lldb_private::ClangASTContext::TemplateParameterInfos
                             &template_param_infos);
   bool ParseTemplateParameterInfos(
       const DWARFDIE &parent_die,
       lldb_private::ClangASTContext::TemplateParameterInfos
           &template_param_infos);
 
   bool ParseChildMembers(
-      const lldb_private::SymbolContext &sc, const DWARFDIE &die,
-      lldb_private::CompilerType &class_compiler_type,
+      const DWARFDIE &die, lldb_private::CompilerType &class_compiler_type,
       const lldb::LanguageType class_language,
       std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
       std::vector<int> &member_accessibilities,
       std::vector<DWARFDIE> &member_function_dies,
       DelayedPropertyList &delayed_properties,
       lldb::AccessType &default_accessibility, bool &is_a_class,
       lldb_private::ClangASTImporter::LayoutInfo &layout_info);
 
   size_t
-  ParseChildParameters(lldb_private::CompileUnit &comp_unit,
-                       clang::DeclContext *containing_decl_ctx,
+  ParseChildParameters(clang::DeclContext *containing_decl_ctx,
                        const DWARFDIE &parent_die, bool skip_artificial,
                        bool &is_static, bool &is_variadic,
                        bool &has_template_params,
                        std::vector<lldb_private::CompilerType> &function_args,
                        std::vector<clang::ParmVarDecl *> &function_param_decls,
                        unsigned &type_quals);
 
-  size_t ParseChildEnumerators(const lldb_private::SymbolContext &sc,
-                               lldb_private::CompilerType &compiler_type,
+  size_t ParseChildEnumerators(lldb_private::CompilerType &compiler_type,
                                bool is_signed, uint32_t enumerator_byte_size,
                                const DWARFDIE &parent_die);
 
   lldb_private::Type *GetTypeForDIE(const DWARFDIE &die);
 
   clang::Decl *GetClangDeclForDIE(const DWARFDIE &die);
 
   clang::DeclContext *GetClangDeclContextForDIE(const DWARFDIE &die);

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

static void CompleteExternalTagDeclType(ClangASTImporter &ast_importer,
   }
 }
 
 namespace {
 /// Parsed form of all attributes that are relevant for type reconstruction.
 /// Some attributes are relevant for all kinds of types (declaration), while
 /// others are only meaningful to a specific type (is_virtual)
 struct ParsedTypeAttributes {
-  ParsedTypeAttributes(const DWARFDIE &die, CompileUnit &comp_unit);
+  explicit ParsedTypeAttributes(const DWARFDIE &die);
 
   AccessType accessibility = eAccessNone;
   bool is_artificial = false;
   bool is_complete_objc_class = false;
   bool is_explicit = false;
   bool is_forward_declaration = false;
   bool is_inline = false;
   bool is_scoped_enum = false;
struct ParsedTypeAttributes {
   llvm::Optional<uint64_t> byte_size;
   size_t calling_convention = llvm::dwarf::DW_CC_normal;
   uint32_t bit_stride = 0;
   uint32_t byte_stride = 0;
   uint32_t encoding = 0;
 };
 } // namespace
 
-ParsedTypeAttributes::ParsedTypeAttributes(const DWARFDIE &die,
-                                           CompileUnit &comp_unit) {
+ParsedTypeAttributes::ParsedTypeAttributes(const DWARFDIE &die) {
   DWARFAttributes attributes;
   size_t num_attributes = die.GetAttributes(attributes);
   for (size_t i = 0; i < num_attributes; ++i) {
     dw_attr_t attr = attributes.AttributeAtIndex(i);
     DWARFFormValue form_value;
     if (!attributes.ExtractFormValueAtIndex(i, form_value))
       continue;
     switch (attr) {
case DW_AT_calling_convention:
       calling_convention = form_value.Unsigned();
       break;
 
     case DW_AT_containing_type:
       containing_type = form_value;
       break;
 
     case DW_AT_decl_file:
-      decl.SetFile(comp_unit.GetSupportFiles().GetFileSpecAtIndex(
-          form_value.Unsigned()));
+      decl.SetFile(
+          die.GetDWARF()->GetSupportFile(*die.GetCU(), form_value.Unsigned()));
       break;
     case DW_AT_decl_line:
       decl.SetLine(form_value.Unsigned());
       break;
     case DW_AT_decl_column:
       decl.SetColumn(form_value.Unsigned());
       break;
 
for (size_t i = 0; i < num_attributes; ++i) {
 
     case DW_AT_GNU_vector:
       is_vector = form_value.Boolean();
       break;
     }
   }
 }
 
+static std::string GetUnitName(const DWARFDIE &die) {
+  std::string result = "the source file";
+  DWARFUnit *unit = die.GetCU();
+  if (!unit)
+    return result;
+  if (FileSpec spec =
+          unit->GetCompilationDirectory().CopyByAppendingPathComponent(
+              unit->GetUnitDIEOnly().GetName()))
+    return spec.GetPath();
+  return result;
+}
+
 TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
                                                const DWARFDIE &die, Log *log,
                                                bool *type_is_new_ptr) {
   if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   if (!die)
     return nullptr;
TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
   Type *type_ptr = dwarf->GetDIEToType().lookup(die.GetDIE());
   if (type_ptr == DIE_IS_BEING_PARSED)
     return nullptr;
   if (type_ptr)
     return type_ptr->shared_from_this();
   // Set a bit that lets us know that we are currently parsing this
   dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
 
-  ParsedTypeAttributes attrs(die, *sc.comp_unit);
+  ParsedTypeAttributes attrs(die);
 
   if (DWARFDIE signature_die = attrs.signature.Reference()) {
     if (TypeSP type_sp =
             ParseTypeFromDWARF(sc, signature_die, log, type_is_new_ptr)) {
       dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
       if (clang::DeclContext *decl_ctx =
               GetCachedClangDeclContextForDIE(signature_die))
         LinkDeclContextToDIE(decl_ctx, die);
case DW_TAG_enumeration_type: {
 
     type_sp = std::make_shared<Type>(
         die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
         dwarf->GetUID(DIERef(attrs.type)), Type::eEncodingIsUID, &attrs.decl,
         clang_type, Type::eResolveStateForward);
 
     if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
       if (die.HasChildren()) {
-        SymbolContext cu_sc(die.GetLLDBCompileUnit());
         bool is_signed = false;
         enumerator_clang_type.IsIntegerType(is_signed);
-        ParseChildEnumerators(cu_sc, clang_type, is_signed,
+        ParseChildEnumerators(clang_type, is_signed,
                               type_sp->GetByteSize().getValueOr(0), die);
       }
       ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
     } else {
       dwarf->GetObjectFile()->GetModule()->ReportError(
           "DWARF DIE at 0x%8.8x named \"%s\" was not able to start its "
           "definition.\nPlease file a bug and attach the file at the "
           "start of this error message",
case DW_TAG_subroutine_type: {
     // ParseChildParameters(...) if we find a "this" parameters as the
     // first parameter
     if (is_cxx_method) {
       is_static = true;
     }
 
     if (die.HasChildren()) {
       bool skip_artificial = true;
-      ParseChildParameters(*sc.comp_unit, containing_decl_ctx, die,
-                           skip_artificial, is_static, is_variadic,
-                           has_template_params, function_param_types,
-                           function_param_decls, type_quals);
+      ParseChildParameters(containing_decl_ctx, die, skip_artificial, is_static,
+                           is_variadic, has_template_params,
+                           function_param_types, function_param_decls,
+                           type_quals);
     }
 
     bool ignore_containing_context = false;
     // Check for templatized class member functions. If we had any
     // DW_TAG_template_type_parameter or DW_TAG_template_value_parameter
     // the DW_TAG_subprogram DIE, then we can't let this become a method in
     // a class. Why? Because templatized functions are only emitted if one
     // of the templatized methods is used in the current compile unit and
if (attrs.name) {
 
       if (!type_handled) {
         clang::FunctionDecl *function_decl = nullptr;
         clang::FunctionDecl *template_function_decl = nullptr;
 
         if (attrs.abstract_origin.IsValid()) {
           DWARFDIE abs_die = attrs.abstract_origin.Reference();
 
-          SymbolContext sc;
-
           if (dwarf->ResolveType(abs_die)) {
             function_decl = llvm::dyn_cast_or_null<clang::FunctionDecl>(
                 GetCachedClangDeclContextForDIE(abs_die));
 
             if (function_decl) {
               LinkDeclContextToDIE(function_decl, die);
             }
           }
if (element_type) {
           else
             module_sp->ReportError(
                 "DWARF DW_TAG_array_type DIE at 0x%8.8x has a "
                 "class/union/struct element type DIE 0x%8.8x that is a "
                 "forward declaration, not a complete definition.\nPlease "
                 "file a bug against the compiler and include the "
                 "preprocessed output for %s",
                 die.GetOffset(), type_die_ref.die_offset,
-                die.GetLLDBCompileUnit()
-                    ? die.GetLLDBCompileUnit()->GetPath().c_str()
-                    : "the source file");
+                GetUnitName(die).c_str());
         }
 
         // We have no choice other than to pretend that the element class
         // type is complete. If we don't do this, clang will crash when
         // trying to layout the class. Since we provide layout
         // assistance, all ivars in this class and other classes will be
         // fine, this is the best we can do short of crashing.
         if (ClangASTContext::StartTagDeclarationDefinition(
if (type_sp.get()) {
     if (sc_parent_tag == DW_TAG_compile_unit ||
         sc_parent_tag == DW_TAG_partial_unit) {
       symbol_context_scope = sc.comp_unit;
     } else if (sc.function != NULL && sc_parent_die) {
       symbol_context_scope =
           sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
       if (symbol_context_scope == NULL)
         symbol_context_scope = sc.function;
-    }
+    } else
+      symbol_context_scope = sc.module_sp.get();
 
     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);
ClangASTImporter::LayoutInfo layout_info;
         } else if (tag == DW_TAG_union_type) {
           tag_decl_kind = clang::TTK_Union;
           default_accessibility = eAccessPublic;
         } else if (tag == DW_TAG_class_type) {
           tag_decl_kind = clang::TTK_Class;
           default_accessibility = eAccessPrivate;
         }
 
-        SymbolContext sc(die.GetLLDBCompileUnit());
         std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
         std::vector<int> member_accessibilities;
         bool is_a_class = false;
         // Parse members and base classes first
         std::vector<DWARFDIE> member_function_dies;
 
         DelayedPropertyList delayed_properties;
-        ParseChildMembers(sc, die, clang_type, class_language, bases,
+        ParseChildMembers(die, clang_type, class_language, bases,
                           member_accessibilities, member_function_dies,
                           delayed_properties, default_accessibility, is_a_class,
                           layout_info);
 
         // Now parse any methods if there were any...
         for (const DWARFDIE &die : member_function_dies)
           dwarf->ResolveType(die);
 
case DW_TAG_class_type: {
     }
   }
 
     return (bool)clang_type;
 
   case DW_TAG_enumeration_type:
     if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
       if (die.HasChildren()) {
-        SymbolContext sc(die.GetLLDBCompileUnit());
         bool is_signed = false;
         clang_type.IsIntegerType(is_signed);
-        ParseChildEnumerators(sc, clang_type, is_signed,
+        ParseChildEnumerators(clang_type, is_signed,
                               type->GetByteSize().getValueOr(0), die);
       }
       ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
     }
     return (bool)clang_type;
 
   default:
     assert(false && "not a forward clang type decl!");
DWARFASTParserClang::GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) {
   clang::DeclContext *clang_decl_ctx =
       GetClangDeclContextContainingDIE(die, nullptr);
   if (clang_decl_ctx)
     return CompilerDeclContext(&m_ast, clang_decl_ctx);
   return CompilerDeclContext();
 }
 
 size_t DWARFASTParserClang::ParseChildEnumerators(
-    const SymbolContext &sc, lldb_private::CompilerType &clang_type,
-    bool is_signed, uint32_t enumerator_byte_size, const DWARFDIE &parent_die) {
+    lldb_private::CompilerType &clang_type, bool is_signed,
+    uint32_t enumerator_byte_size, const DWARFDIE &parent_die) {
   if (!parent_die)
     return 0;
 
   size_t enumerators_added = 0;
 
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     const dw_tag_t tag = die.Tag();
if (tag == DW_TAG_enumerator) {
 
             case DW_AT_name:
               name = form_value.AsCString();
               break;
 
             case DW_AT_description:
             default:
             case DW_AT_decl_file:
-              decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                  form_value.Unsigned()));
+              decl.SetFile(die.GetDWARF()->GetSupportFile(
+                  *die.GetCU(), form_value.Unsigned()));
               break;
             case DW_AT_decl_line:
               decl.SetLine(form_value.Unsigned());
               break;
             case DW_AT_decl_column:
               decl.SetColumn(form_value.Unsigned());
               break;
             case DW_AT_sibling:
if (func_range.GetBaseAddress().IsValid()) {
         DWARFDeclContext decl_ctx;
         StreamString sstr;
 
         die.GetDWARFDeclContext(decl_ctx);
         sstr << decl_ctx.GetQualifiedName();
 
         clang::DeclContext *containing_decl_ctx =
             GetClangDeclContextContainingDIE(die, nullptr);
-        ParseChildParameters(comp_unit, containing_decl_ctx, die, true,
-                             is_static, is_variadic, has_template_params,
-                             param_types, param_decls, type_quals);
+        ParseChildParameters(containing_decl_ctx, die, true, is_static,
+                             is_variadic, has_template_params, param_types,
+                             param_decls, type_quals);
         sstr << "(";
         for (size_t i = 0; i < param_types.size(); i++) {
           if (i > 0)
             sstr << ", ";
           sstr << param_types[i].GetTypeName();
         }
         if (is_variadic)
           sstr << ", ...";
         sstr << ")";
         if (type_quals & clang::Qualifiers::Const)
           sstr << " const";
 
         func_name.SetValue(ConstString(sstr.GetString()), false);
       } else
         func_name.SetValue(ConstString(name), false);
 
       FunctionSP func_sp;
       std::unique_ptr<Declaration> decl_up;
       if (decl_file != 0 || decl_line != 0 || decl_column != 0)
         decl_up.reset(new Declaration(
-            comp_unit.GetSupportFiles().GetFileSpecAtIndex(decl_file),
-            decl_line, decl_column));
+            die.GetDWARF()->GetSupportFile(*die.GetCU(), decl_file), decl_line,
+            decl_column));
 
       SymbolFileDWARF *dwarf = die.GetDWARF();
       // Supply the type _only_ if it has already been parsed
       Type *func_type = dwarf->GetDIEToType().lookup(die.GetDIE());
 
       assert(func_type == nullptr || func_type != DIE_IS_BEING_PARSED);
 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
if (func_range.GetBaseAddress().IsValid()) {
         }
       }
     }
   }
   return nullptr;
 }
 
 bool DWARFASTParserClang::ParseChildMembers(
-    const SymbolContext &sc, const DWARFDIE &parent_die,
-    CompilerType &class_clang_type, const LanguageType class_language,
+    const DWARFDIE &parent_die, CompilerType &class_clang_type,
+    const LanguageType class_language,
     std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
     std::vector<int> &member_accessibilities,
     std::vector<DWARFDIE> &member_function_dies,
     DelayedPropertyList &delayed_properties, AccessType &default_accessibility,
     bool &is_a_class, ClangASTImporter::LayoutInfo &layout_info) {
   if (!parent_die)
     return false;
 
case DW_TAG_APPLE_property: {
                 }
 
                 if ((this_field_info.bit_offset >= parent_bit_size) ||
                     !last_field_info.NextBitfieldOffsetIsValid(
                         this_field_info.bit_offset)) {
                   ObjectFile *objfile = die.GetDWARF()->GetObjectFile();
                   objfile->GetModule()->ReportWarning(
                       "0x%8.8" PRIx64 ": %s bitfield named \"%s\" has invalid "
-                                      "bit offset (0x%8.8" PRIx64
                       ") member will be ignored. Please file a bug against the "
                       "compiler and include the preprocessed output for %s\n",
                       die.GetID(), DW_TAG_value_to_name(tag), name,
                       this_field_info.bit_offset,
-                      sc.comp_unit ? sc.comp_unit->GetPath().c_str()
-                                   : "the source file");
+                      GetUnitName(parent_die).c_str());
                   this_field_info.Clear();
                   continue;
                 }
 
                 // Update the field bit offset we will report for layout
                 field_bit_offset = this_field_info.bit_offset;
 
                 // If the member to be emitted did not start on a character
case DW_TAG_APPLE_property: {
                       die.GetOffset(), name);
                 else
                   module_sp->ReportError(
                       "DWARF DIE at 0x%8.8x (class %s) has a member variable "
                       "0x%8.8x (%s) whose type is a forward declaration, not a "
                       "complete definition.\nPlease file a bug against the "
                       "compiler and include the preprocessed output for %s",
                       parent_die.GetOffset(), parent_die.GetName(),
-                      die.GetOffset(), name,
-                      sc.comp_unit ? sc.comp_unit->GetPath().c_str()
-                                   : "the source file");
+                      die.GetOffset(), name, GetUnitName(parent_die).c_str());
                 // We have no choice other than to pretend that the member
                 // class is complete. If we don't do this, clang will crash
                 // when trying to layout the class. Since we provide layout
                 // assistance, all ivars in this class and other classes will
                 // be fine, this is the best we can do short of crashing.
                 if (ClangASTContext::StartTagDeclarationDefinition(
                         member_clang_type)) {
                   ClangASTContext::CompleteTagDeclarationDefinition(
default:
       break;
     }
   }
 
   return true;
 }
 
 size_t DWARFASTParserClang::ParseChildParameters(
-    CompileUnit &comp_unit, clang::DeclContext *containing_decl_ctx,
-    const DWARFDIE &parent_die, bool skip_artificial, bool &is_static,
-    bool &is_variadic, bool &has_template_params,
-    std::vector<CompilerType> &function_param_types,
+    clang::DeclContext *containing_decl_ctx, const DWARFDIE &parent_die,
+    bool skip_artificial, bool &is_static, bool &is_variadic,
+    bool &has_template_params, std::vector<CompilerType> &function_param_types,
     std::vector<clang::ParmVarDecl *> &function_param_decls,
     unsigned &type_quals) {
   if (!parent_die)
     return 0;
 
   size_t arg_idx = 0;
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {

source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h

public:
   lldb::user_id_t GetID() const;
 
   const char *GetName() const;
 
   lldb::LanguageType GetLanguage() const;
 
   lldb::ModuleSP GetModule() const;
 
-  lldb_private::CompileUnit *GetLLDBCompileUnit() const;
-
   // Getting attribute values from the DIE.
   //
   // GetAttributeValueAsXXX() functions should only be used if you are
   // looking for one or two attributes on a DIE. If you are trying to
   // parse all attributes, use GetAttributes (...) instead
   const char *GetAttributeValueAsString(const dw_attr_t attr,
                                         const char *fail_value) const;
 

source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

 lldb::ModuleSP DWARFBaseDIE::GetModule() const {
   SymbolFileDWARF *dwarf = GetDWARF();
   if (dwarf)
     return dwarf->GetObjectFile()->GetModule();
   else
     return lldb::ModuleSP();
 }
 
-lldb_private::CompileUnit *DWARFBaseDIE::GetLLDBCompileUnit() const {
-  if (IsValid())
-    return GetDWARF()->GetCompUnitForDWARFCompUnit(GetCU());
-  else
-    return nullptr;
-}
-
 dw_offset_t DWARFBaseDIE::GetOffset() const {
   if (IsValid())
     return m_die->GetOffset();
   else
     return DW_INVALID_OFFSET;
 }
 
 SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const {

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

 #include "llvm/Support/Error.h"
 
 class DWARFCompileUnit : public DWARFUnit {
 public:
   void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) override;
 
   void Dump(lldb_private::Stream *s) const override;
 
+  static bool classof(const DWARFUnit *unit) { return !unit->IsTypeUnit(); }
+
 private:
   DWARFCompileUnit(SymbolFileDWARF *dwarf, lldb::user_id_t uid,
                    const DWARFUnitHeader &header,
                    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/DWARFTypeUnit.h

public:
   void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) override {}
 
   void Dump(lldb_private::Stream *s) const override;
 
   uint64_t GetTypeHash() { return m_header.GetTypeHash(); }
 
   dw_offset_t GetTypeOffset() { return GetOffset() + m_header.GetTypeOffset(); }
 
-  static bool classof(const DWARFUnit *unit) {
-    return unit->GetUnitType() == DW_UT_type;
-  }
+  static bool classof(const DWARFUnit *unit) { return unit->IsTypeUnit(); }
 
 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/DWARFUnit.h

public:
   uint16_t GetVersion() const { return m_header.GetVersion(); }
   const DWARFAbbreviationDeclarationSet *GetAbbreviations() const;
   dw_offset_t GetAbbrevOffset() const;
   uint8_t GetAddressByteSize() const { return m_header.GetAddressByteSize(); }
   dw_addr_t GetBaseAddress() const { return m_base_addr; }
   dw_addr_t GetAddrBase() const { return m_addr_base; }
   dw_addr_t GetRangesBase() const { return m_ranges_base; }
   dw_addr_t GetStrOffsetsBase() const { return m_str_offsets_base; }
+  dw_offset_t GetLineTableOffset();
   void SetAddrBase(dw_addr_t addr_base);
   void SetRangesBase(dw_addr_t ranges_base);
   void SetBaseObjOffset(dw_offset_t base_obj_offset);
   void SetStrOffsetsBase(dw_offset_t str_offsets_base);
   virtual void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) = 0;
 
   lldb::ByteOrder GetByteOrder() const;
 
public:
 
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
   lldb::LanguageType GetLanguageType();
 
   bool GetIsOptimized();
 
   const lldb_private::FileSpec &GetCompilationDirectory();
   lldb_private::FileSpec::Style GetPathStyle();
 
   SymbolFileDWARFDwo *GetDwoSymbolFile() const;
 
   dw_offset_t GetBaseObjOffset() const;
 
   die_iterator_range dies() {
     ExtractDIEsIfNeeded();
     return die_iterator_range(m_die_array.begin(), m_die_array.end());
   }
 
   DIERef::Section GetDebugSection() const { return m_section; }
 
   uint8_t GetUnitType() const { return m_header.GetUnitType(); }
+  bool IsTypeUnit() const { return m_header.IsTypeUnit(); }
 
   /// Return a list of address ranges resulting from a (possibly encoded)
   /// range list starting at a given offset in the appropriate ranges section.
   llvm::Expected<DWARFRangeList> FindRnglistFromOffset(dw_offset_t offset) const;
 
   /// Return a list of address ranges retrieved from an encoded range
   /// list whose offset is found via a table lookup given an index (DWARF v5
   /// and later).
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.
+  dw_offset_t m_line_table_offset =
+      DW_INVALID_OFFSET; // Value of DW_AT_stmt_list.
   const DIERef::Section m_section;
 
 private:
   void ParseProducerInfo();
   void ExtractDIEsRWLocked();
   void ClearDIEsRWLocked();
 
   void AddUnitDIE(const DWARFDebugInfoEntry &cu_die);
 
   void ComputeCompDirAndGuessPathStyle();
 
   DISALLOW_COPY_AND_ASSIGN(DWARFUnit);
 };
 
 #endif // SymbolFileDWARF_DWARFUnit_h_

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

static void SetDwoStrOffsetsBase(DWARFUnit *dwo_cu) {
   // Skip padding.
   baseOffset += 2;
 
   dwo_cu->SetStrOffsetsBase(baseOffset);
 }
 
 // m_die_array_mutex must be already held as read/write.
 void DWARFUnit::AddUnitDIE(const DWARFDebugInfoEntry &cu_die) {
   dw_addr_t addr_base = cu_die.GetAttributeValueAsUnsigned(
       this, DW_AT_addr_base, LLDB_INVALID_ADDRESS);
   if (addr_base != LLDB_INVALID_ADDRESS)
     SetAddrBase(addr_base);
 
   dw_addr_t ranges_base = cu_die.GetAttributeValueAsUnsigned(
       this, DW_AT_rnglists_base, LLDB_INVALID_ADDRESS);
   if (ranges_base != LLDB_INVALID_ADDRESS)
     SetRangesBase(ranges_base);
 
   SetStrOffsetsBase(
       cu_die.GetAttributeValueAsUnsigned(this, DW_AT_str_offsets_base, 0));
 
   uint64_t base_addr = cu_die.GetAttributeValueAsAddress(this, DW_AT_low_pc,
                                                          LLDB_INVALID_ADDRESS);
   if (base_addr == LLDB_INVALID_ADDRESS)
     base_addr = cu_die.GetAttributeValueAsAddress(this, DW_AT_entry_pc, 0);
   SetBaseAddress(base_addr);
 
+  m_line_table_offset = cu_die.GetAttributeValueAsUnsigned(
+      this, DW_AT_stmt_list, DW_INVALID_OFFSET);
+
   std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
       m_dwarf->GetDwoSymbolFileForCompileUnit(*this, cu_die);
   if (!dwo_symbol_file)
     return;
 
   DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
   if (!dwo_cu)
     return; // Can't fetch the compile unit from the dwo file.
 
   DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
   if (!dwo_cu_die.IsValid())
     return; // Can't fetch the compile unit DIE from the dwo file.
 
   uint64_t main_dwo_id =
       cu_die.GetAttributeValueAsUnsigned(this, DW_AT_GNU_dwo_id, 0);
   uint64_t sub_dwo_id =
       dwo_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_dwo_id, 0);
   if (main_dwo_id != sub_dwo_id)
     return; // The 2 dwo ID isn't match. Don't use the dwo file as it belongs to
   // a differectn compilation.
 
   m_dwo_symbol_file = std::move(dwo_symbol_file);
 
   // Here for DWO CU we want to use the address base set in the skeleton unit
   // (DW_AT_addr_base) if it is available and use the DW_AT_GNU_addr_base
   // otherwise. We do that because pre-DWARF v5 could use the DW_AT_GNU_*
   // attributes which were applicable to the DWO units. The corresponding
   // DW_AT_* attributes standardized in DWARF v5 are also applicable to the main
   // unit in contrast.
   if (addr_base == LLDB_INVALID_ADDRESS)
     addr_base =
         cu_die.GetAttributeValueAsUnsigned(this, DW_AT_GNU_addr_base, 0);
   dwo_cu->SetAddrBase(addr_base);
 
   if (ranges_base == LLDB_INVALID_ADDRESS)
     ranges_base =
         cu_die.GetAttributeValueAsUnsigned(this, DW_AT_GNU_ranges_base, 0);
   dwo_cu->SetRangesBase(ranges_base);
 
   dwo_cu->SetBaseObjOffset(GetOffset());
 
   SetDwoStrOffsetsBase(dwo_cu);
 }
 

 const DWARFAbbreviationDeclarationSet *DWARFUnit::GetAbbreviations() const {
   return m_abbrevs;
 }
 
 dw_offset_t DWARFUnit::GetAbbrevOffset() const {
   return m_abbrevs ? m_abbrevs->GetOffset() : DW_INVALID_OFFSET;
 }
 
+dw_offset_t DWARFUnit::GetLineTableOffset() {
+  ExtractUnitDIEIfNeeded();
+  return m_line_table_offset;
+}
+
 void DWARFUnit::SetAddrBase(dw_addr_t addr_base) { m_addr_base = addr_base; }
 
 void DWARFUnit::SetRangesBase(dw_addr_t ranges_base) {
   m_ranges_base = ranges_base;
 }
 
 void DWARFUnit::SetBaseObjOffset(dw_offset_t base_obj_offset) {
   m_base_obj_offset = base_obj_offset;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 class DWARFDebugAbbrev;
 class DWARFDebugAranges;
 class DWARFDebugInfo;
 class DWARFDebugInfoEntry;
 class DWARFDebugLine;
 class DWARFDebugRangesBase;
 class DWARFDeclContext;
 class DWARFFormValue;
+class DWARFTypeUnit;
 class SymbolFileDWARFDebugMap;
 class SymbolFileDWARFDwo;
 class SymbolFileDWARFDwp;
 
 #define DIE_IS_BEING_PARSED ((lldb_private::Type *)1)
 
 class SymbolFileDWARF : public lldb_private::SymbolFile,
                         public lldb_private::UserID {
public:
   ParseCallEdgesInFunction(UserID func_id) override;
 
   void Dump(lldb_private::Stream &s) override;
 
   void DumpClangAST(lldb_private::Stream &s) override;
 
   lldb_private::DWARFContext &GetDWARFContext() { return m_context; }
 
+  lldb_private::FileSpec GetSupportFile(DWARFUnit &unit, size_t file_idx);
+
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
protected:
   struct DecodedUID {
     SymbolFileDWARF *dwarf;
     DIERef ref;
   };
   DecodedUID DecodeUID(lldb::user_id_t uid);
 
   SymbolFileDWARFDwp *GetDwpSymbolFile();
 
+  const lldb_private::FileSpecList &GetTypeUnitSupportFiles(DWARFTypeUnit &tu);
+
   lldb::ModuleWP m_debug_map_module_wp;
   SymbolFileDWARFDebugMap *m_debug_map_symfile;
 
   llvm::once_flag m_dwp_symfile_once_flag;
   std::unique_ptr<SymbolFileDWARFDwp> m_dwp_symfile;
 
   lldb_private::DWARFContext m_context;
 
protected:
   NameToOffsetMap m_function_scope_qualified_name_map;
   std::unique_ptr<DWARFDebugRangesBase> m_ranges;
   std::unique_ptr<DWARFDebugRangesBase> m_rnglists;
   UniqueDWARFASTTypeMap m_unique_ast_type_map;
   DIEToTypePtr m_die_to_type;
   DIEToVariableSP m_die_to_variable_sp;
   DIEToClangType m_forward_decl_die_to_clang_type;
   ClangTypeToDIE m_forward_decl_clang_type_to_die;
+  llvm::DenseMap<dw_offset_t, lldb_private::FileSpecList>
+      m_type_unit_support_files;
 };
 
 #endif // SymbolFileDWARF_SymbolFileDWARF_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "lldb/Symbol/VariableList.h"
 
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Target.h"
 
 #include "AppleDWARFIndex.h"
 #include "DWARFASTParser.h"
 #include "DWARFASTParserClang.h"
+#include "DWARFCompileUnit.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugLine.h"
 #include "DWARFDebugMacro.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
+#include "DWARFTypeUnit.h"
 #include "DWARFUnit.h"
 #include "DebugNamesDWARFIndex.h"
 #include "LogChannelDWARF.h"
 #include "ManualDWARFIndex.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDwp.h"
 
size_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
   }
   // FixupTypes();
   return functions_added;
 }
 
 bool SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit,
                                         FileSpecList &support_files) {
   ASSERT_MODULE_LOCK(this);
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
-  if (dwarf_cu) {
-    const DWARFBaseDIE cu_die = dwarf_cu->GetUnitDIEOnly();
+  DWARFUnit *unit = GetDWARFCompileUnit(&comp_unit);
+  if (auto *tu = llvm::dyn_cast_or_null<DWARFTypeUnit>(unit)) {
+    support_files = GetTypeUnitSupportFiles(*tu);
+    return true;
+  }
 
-    if (cu_die) {
-      const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
-          DW_AT_stmt_list, DW_INVALID_OFFSET);
-      if (stmt_list != DW_INVALID_OFFSET) {
-        // All file indexes in DWARF are one based and a file of index zero is
-        // supposed to be the compile unit itself.
-        support_files.Append(comp_unit);
-        return DWARFDebugLine::ParseSupportFiles(
-            comp_unit.GetModule(), m_context.getOrLoadLineData(), stmt_list,
-            support_files, dwarf_cu);
-      }
+  if (unit) {
+    const dw_offset_t stmt_list = unit->GetLineTableOffset();
+      return DWARFDebugLine::ParseSupportFiles(comp_unit.GetModule(),
+                                               m_context.getOrLoadLineData(),
+                                               stmt_list, support_files, unit);
     }
   }
   return false;
 }
 
+FileSpec SymbolFileDWARF::GetSupportFile(DWARFUnit &unit, size_t file_idx) {
+  if (CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(&unit))
+    return lldb_cu->GetSupportFiles().GetFileSpecAtIndex(file_idx);
+  return FileSpec();
+}
+
+const FileSpecList &
+SymbolFileDWARF::GetTypeUnitSupportFiles(DWARFTypeUnit &tu) {
+  static FileSpecList empty_list;
+
+  dw_offset_t offset = tu.GetLineTableOffset();
+  if (offset == DW_INVALID_OFFSET ||
+      offset == llvm::DenseMapInfo<dw_offset_t>::getEmptyKey() ||
+      offset == llvm::DenseMapInfo<dw_offset_t>::getTombstoneKey())
+    return empty_list;
+
+  // Many type units can share a line table, so parse the support file list
+  // once, and cache it based on the offset field.
+  auto iter_bool = m_type_unit_support_files.try_emplace(offset);
+  FileSpecList &list = iter_bool.first->second;
+  if (iter_bool.second) {
+    list.Append(FileSpec());
+    DWARFDebugLine::ParseSupportFiles(GetObjectFile()->GetModule(),
+                                      m_context.getOrLoadLineData(), offset,
+                                      list, &tu);
+  }
+  return list;
+}
+
 bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetIsOptimized();
   return false;
 }