CompileUnit: Use shared_ptr for storing support file lists

[labath]

Summary

This patch refactors the CompileUnit class to store the support files in
a shared_ptr, and changes the SymbolFiles to hand them out as such.

This allows the file lists to be shared between compile units, or
between other objects. The motivation for this is to enable
SymbolFileDWARF to keep a handle on the file lists it parses, so that it
can use it when processing type units (which will not be handed out as
lldb_private::CompileUnits). This will be implemented in follow-up
patch(es).

Since I was already changing the signature of this function, I made it
return an Expected<shared_ptr> and changed all the places that were
silently doing nothing to return an error. The CompileUnit class still
returns an empty file list in case the parsing failed, but it first
makes sure any errors get reported.

[labath]

This isn't strictly necessary. I could just have SymbolFileDWARF keep one copy a file list for each line table. That way each list would be stored exactly twice. However, it seemed like it would be nice to avoid that (though I don't have any data about how much this saves or anything).

[labath]

Actually, I've run into a bit of a snag while trying to implement the full line table sharing. The thing is, before DWARF5, the line tables are not fully independent, and require the DW_AT_comp_dir of the compile unit in order to resolve the relative paths correctly. Type units do not have the DW_AT_comp_dir attribute, and so in order to correctly parse their line tables, I'd have to check their DW_AT_stmt_list attribute, find the matching compile unit, and fetch the compilation directory from there. This is relatively easy do to in regular DWARF, though it still requires some fairly elaborate dances if one wants to do it lazily and efficiently, etc.

However, things get a lot more complicated when split-dwarf comes into play. There the compiler will emit a separate line table into the dwo file for use by the type unit, and the compile unit will use the line table from the main file (located through DW_AT_stmt_list on the skeleton unit in the .o file). Here it is pretty much impossible to reliably connect the type unit to the relevant comp_dir. If the DWO file contains a single compilation unit, I might guess that I should look at this one, but in case of multiple compile units in a single dwo file we're out of luck.

So, this got me thinking that maybe this DW_AT_comp_dir business is not worth all the trouble it brings, and I'm now thinking of a simpler solution:

• for each type unit, parse the line tables without the DW_AT_comp_dir attribute. Cache them, and share them between type units.
• for each compile unit, parse the line tables *with* the DW_AT_comp_dir. Don't cache and don't share them (i.e., do exactly what we do now)

This means each line table will be parsed at most twice (once for its compile unit, and once for any type units that refer to it). It's not possible to share them between CUs and TUs without going through the complex matching process I described above, or without risking that the CU will get incomplete line tables if they have already been parsed via a type unit. It also means that for types in a TU we might not have complete declaration file names (in DWARF<=4), but I am not sure how many users will actually care about that (not even llvm-dwarfdump tries to do this matching). And this will still prevent the line table being parsed hundreds of times for each type unit that happens to refer to it...

I think that potentially parsing a line table (only it's file list, really) twice is worth the reduction in complexity that a full sharing would require. WDYT?

If you agree, then this patch is also not really necessary (though the llvm::Expected part is a nice refactor regardless IMO).

[clayborg]

In D62649#1523074, @labath wrote:

Actually, I've run into a bit of a snag while trying to implement the full line table sharing. The thing is, before DWARF5, the line tables are not fully independent, and require the DW_AT_comp_dir of the compile unit in order to resolve the relative paths correctly. Type units do not have the DW_AT_comp_dir attribute, and so in order to correctly parse their line tables, I'd have to check their DW_AT_stmt_list attribute, find the matching compile unit, and fetch the compilation directory from there. This is relatively easy do to in regular DWARF, though it still requires some fairly elaborate dances if one wants to do it lazily and efficiently, etc.

However, things get a lot more complicated when split-dwarf comes into play. There the compiler will emit a separate line table into the dwo file for use by the type unit, and the compile unit will use the line table from the main file (located through DW_AT_stmt_list on the skeleton unit in the .o file). Here it is pretty much impossible to reliably connect the type unit to the relevant comp_dir. If the DWO file contains a single compilation unit, I might guess that I should look at this one, but in case of multiple compile units in a single dwo file we're out of luck.

So, this got me thinking that maybe this DW_AT_comp_dir business is not worth all the trouble it brings, and I'm now thinking of a simpler solution:

• for each type unit, parse the line tables without the DW_AT_comp_dir attribute. Cache them, and share them between type units.
• for each compile unit, parse the line tables *with* the DW_AT_comp_dir. Don't cache and don't share them (i.e., do exactly what we do now)

This means each line table will be parsed at most twice (once for its compile unit, and once for any type units that refer to it). It's not possible to share them between CUs and TUs without going through the complex matching process I described above, or without risking that the CU will get incomplete line tables if they have already been parsed via a type unit. It also means that for types in a TU we might not have complete declaration file names (in DWARF<=4), but I am not sure how many users will actually care about that (not even llvm-dwarfdump tries to do this matching). And this will still prevent the line table being parsed hundreds of times for each type unit that happens to refer to it...

I think that potentially parsing a line table (only it's file list, really) twice is worth the reduction in complexity that a full sharing would require. WDYT?

If you agree, then this patch is also not really necessary (though the llvm::Expected part is a nice refactor regardless IMO).

That is my current solution in our internal LLDB fork, so yes, this works and is probably the best solution.

[labath]

Ok, abandoning this patch in that case.

include/lldb/Symbol/CompileUnit.h

protected:
   Flags m_flags;
   /// Maps UIDs to functions.
   llvm::DenseMap<lldb::user_id_t, lldb::FunctionSP> m_functions_by_uid;
   /// All modules, including the current module, imported by this
   /// compile unit.
   std::vector<SourceModule> m_imported_modules;
   /// Files associated with this compile unit's line table and
   /// declarations.
-  FileSpecList m_support_files;
+  std::shared_ptr<const FileSpecList> m_support_files_sp;
   /// Line table that will get parsed on demand.
   std::unique_ptr<LineTable> m_line_table_up;
   /// Debug macros that will get parsed on demand.
   DebugMacrosSP m_debug_macros_sp;
   /// Global and static variable list that will get parsed on demand.
   lldb::VariableListSP m_variables;
   /// eLazyBoolYes if this compile unit was compiled with
   /// optimization.
   lldb_private::LazyBool m_is_optimized;
 
 private:
   enum {
     flagsParsedAllFunctions =
         (1u << 0), ///< Have we already parsed all our functions
     flagsParsedVariables =
         (1u << 1), ///< Have we already parsed globals and statics?
-    flagsParsedSupportFiles = (1u << 2), ///< Have we already parsed the support
-                                         ///files for this compile unit?
     flagsParsedLineTable =
-        (1u << 3),                   ///< Have we parsed the line table already?
-    flagsParsedLanguage = (1u << 4), ///< Have we parsed the language already?
+        (1u << 2),                   ///< Have we parsed the line table already?
+    flagsParsedLanguage = (1u << 3), ///< Have we parsed the language already?
     flagsParsedImportedModules =
-        (1u << 5), ///< Have we parsed the imported modules already?
+        (1u << 4), ///< Have we parsed the imported modules already?
     flagsParsedDebugMacros =
-        (1u << 6) ///< Have we parsed the debug macros already?
+        (1u << 5) ///< Have we parsed the debug macros already?
   };
 
   DISALLOW_COPY_AND_ASSIGN(CompileUnit);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_CompUnit_h_

include/lldb/Symbol/SymbolFile.h

public:
   // Approach 1 - iterator
   virtual uint32_t GetNumCompileUnits() = 0;
   virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) = 0;
 
   virtual lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) = 0;
   virtual size_t ParseFunctions(CompileUnit &comp_unit) = 0;
   virtual bool ParseLineTable(CompileUnit &comp_unit) = 0;
   virtual bool ParseDebugMacros(CompileUnit &comp_unit) = 0;
-  virtual bool ParseSupportFiles(CompileUnit &comp_unit,
-                                 FileSpecList &support_files) = 0;
+
+  virtual llvm::Expected<std::shared_ptr<const FileSpecList>>
+  ParseSupportFiles(CompileUnit &comp_unit) = 0;
+
   virtual size_t ParseTypes(CompileUnit &comp_unit) = 0;
   virtual bool ParseIsOptimized(CompileUnit &comp_unit) { return false; }
 
   virtual bool
   ParseImportedModules(const SymbolContext &sc,
                        std::vector<SourceModule> &imported_modules) = 0;
   virtual size_t ParseBlocksRecursive(Function &func) = 0;
   virtual size_t ParseVariablesForContext(const SymbolContext &sc) = 0;

include/lldb/Symbol/SymbolVendor.h

public:
   virtual lldb::LanguageType ParseLanguage(CompileUnit &comp_unit);
 
   virtual size_t ParseFunctions(CompileUnit &comp_unit);
 
   virtual bool ParseLineTable(CompileUnit &comp_unit);
 
   virtual bool ParseDebugMacros(CompileUnit &comp_unit);
 
-  virtual bool ParseSupportFiles(CompileUnit &comp_unit,
-                                 FileSpecList &support_files);
+  virtual llvm::Expected<std::shared_ptr<const FileSpecList>>
+  ParseSupportFiles(CompileUnit &comp_unit);
 
   virtual bool ParseIsOptimized(CompileUnit &comp_unit);
 
   virtual size_t ParseTypes(CompileUnit &comp_unit);
 
   virtual bool
   ParseImportedModules(const SymbolContext &sc,
                        std::vector<SourceModule> &imported_modules);

source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

public:
   }
 
   size_t ParseFunctions(CompileUnit &comp_unit) override;
 
   bool ParseLineTable(CompileUnit &comp_unit) override;
 
   bool ParseDebugMacros(CompileUnit &comp_unit) override { return false; }
 
-  bool ParseSupportFiles(CompileUnit &comp_unit,
-                         FileSpecList &support_files) override;
+  llvm::Expected<std::shared_ptr<const FileSpecList>>
+  ParseSupportFiles(CompileUnit &comp_unit) override;
+
   size_t ParseTypes(CompileUnit &cu) override { return 0; }
 
   bool ParseImportedModules(
       const SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override {
     return false;
   }
 

source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

bool SymbolFileBreakpad::ParseLineTable(CompileUnit &comp_unit) {
 
   if (!data.line_table_up)
     ParseLineTableAndSupportFiles(comp_unit, data);
 
   comp_unit.SetLineTable(data.line_table_up.release());
   return true;
 }
 
-bool SymbolFileBreakpad::ParseSupportFiles(CompileUnit &comp_unit,
-                                           FileSpecList &support_files) {
+llvm::Expected<std::shared_ptr<const FileSpecList>>
+SymbolFileBreakpad::ParseSupportFiles(CompileUnit &comp_unit) {
   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
   if (!data.support_files)
     ParseLineTableAndSupportFiles(comp_unit, data);
 
-  support_files = std::move(*data.support_files);
-  return true;
+  return std::make_shared<FileSpecList>(std::move(*data.support_files));
 }
 
 uint32_t
 SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr,
                                          SymbolContextItem resolve_scope,
                                          SymbolContext &sc) {
   if (!(resolve_scope & (eSymbolContextCompUnit | eSymbolContextLineEntry)))
     return 0;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
-                         lldb_private::FileSpecList &support_files) override;
+  llvm::Expected<std::shared_ptr<const lldb_private::FileSpecList>>
+  ParseSupportFiles(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseIsOptimized(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (comp_unit.FindFunctionByUID(die.GetID()))
       continue;
     if (ParseFunction(comp_unit, die))
       ++functions_added;
   }
   // FixupTypes();
   return functions_added;
 }
 
-bool SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit,
-                                        FileSpecList &support_files) {
+llvm::Expected<std::shared_ptr<const FileSpecList>>
+SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu) {
     const DWARFBaseDIE cu_die = dwarf_cu->GetUnitDIEOnly();
 
     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(
+        auto files_sp = std::make_shared<FileSpecList>();
+        files_sp->Append(comp_unit);
+        DWARFDebugLine::ParseSupportFiles(
             comp_unit.GetModule(), m_context.getOrLoadLineData(), stmt_list,
-            support_files, dwarf_cu);
+            *files_sp, dwarf_cu);
+        return files_sp;
       }
     }
   }
-  return false;
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "No DWARF Compile unit");
 }
 
 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;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
-                         lldb_private::FileSpecList &support_files) override;
+  llvm::Expected<std::shared_ptr<const lldb_private::FileSpecList>>
+  ParseSupportFiles(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseIsOptimized(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 
 bool SymbolFileDWARFDebugMap::ParseDebugMacros(CompileUnit &comp_unit) {
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseDebugMacros(comp_unit);
   return false;
 }
 
-bool SymbolFileDWARFDebugMap::ParseSupportFiles(CompileUnit &comp_unit,
-                                                FileSpecList &support_files) {
-  SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
-  if (oso_dwarf)
-    return oso_dwarf->ParseSupportFiles(comp_unit, support_files);
-  return false;
+llvm::Expected<std::shared_ptr<const FileSpecList>>
+SymbolFileDWARFDebugMap::ParseSupportFiles(CompileUnit &comp_unit) {
+  if (SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit))
+    return oso_dwarf->ParseSupportFiles(comp_unit);
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "No OSO dwarf.");
 }
 
 bool SymbolFileDWARFDebugMap::ParseIsOptimized(CompileUnit &comp_unit) {
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseIsOptimized(comp_unit);
   return false;
 }

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
-                         FileSpecList &support_files) override;
+  llvm::Expected<std::shared_ptr<const FileSpecList>>
+  ParseSupportFiles(lldb_private::CompileUnit &comp_unit) override;
+
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;
 
   size_t ParseBlocksRecursive(Function &func) override;
 

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

bool SymbolFileNativePDB::ParseLineTable(CompileUnit &comp_unit) {
   return true;
 }
 
 bool SymbolFileNativePDB::ParseDebugMacros(CompileUnit &comp_unit) {
   // PDB doesn't contain information about macros
   return false;
 }
 
-bool SymbolFileNativePDB::ParseSupportFiles(CompileUnit &comp_unit,
-                                            FileSpecList &support_files) {
+llvm::Expected<std::shared_ptr<const FileSpecList>>
+SymbolFileNativePDB::ParseSupportFiles(CompileUnit &comp_unit) {
   PdbSymUid cu_id(comp_unit.GetID());
   lldbassert(cu_id.kind() == PdbSymUidKind::Compiland);
   CompilandIndexItem *cci =
       m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
   lldbassert(cci);
 
+  auto files_sp = std::make_shared<FileSpecList>();
   for (llvm::StringRef f : cci->m_file_list) {
     FileSpec::Style style =
         f.startswith("/") ? FileSpec::Style::posix : FileSpec::Style::windows;
     FileSpec spec(f, style);
-    support_files.Append(spec);
+    files_sp->Append(spec);
   }
 
   llvm::SmallString<64> main_source_file =
       m_index->compilands().GetMainSourceFile(*cci);
   FileSpec::Style style = main_source_file.startswith("/")
                               ? FileSpec::Style::posix
                               : FileSpec::Style::windows;
   FileSpec spec(main_source_file, style);
-  support_files.Insert(0, spec);
-  return true;
+  files_sp->Insert(0, spec);
+  return files_sp;
 }
 
 bool SymbolFileNativePDB::ParseImportedModules(
     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
   // PDB does not yet support module debug info
   return false;
 }
 

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
-                         lldb_private::FileSpecList &support_files) override;
+  llvm::Expected<std::shared_ptr<const lldb_private::FileSpecList>>
+  ParseSupportFiles(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;
 
   size_t ParseBlocksRecursive(lldb_private::Function &func) override;

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

bool SymbolFilePDB::ParseLineTable(CompileUnit &comp_unit) {
   return ParseCompileUnitLineTable(comp_unit, 0);
 }
 
 bool SymbolFilePDB::ParseDebugMacros(CompileUnit &comp_unit) {
   // PDB doesn't contain information about macros
   return false;
 }
 
-bool SymbolFilePDB::ParseSupportFiles(
-    CompileUnit &comp_unit, lldb_private::FileSpecList &support_files) {
+llvm::Expected<std::shared_ptr<const FileSpecList>>
+SymbolFilePDB::ParseSupportFiles(CompileUnit &comp_unit) {
 
   // In theory this is unnecessary work for us, because all of this information
   // is easily (and quickly) accessible from DebugInfoPDB, so caching it a
   // second time seems like a waste.  Unfortunately, there's no good way around
   // this short of a moderate refactor since SymbolVendor depends on being able
   // to cache this list.
   auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland_up)
-    return false;
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "No compiland.");
   auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
   if (!files || files->getChildCount() == 0)
-    return false;
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "No source files in compiland.");
 
+  auto files_sp = std::make_shared<FileSpecList>();
   while (auto file = files->getNext()) {
     FileSpec spec(file->getFileName(), FileSpec::Style::windows);
-    support_files.AppendIfUnique(spec);
+    files_sp->AppendIfUnique(spec);
   }
 
   // LLDB uses the DWARF-like file numeration (one based),
   // the zeroth file is the compile unit itself
-  support_files.Insert(0, comp_unit);
+  files_sp->Insert(0, comp_unit);
 
-  return true;
+  return files_sp;
 }
 
 bool SymbolFilePDB::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<SourceModule> &imported_modules) {
   // PDB does not yet support module debug info
   return false;
 }

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

public:
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
-                         lldb_private::FileSpecList &support_files) override;
+  llvm::Expected<std::shared_ptr<const lldb_private::FileSpecList>>
+  ParseSupportFiles(lldb_private::CompileUnit &comp_unit) override {
+    return std::make_shared<lldb_private::FileSpecList>();
+  }
 
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;
 
   size_t ParseBlocksRecursive(lldb_private::Function &func) override;

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

 size_t SymbolFileSymtab::ParseTypes(CompileUnit &comp_unit) { return 0; }
 
 bool SymbolFileSymtab::ParseLineTable(CompileUnit &comp_unit) { return false; }
 
 bool SymbolFileSymtab::ParseDebugMacros(CompileUnit &comp_unit) {
   return false;
 }
 
-bool SymbolFileSymtab::ParseSupportFiles(CompileUnit &comp_unit,
-                                         FileSpecList &support_files) {
-  return false;
-}
-
 bool SymbolFileSymtab::ParseImportedModules(
     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
   return false;
 }
 
 size_t SymbolFileSymtab::ParseBlocksRecursive(Function &func) { return 0; }
 
 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {

source/Symbol/CompileUnit.cpp

 using namespace lldb_private;
 
 CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
                          const char *pathname, const lldb::user_id_t cu_sym_id,
                          lldb::LanguageType language,
                          lldb_private::LazyBool is_optimized)
     : ModuleChild(module_sp), FileSpec(pathname), UserID(cu_sym_id),
       m_user_data(user_data), m_language(language), m_flags(0),
-      m_support_files(), m_line_table_up(), m_variables(),
-      m_is_optimized(is_optimized) {
+      m_line_table_up(), m_variables(), m_is_optimized(is_optimized) {
   if (language != eLanguageTypeUnknown)
     m_flags.Set(flagsParsedLanguage);
   assert(module_sp);
 }
 
 CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
                          const FileSpec &fspec, const lldb::user_id_t cu_sym_id,
                          lldb::LanguageType language,
                          lldb_private::LazyBool is_optimized)
     : ModuleChild(module_sp), FileSpec(fspec), UserID(cu_sym_id),
       m_user_data(user_data), m_language(language), m_flags(0),
-      m_support_files(), m_line_table_up(), m_variables(),
-      m_is_optimized(is_optimized) {
+      m_line_table_up(), m_variables(), m_is_optimized(is_optimized) {
   if (language != eLanguageTypeUnknown)
     m_flags.Set(flagsParsedLanguage);
   assert(module_sp);
 }
 
 CompileUnit::~CompileUnit() {}
 
 void CompileUnit::CalculateSymbolContext(SymbolContext *sc) {
if (SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor()) {
       CalculateSymbolContext(&sc);
       symbol_vendor->ParseImportedModules(sc, m_imported_modules);
     }
   }
   return m_imported_modules;
 }
 
 const FileSpecList &CompileUnit::GetSupportFiles() {
-  if (m_support_files.GetSize() == 0) {
-    if (m_flags.IsClear(flagsParsedSupportFiles)) {
-      m_flags.Set(flagsParsedSupportFiles);
-      SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor();
-      if (symbol_vendor) {
-        symbol_vendor->ParseSupportFiles(*this, m_support_files);
-      }
+  if (!m_support_files_sp) {
+    llvm::Expected<std::shared_ptr<const FileSpecList>> expected_list(
+        symbol_vendor ? symbol_vendor->ParseSupportFiles(*this)
+                      : llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                                "No symbol vendor."));
+
+    if (expected_list) {
+      assert(*expected_list);
+      m_support_files_sp = *expected_list;
+    } else {
+      GetModule()->ReportError(
+          "Parsing support files for compile unit `%s` failed: %s",
+          GetCString(), toString(expected_list.takeError()).c_str());
+      m_support_files_sp = std::make_shared<FileSpecList>();
     }
   }
-  return m_support_files;
+  return *m_support_files_sp;
 }
 
 void *CompileUnit::GetUserData() const { return m_user_data; }

source/Symbol/SymbolVendor.cpp

bool SymbolVendor::ParseDebugMacros(CompileUnit &comp_unit) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_up)
       return m_sym_file_up->ParseDebugMacros(comp_unit);
   }
   return false;
 }
-bool SymbolVendor::ParseSupportFiles(CompileUnit &comp_unit,
-                                     FileSpecList &support_files) {
+
+llvm::Expected<std::shared_ptr<const FileSpecList>>
+SymbolVendor::ParseSupportFiles(CompileUnit &comp_unit) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_up)
-      return m_sym_file_up->ParseSupportFiles(comp_unit, support_files);
+      return m_sym_file_up->ParseSupportFiles(comp_unit);
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "No symbol file.");
   }
-  return false;
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "No module file.");
 }
 
 bool SymbolVendor::ParseIsOptimized(CompileUnit &comp_unit) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_up)
       return m_sym_file_up->ParseIsOptimized(comp_unit);