[SymbolFile] Make ParseCompileUnitXXX accept a CompileUnit&.

[zturner]

Summary

Previously all of these functions accepted a SymbolContext&.
While a CompileUnit is one member of a SymbolContext, there
are also many others, and by passing such a monolithic parameter
in this way it makes the requirements and assumptions of the
API unclear for both callers as well as implementors.

All these methods need is a CompileUnit.  By limiting the
parameter type in this way, we simplify the code as well as
make it self-documenting for both implementers and users.

This patch changes the following methods:
    * ParseCompileUnitLanguage(const SymbolContext&)
    * ParseCompileUnitFunctions(const SymbolContext&)
    * ParseCompileUnitLineTable(const SymbolContext&)
    * ParseCompileUnitDebugMacros(const SymbolContext&)
    * ParseCompileUnitSupportFiles(const SymbolContext&)
    * ParseTypesForCompileUnit(const SymbolContext&)

to accept only a CompileUnit&, which is both necessary and
sufficient for them to complete their task.

Note that this is purely mechanical, so it's not necessary to review the whole patch in detail unless you really want to. The main change can be viewed in the first file.

[clayborg]

All the change to the symbol vendor make sense, but it seems like all of the call sites should be:

cu->GetLanguage();
cu->ParseFunctions();
cu->GetLineTable();
cu->ParseDebugMacros();
cu->GetSupportFiles();
cu->ParseTypes();

Some of these calls might already be there, but is seems like we should initiate these calls from the CompileUnit class.

lldb/source/Core/Module.cpp

373 ↗

(On Diff #181166)

Seems like this should almost be:

sc.comp_unit->ParseAllFunctions()

Inside the compile unit it can pass "*this" to the symbol vendor?

[zturner]

In D56564#1353514, @clayborg wrote:

All the change to the symbol vendor make sense, but it seems like all of the call sites should be:

cu->GetLanguage();
cu->ParseFunctions();
cu->GetLineTable();
cu->ParseDebugMacros();
cu->GetSupportFiles();
cu->ParseTypes();

Some of these calls might already be there, but is seems like we should initiate these calls from the CompileUnit class.

Some functions like that exist today (e.g. cu->GetLineTable(), cu->GetSupportFiles(), etc), but some don't (e.g. cu->GetFunctions() and cu->GetTypes() don't exist). I agree it would be nice to have the CompileUnit support all of these, but it might not be purely NFC, or at least it might be easy to accidentally make it *not* be NFC, because we'd be adding some member variables to the CompileUnit class for the laziness, to make the implementations match up with the implementation of the existing ones. Do you think it would be reasonable to start with this patch, which is definitely NFC, and then iterate on it to get more access to these things from the CompileUnit class directly?

[clayborg]

This is fine to start.

[labath]

looks good to me.

lldb/include/lldb/Symbol/SymbolFile.h

135 ↗

(On Diff #181166)

You're not consistent in the namespace qualification of CompileUnit. I'd suggest removing the namespace qualification, since you're already in that namespace anyway...

include/lldb/Symbol/SymbolFile.h

public:
 
   //------------------------------------------------------------------
   // Compile Unit function calls
   //------------------------------------------------------------------
   // Approach 1 - iterator
   virtual uint32_t GetNumCompileUnits() = 0;
   virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) = 0;
 
-  virtual lldb::LanguageType
-  ParseCompileUnitLanguage(const SymbolContext &sc) = 0;
-  virtual size_t ParseCompileUnitFunctions(const SymbolContext &sc) = 0;
-  virtual bool ParseCompileUnitLineTable(const SymbolContext &sc) = 0;
-  virtual bool ParseCompileUnitDebugMacros(const SymbolContext &sc) = 0;
-  virtual bool ParseCompileUnitSupportFiles(const SymbolContext &sc,
-                                            FileSpecList &support_files) = 0;
-  virtual bool
-  ParseCompileUnitIsOptimized(const lldb_private::SymbolContext &sc) {
-    return false;
-  }
+  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,
+  virtual size_t ParseTypes(CompileUnit &comp_unit) = 0;
+  virtual bool ParseIsOptimized(CompileUnit &comp_unit) { return false; }
+
   virtual bool
   ParseImportedModules(const SymbolContext &sc,
                        std::vector<ConstString> &imported_modules) = 0;
   virtual size_t ParseFunctionBlocks(const SymbolContext &sc) = 0;
-  virtual size_t ParseTypesForCompileUnit(CompileUnit &comp_unit) = 0;
   virtual size_t ParseVariablesForContext(const SymbolContext &sc) = 0;
   virtual Type *ResolveTypeUID(lldb::user_id_t type_uid) = 0;
 
 
   /// The characteristics of an array type.
   struct ArrayInfo {
     int64_t first_index;
     llvm::SmallVector<uint64_t, 1> element_orders;

include/lldb/Symbol/SymbolVendor.h

public:
   SymbolVendor(const lldb::ModuleSP &module_sp);
 
   ~SymbolVendor() override;
 
   void AddSymbolFileRepresentation(const lldb::ObjectFileSP &objfile_sp);
 
   virtual void Dump(Stream *s);
 
-  virtual lldb::LanguageType ParseCompileUnitLanguage(const SymbolContext &sc);
+  virtual lldb::LanguageType ParseLanguage(CompileUnit &comp_unit);
 
-  virtual size_t ParseCompileUnitFunctions(const SymbolContext &sc);
+  virtual size_t ParseFunctions(CompileUnit &comp_unit);
 
-  virtual bool ParseCompileUnitLineTable(const SymbolContext &sc);
+  virtual bool ParseLineTable(CompileUnit &comp_unit);
 
-  virtual bool ParseCompileUnitDebugMacros(const SymbolContext &sc);
+  virtual bool ParseDebugMacros(CompileUnit &comp_unit);
 
-  virtual bool ParseCompileUnitSupportFiles(const SymbolContext &sc,
-                                            FileSpecList &support_files);
+  virtual bool ParseSupportFiles(CompileUnit &comp_unit,
 
-  virtual bool ParseCompileUnitIsOptimized(const SymbolContext &sc);
+  virtual bool ParseIsOptimized(CompileUnit &comp_unit);
+
+  virtual size_t ParseTypes(CompileUnit &comp_unit);
 
   virtual bool ParseImportedModules(const SymbolContext &sc,
                                     std::vector<ConstString> &imported_modules);
 
   virtual size_t ParseFunctionBlocks(const SymbolContext &sc);
 
-  virtual size_t ParseTypesForCompileUnit(CompileUnit &comp_unit);
-
   virtual size_t ParseVariablesForContext(const SymbolContext &sc);
 
   virtual Type *ResolveTypeUID(lldb::user_id_t type_uid);
 
   virtual uint32_t ResolveSymbolContext(const Address &so_addr,
                                         lldb::SymbolContextItem resolve_scope,
                                         SymbolContext &sc);
 

source/Core/Module.cpp

if (num_comp_units == 0)
     return;
 
   SymbolContext sc;
   sc.module_sp = shared_from_this();
   SymbolVendor *symbols = GetSymbolVendor();
 
   for (size_t cu_idx = 0; cu_idx < num_comp_units; cu_idx++) {
     sc.comp_unit = symbols->GetCompileUnitAtIndex(cu_idx).get();
-    if (sc.comp_unit) {
-      sc.function = nullptr;
-      symbols->ParseVariablesForContext(sc);
+    if (!sc.comp_unit)
+      continue;
+
 
-      symbols->ParseCompileUnitFunctions(sc);
+    symbols->ParseFunctions(*sc.comp_unit);
 
-      sc.comp_unit->ForeachFunction([&sc, &symbols](const FunctionSP &f) {
-        sc.function = f.get();
-        symbols->ParseFunctionBlocks(sc);
-        // Parse the variables for this function and all its blocks
-        symbols->ParseVariablesForContext(sc);
-        return false;
-      });
 
-      // Parse all types for this compile unit
-      symbols->ParseTypesForCompileUnit(*sc.comp_unit);
-    }
+    symbols->ParseTypes(*sc.comp_unit);
   }
 }
 
 void Module::CalculateSymbolContext(SymbolContext *sc) {
   sc->module_sp = shared_from_this();
 }
 
 ModuleSP Module::CalculateSymbolContextModule() { return shared_from_this(); }

source/Core/SearchFilter.cpp

for (size_t i = 0; i < num_comp_units; i++) {
             return shouldContinue;
         } else {
           // First make sure this compile unit's functions are parsed
           // since CompUnit::ForeachFunction only iterates over already
           // parsed functions.
           SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
           if (!sym_vendor)
             continue;
-          SymbolContext sym_ctx;
-          cu_sp->CalculateSymbolContext(&sym_ctx);
-          if (!sym_vendor->ParseCompileUnitFunctions(sym_ctx))
+          if (!sym_vendor->ParseFunctions(*cu_sp))
             continue;
           // If we got any functions, use ForeachFunction to do the iteration.
           cu_sp->ForeachFunction([&](const FunctionSP &func_sp) {
             if (!FunctionPasses(*func_sp.get()))
               return false; // Didn't pass the filter, just keep going.
             if (searcher.GetDepth() == lldb::eSearchDepthFunction) {
               SymbolContext matchingContext(m_target_sp, module_sp, 
                                             cu_sp.get(), func_sp.get());

source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

 #include "DWARFDefines.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 
 class DWARFDIE;
 namespace lldb_private {
+class CompileUnit;
 class ExecutionContext;
 }
 class SymbolFileDWARF;
 
 class DWARFASTParser {
 public:
   virtual ~DWARFASTParser() {}
 
   virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                           const DWARFDIE &die,
                                           lldb_private::Log *log,
                                           bool *type_is_new_ptr) = 0;
 
   virtual lldb_private::Function *
-  ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
+  ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die) = 0;
 
   virtual bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) = 0;
 
   virtual lldb_private::CompilerDecl
   GetDeclForUIDFromDWARF(const DWARFDIE &die) = 0;

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 
 #include "DWARFASTParser.h"
 #include "DWARFDefines.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 
+namespace lldb_private {
+class CompileUnit;
+}
 class DWARFDebugInfoEntry;
 class DWARFDIECollection;
 class SymbolFileDWARF;
 
 class DWARFASTParserClang : public DWARFASTParser {
 public:
   DWARFASTParserClang(lldb_private::ClangASTContext &ast);
 
   ~DWARFASTParserClang() override;
 
   // DWARFASTParser interface.
   lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                   const DWARFDIE &die, lldb_private::Log *log,
                                   bool *type_is_new_ptr) override;
 
   lldb_private::Function *
-  ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
+  ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die) override;
 
   bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) override;
 
   lldb_private::CompilerDecl
   GetDeclForUIDFromDWARF(const DWARFDIE &die) override;
bool ParseChildMembers(
       std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
       std::vector<int> &member_accessibilities,
       DWARFDIECollection &member_function_dies,
       DelayedPropertyList &delayed_properties,
       lldb::AccessType &default_accessibility, bool &is_a_class,
       lldb_private::ClangASTImporter::LayoutInfo &layout_info);
 
   size_t
-  ParseChildParameters(const lldb_private::SymbolContext &sc,
+  ParseChildParameters(lldb_private::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<lldb_private::CompilerType> &function_args,
                        std::vector<clang::ParmVarDecl *> &function_param_decls,
                        unsigned &type_quals);
 

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (type_ptr == NULL) {
           break;
         case DW_TAG_volatile_type:
           encoding_data_type = Type::eEncodingIsVolatileUID;
           break;
         }
 
         if (!clang_type &&
             (encoding_data_type == Type::eEncodingIsPointerUID ||
-             encoding_data_type == Type::eEncodingIsTypedefUID) &&
-            sc.comp_unit != NULL) {
+             encoding_data_type == Type::eEncodingIsTypedefUID)) {
           if (tag == DW_TAG_pointer_type) {
             DWARFDIE target_die = die.GetReferencedDIE(DW_AT_type);
 
             if (target_die.GetAttributeValueAsUnsigned(DW_AT_APPLE_block, 0)) {
               // Blocks have a __FuncPtr inside them which is a pointer to a
               // function of the proper type.
 
               for (DWARFDIE child_die = target_die.GetFirstChild();
if (type_ptr == NULL) {
         const size_t num_attributes = die.GetAttributes(attributes);
         if (num_attributes > 0) {
           uint32_t i;
           for (i = 0; i < num_attributes; ++i) {
             attr = attributes.AttributeAtIndex(i);
             if (attributes.ExtractFormValueAtIndex(i, form_value)) {
               switch (attr) {
               case DW_AT_decl_file:
-                decl.SetFile(
-                   sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                      form_value.Unsigned()));
+                decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
                 break;
 
               case DW_AT_decl_line:
                 decl.SetLine(form_value.Unsigned());
                 break;
 
               case DW_AT_decl_column:
                 decl.SetColumn(form_value.Unsigned());

         // 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, containing_decl_ctx, die, skip_artificial,
-                               is_static, is_variadic, has_template_params,
-                               function_param_types, function_param_decls,
-                               type_quals);
+          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);
         }
 
         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
public:
   };
 
 protected:
   typedef std::vector<DWARFDIE> Stack;
   Stack m_dies;
 };
 #endif
 
-Function *DWARFASTParserClang::ParseFunctionFromDWARF(const SymbolContext &sc,
+Function *DWARFASTParserClang::ParseFunctionFromDWARF(CompileUnit &comp_unit,
                                                       const DWARFDIE &die) {
   DWARFRangeList func_ranges;
   const char *name = NULL;
   const char *mangled = NULL;
   int decl_file = 0;
   int decl_line = 0;
   int decl_column = 0;
   int call_file = 0;
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(sc, containing_decl_ctx, die, true, is_static,
-                             is_variadic, has_template_params, param_types,
-                             param_decls, type_quals);
+        ParseChildParameters(comp_unit, 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_ap;
       if (decl_file != 0 || decl_line != 0 || decl_column != 0)
         decl_ap.reset(new Declaration(
-            sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
+            comp_unit.GetSupportFiles().GetFileSpecAtIndex(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 == NULL || func_type != DIE_IS_BEING_PARSED);
 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
         const user_id_t func_user_id = die.GetID();
-        func_sp.reset(new Function(sc.comp_unit,
+        func_sp.reset(new Function(&comp_unit,
                                    func_user_id, // UserID is the DIE offset
                                    func_user_id, func_name, func_type,
                                    func_range)); // first address range
 
         if (func_sp.get() != NULL) {
           if (frame_base.IsValid())
             func_sp->GetFrameBaseExpression() = frame_base;
-          sc.comp_unit->AddFunction(func_sp);
+          comp_unit.AddFunction(func_sp);
           return func_sp.get();
         }
       }
     }
   }
   return NULL;
 }
 
default:
       break;
     }
   }
 
   return true;
 }
 
 size_t DWARFASTParserClang::ParseChildParameters(
-    const SymbolContext &sc, clang::DeclContext *containing_decl_ctx,
+    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,
     std::vector<clang::ParmVarDecl *> &function_param_decls,
     unsigned &type_quals) {
   if (!parent_die)
     return 0;
 
case DW_TAG_formal_parameter: {
         clang::StorageClass storage = clang::SC_None;
         uint32_t i;
         for (i = 0; i < num_attributes; ++i) {
           const dw_attr_t attr = attributes.AttributeAtIndex(i);
           DWARFFormValue form_value;
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             switch (attr) {
             case DW_AT_decl_file:
-              decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
+              decl.SetFile(comp_unit.GetSupportFiles().GetFileSpecAtIndex(
                   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;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   // Compile Unit function calls
   //------------------------------------------------------------------
 
   uint32_t GetNumCompileUnits() override;
 
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
   lldb::LanguageType
-  ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) override;
+  ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
-  size_t
-  ParseCompileUnitFunctions(const lldb_private::SymbolContext &sc) override;
+  size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
-  bool
-  ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc) override;
+  bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
-  bool
-  ParseCompileUnitDebugMacros(const lldb_private::SymbolContext &sc) override;
+  bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseCompileUnitSupportFiles(
-      const lldb_private::SymbolContext &sc,
+  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
                          lldb_private::FileSpecList &support_files) override;
 
-  bool
-  ParseCompileUnitIsOptimized(const lldb_private::SymbolContext &sc) 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::ConstString> &imported_modules) override;
 
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc) override;
 
   size_t
-  ParseTypesForCompileUnit(lldb_private::CompileUnit &comp_unit) override;
-
-  size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,
       const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
protected:
 
   virtual DWARFUnit *
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
 
   DWARFUnit *GetNextUnparsedDWARFCompileUnit(DWARFUnit *prev_cu);
 
   bool GetFunction(const DWARFDIE &die, lldb_private::SymbolContext &sc);
 
-  lldb_private::Function *
-  ParseCompileUnitFunction(const lldb_private::SymbolContext &sc,
+  lldb_private::Function *ParseFunction(lldb_private::CompileUnit &comp_unit,
                                         const DWARFDIE &die);
 
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc,
                              lldb_private::Block *parent_block,
                              const DWARFDIE &die,
                              lldb::addr_t subprogram_low_pc, uint32_t depth);
 
   size_t ParseTypes(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
                     bool parse_siblings, bool parse_children);

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) {
   if (info) {
     DWARFUnit *dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
     if (dwarf_cu)
       cu_sp = ParseCompileUnit(dwarf_cu, cu_idx);
   }
   return cu_sp;
 }
 
-Function *SymbolFileDWARF::ParseCompileUnitFunction(const SymbolContext &sc,
-                                                    const DWARFDIE &die) {
+Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
   ASSERT_MODULE_LOCK(this);
   if (die.IsValid()) {
     TypeSystem *type_system =
         GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
 
     if (type_system) {
       DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
       if (dwarf_ast)
-        return dwarf_ast->ParseFunctionFromDWARF(sc, die);
+        return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die);
     }
   }
   return nullptr;
 }
 
 bool SymbolFileDWARF::FixupAddress(Address &addr) {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile) {
     return debug_map_symfile->LinkOSOAddress(addr);
   }
   // This is a normal DWARF file, no address fixups need to happen
   return true;
 }
-lldb::LanguageType
-SymbolFileDWARF::ParseCompileUnitLanguage(const SymbolContext &sc) {
+lldb::LanguageType SymbolFileDWARF::ParseLanguage(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
-  assert(sc.comp_unit);
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetLanguageType();
   else
     return eLanguageTypeUnknown;
 }
 
-size_t SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) {
+size_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
-  assert(sc.comp_unit);
   size_t functions_added = 0;
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu) {
     DWARFDIECollection function_dies;
     const size_t num_functions =
         dwarf_cu->AppendDIEsWithTag(DW_TAG_subprogram, function_dies);
     size_t func_idx;
     for (func_idx = 0; func_idx < num_functions; ++func_idx) {
       DWARFDIE die = function_dies.GetDIEAtIndex(func_idx);
-      if (sc.comp_unit->FindFunctionByUID(die.GetID()).get() == NULL) {
-        if (ParseCompileUnitFunction(sc, die))
+      if (comp_unit.FindFunctionByUID(die.GetID()).get() == NULL) {
+        if (ParseFunction(comp_unit, die))
           ++functions_added;
       }
     }
     // FixupTypes();
   }
   return functions_added;
 }
 
-bool SymbolFileDWARF::ParseCompileUnitSupportFiles(
-    const SymbolContext &sc, FileSpecList &support_files) {
+bool SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit,
+                                        FileSpecList &support_files) {
   ASSERT_MODULE_LOCK(this);
-  assert(sc.comp_unit);
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu) {
     const DWARFBaseDIE cu_die = dwarf_cu->GetUnitDIEOnly();
 
     if (cu_die) {
       FileSpec cu_comp_dir = resolveCompDir(
           cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
       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(*sc.comp_unit);
+        support_files.Append(comp_unit);
         return DWARFDebugLine::ParseSupportFiles(
-            sc.comp_unit->GetModule(), get_debug_line_data(), cu_comp_dir,
+            comp_unit.GetModule(), get_debug_line_data(), cu_comp_dir,
             stmt_list, support_files, dwarf_cu);
       }
     }
   }
   return false;
 }
 
-bool SymbolFileDWARF::ParseCompileUnitIsOptimized(
-    const lldb_private::SymbolContext &sc) {
+bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetIsOptimized();
   return false;
 }
 
 bool SymbolFileDWARF::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<lldb_private::ConstString> &imported_modules) {
if (state.end_sequence) {
       // First, put the current sequence into the line table.
       line_table->InsertSequence(info->sequence_ap.get());
       // Then, empty it to prepare for the next sequence.
       info->sequence_ap->Clear();
     }
   }
 }
 
-bool SymbolFileDWARF::ParseCompileUnitLineTable(const SymbolContext &sc) {
+bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
-  assert(sc.comp_unit);
-  if (sc.comp_unit->GetLineTable() != NULL)
+  if (comp_unit.GetLineTable() != NULL)
     return true;
 
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu) {
     const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
     if (dwarf_cu_die) {
       const dw_offset_t cu_line_offset =
           dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list,
                                                    DW_INVALID_OFFSET);
       if (cu_line_offset != DW_INVALID_OFFSET) {
-        std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit));
+        std::unique_ptr<LineTable> line_table_ap(new LineTable(&comp_unit));
         if (line_table_ap.get()) {
           ParseDWARFLineTableCallbackInfo info;
           info.line_table = line_table_ap.get();
 
           /*
            * MIPS:
            * The SymbolContext may not have a valid target, thus we may not be
            * able
if (dwarf_cu_die) {
                                               ParseDWARFLineTableCallback,
                                               &info, dwarf_cu);
           SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
           if (debug_map_symfile) {
             // We have an object file that has a line table with addresses that
             // are not linked. We need to link the line table and convert the
             // addresses that are relative to the .o file into addresses for
             // the main executable.
-            sc.comp_unit->SetLineTable(
+            comp_unit.SetLineTable(
                 debug_map_symfile->LinkOSOLineTable(this, line_table_ap.get()));
           } else {
-            sc.comp_unit->SetLineTable(line_table_ap.release());
+            comp_unit.SetLineTable(line_table_ap.release());
             return true;
           }
         }
       }
     }
   }
   return false;
 }
const DWARFDebugMacroHeader &header =
       DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset);
   DWARFDebugMacroEntry::ReadMacroEntries(debug_macro_data, get_debug_str_data(),
                                          header.OffsetIs64Bit(), offset, this,
                                          debug_macros_sp);
 
   return debug_macros_sp;
 }
 
-bool SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
+bool SymbolFileDWARF::ParseDebugMacros(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
-  assert(sc.comp_unit);
 
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu == nullptr)
     return false;
 
   const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
   if (!dwarf_cu_die)
     return false;
 
   lldb::offset_t sect_offset =
       dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET);
   if (sect_offset == DW_INVALID_OFFSET)
     sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros,
                                                            DW_INVALID_OFFSET);
   if (sect_offset == DW_INVALID_OFFSET)
     return false;
 
-  sc.comp_unit->SetDebugMacros(ParseDebugMacros(&sect_offset));
+  comp_unit.SetDebugMacros(ParseDebugMacros(&sect_offset));
 
   return true;
 }
 
 size_t SymbolFileDWARF::ParseFunctionBlocks(const SymbolContext &sc,
                                             Block *parent_block,
                                             const DWARFDIE &orig_die,
                                             addr_t subprogram_low_pc,
bool SymbolFileDWARF::GetFunction(const DWARFDIE &die, SymbolContext &sc) {
   sc.Clear(false);
 
   if (die) {
     // Check if the symbol vendor already knows about this compile unit?
     sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX);
 
     sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
     if (sc.function == NULL)
-      sc.function = ParseCompileUnitFunction(sc, die);
+      sc.function = ParseFunction(*sc.comp_unit, die);
 
     if (sc.function) {
       sc.module_sp = sc.function->CalculateSymbolContextModule();
       return true;
     }
   }
 
   return false;
if (debug_info) {
             if (resolve_scope &
                 (eSymbolContextFunction | eSymbolContextBlock)) {
               DWARFDIE function_die = dwarf_cu->LookupAddress(file_vm_addr);
               DWARFDIE block_die;
               if (function_die) {
                 sc.function =
                     sc.comp_unit->FindFunctionByUID(function_die.GetID()).get();
                 if (sc.function == NULL)
-                  sc.function = ParseCompileUnitFunction(sc, function_die);
+                  sc.function = ParseFunction(*sc.comp_unit, function_die);
 
                 if (sc.function && (resolve_scope & eSymbolContextBlock))
                   block_die = function_die.LookupDeepestBlock(file_vm_addr);
               } else {
                 // We might have had a compile unit that had discontiguous
                 // address ranges where the gaps are symbols that don't have
                 // any debug info. Discontiguous compile unit address ranges
                 // should only happen when there aren't other functions from
if (debug_info) {
                         DWARFDIE block_die;
                         if (function_die) {
                           sc.function =
                               sc.comp_unit
                                   ->FindFunctionByUID(function_die.GetID())
                                   .get();
                           if (sc.function == NULL)
                             sc.function =
-                                ParseCompileUnitFunction(sc, function_die);
+                                ParseFunction(*sc.comp_unit, function_die);
 
                           if (sc.function &&
                               (resolve_scope & eSymbolContextBlock))
                             block_die =
                                 function_die.LookupDeepestBlock(file_vm_addr);
                         }
 
                         if (sc.function != NULL) {
if (function_die) {
       ParseFunctionBlocks(sc, &sc.function->GetBlock(false), function_die,
                           LLDB_INVALID_ADDRESS, 0);
     }
   }
 
   return functions_added;
 }
 
-size_t SymbolFileDWARF::ParseTypesForCompileUnit(CompileUnit &comp_unit) {
+size_t SymbolFileDWARF::ParseTypes(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
   size_t types_added = 0;
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu) {
     DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
     if (dwarf_cu_die && dwarf_cu_die.HasChildren()) {
       SymbolContext sc;
       sc.comp_unit = &comp_unit;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
 
   //------------------------------------------------------------------
   // Compile Unit function calls
   //------------------------------------------------------------------
   uint32_t GetNumCompileUnits() override;
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
   lldb::LanguageType
-  ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) override;
-  size_t
-  ParseCompileUnitFunctions(const lldb_private::SymbolContext &sc) override;
-  bool
-  ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc) override;
-  bool
-  ParseCompileUnitDebugMacros(const lldb_private::SymbolContext &sc) override;
-  bool ParseCompileUnitSupportFiles(
-      const lldb_private::SymbolContext &sc,
+  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;
-  bool
-  ParseCompileUnitIsOptimized(const lldb_private::SymbolContext &sc) 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::ConstString> &imported_modules) override;
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc) override;
   size_t
-  ParseTypesForCompileUnit(lldb_private::CompileUnit &comp_unit) override;
-  size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,
       const lldb_private::ExecutionContext *exe_ctx) override;
 
   lldb_private::CompilerDeclContext
static uint32_t GetOSOIndexFromUserID(lldb::user_id_t uid) {
     return (uint32_t)((uid >> 32ull) - 1ull);
   }
 
   static SymbolFileDWARF *GetSymbolFileAsSymbolFileDWARF(SymbolFile *sym_file);
 
   bool GetFileSpecForSO(uint32_t oso_idx, lldb_private::FileSpec &file_spec);
 
   CompileUnitInfo *GetCompUnitInfo(const lldb_private::SymbolContext &sc);
+  CompileUnitInfo *GetCompUnitInfo(const lldb_private::CompileUnit &comp_unit);
 
   size_t GetCompUnitInfosForModule(const lldb_private::Module *oso_module,
                                    std::vector<CompileUnitInfo *> &cu_infos);
 
   lldb_private::Module *
   GetModuleByCompUnitInfo(CompileUnitInfo *comp_unit_info);
 
   lldb_private::Module *GetModuleByOSOIndex(uint32_t oso_idx);
 
   lldb_private::ObjectFile *
   GetObjectFileByCompUnitInfo(CompileUnitInfo *comp_unit_info);
 
   lldb_private::ObjectFile *GetObjectFileByOSOIndex(uint32_t oso_idx);
 
   uint32_t GetCompUnitInfoIndex(const CompileUnitInfo *comp_unit_info);
 
   SymbolFileDWARF *GetSymbolFile(const lldb_private::SymbolContext &sc);
+  SymbolFileDWARF *GetSymbolFile(const lldb_private::CompileUnit &comp_unit);
 
   SymbolFileDWARF *GetSymbolFileByCompUnitInfo(CompileUnitInfo *comp_unit_info);
 
   SymbolFileDWARF *GetSymbolFileByOSOIndex(uint32_t oso_idx);
 
   // If closure returns "false", iteration continues.  If it returns
   // "true", iteration terminates.
   void ForEachSymbolFile(std::function<bool(SymbolFileDWARF *)> closure) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

ObjectFile *SymbolFileDWARFDebugMap::GetObjectFileByOSOIndex(uint32_t oso_idx) {
   Module *oso_module = GetModuleByOSOIndex(oso_idx);
   if (oso_module)
     return oso_module->GetObjectFile();
   return NULL;
 }
 
 SymbolFileDWARF *
 SymbolFileDWARFDebugMap::GetSymbolFile(const SymbolContext &sc) {
-  CompileUnitInfo *comp_unit_info = GetCompUnitInfo(sc);
+  return GetSymbolFile(*sc.comp_unit);
+}
+
+SymbolFileDWARF *
+SymbolFileDWARFDebugMap::GetSymbolFile(const CompileUnit &comp_unit) {
+  CompileUnitInfo *comp_unit_info = GetCompUnitInfo(comp_unit);
   if (comp_unit_info)
     return GetSymbolFileByCompUnitInfo(comp_unit_info);
   return NULL;
 }
 
 ObjectFile *SymbolFileDWARFDebugMap::GetObjectFileByCompUnitInfo(
     CompileUnitInfo *comp_unit_info) {
   Module *oso_module = GetModuleByCompUnitInfo(comp_unit_info);
if (cu_idx < cu_count) {
     comp_unit_sp = m_compile_unit_infos[cu_idx].compile_unit_sp;
   }
 
   return comp_unit_sp;
 }
 
 SymbolFileDWARFDebugMap::CompileUnitInfo *
 SymbolFileDWARFDebugMap::GetCompUnitInfo(const SymbolContext &sc) {
+  return GetCompUnitInfo(*sc.comp_unit);
+}
+
+SymbolFileDWARFDebugMap::CompileUnitInfo *
+SymbolFileDWARFDebugMap::GetCompUnitInfo(const CompileUnit &comp_unit) {
   const uint32_t cu_count = GetNumCompileUnits();
   for (uint32_t i = 0; i < cu_count; ++i) {
-    if (sc.comp_unit == m_compile_unit_infos[i].compile_unit_sp.get())
+    if (comp_unit == m_compile_unit_infos[i].compile_unit_sp.get())
       return &m_compile_unit_infos[i];
   }
   return NULL;
 }
 
 size_t SymbolFileDWARFDebugMap::GetCompUnitInfosForModule(
     const lldb_private::Module *module,
     std::vector<CompileUnitInfo *> &cu_infos) {
   const uint32_t cu_count = GetNumCompileUnits();
   for (uint32_t i = 0; i < cu_count; ++i) {
     if (module == GetModuleByCompUnitInfo(&m_compile_unit_infos[i]))
       cu_infos.push_back(&m_compile_unit_infos[i]);
   }
   return cu_infos.size();
 }
 
 lldb::LanguageType
-SymbolFileDWARFDebugMap::ParseCompileUnitLanguage(const SymbolContext &sc) {
-  SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
+SymbolFileDWARFDebugMap::ParseLanguage(CompileUnit &comp_unit) {
+  SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
-    return oso_dwarf->ParseCompileUnitLanguage(sc);
+    return oso_dwarf->ParseLanguage(comp_unit);
   return eLanguageTypeUnknown;
 }
 
-size_t
-SymbolFileDWARFDebugMap::ParseCompileUnitFunctions(const SymbolContext &sc) {
-  SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
+size_t SymbolFileDWARFDebugMap::ParseFunctions(CompileUnit &comp_unit) {
+  SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
-    return oso_dwarf->ParseCompileUnitFunctions(sc);
+    return oso_dwarf->ParseFunctions(comp_unit);
   return 0;
 }
 
-bool SymbolFileDWARFDebugMap::ParseCompileUnitLineTable(
-    const SymbolContext &sc) {
-  SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
+bool SymbolFileDWARFDebugMap::ParseLineTable(CompileUnit &comp_unit) {
+  SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
-    return oso_dwarf->ParseCompileUnitLineTable(sc);
+    return oso_dwarf->ParseLineTable(comp_unit);
   return false;
 }
 
-bool SymbolFileDWARFDebugMap::ParseCompileUnitDebugMacros(
-    const SymbolContext &sc) {
-  SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
+bool SymbolFileDWARFDebugMap::ParseDebugMacros(CompileUnit &comp_unit) {
+  SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
-    return oso_dwarf->ParseCompileUnitDebugMacros(sc);
+    return oso_dwarf->ParseDebugMacros(comp_unit);
   return false;
 }
 
-bool SymbolFileDWARFDebugMap::ParseCompileUnitSupportFiles(
-    const SymbolContext &sc, FileSpecList &support_files) {
-  SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
+bool SymbolFileDWARFDebugMap::ParseSupportFiles(CompileUnit &comp_unit,
+                                                FileSpecList &support_files) {
+  SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
-    return oso_dwarf->ParseCompileUnitSupportFiles(sc, support_files);
+    return oso_dwarf->ParseSupportFiles(comp_unit, support_files);
   return false;
 }
 
-bool SymbolFileDWARFDebugMap::ParseCompileUnitIsOptimized(
-    const lldb_private::SymbolContext &sc) {
-  SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
+bool SymbolFileDWARFDebugMap::ParseIsOptimized(CompileUnit &comp_unit) {
+  SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
-    return oso_dwarf->ParseCompileUnitIsOptimized(sc);
+    return oso_dwarf->ParseIsOptimized(comp_unit);
   return false;
 }
 
 bool SymbolFileDWARFDebugMap::ParseImportedModules(
     const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
   if (oso_dwarf)
     return oso_dwarf->ParseImportedModules(sc, imported_modules);
   return false;
 }
 
 size_t SymbolFileDWARFDebugMap::ParseFunctionBlocks(const SymbolContext &sc) {
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
   if (oso_dwarf)
     return oso_dwarf->ParseFunctionBlocks(sc);
   return 0;
 }
 
-size_t
-SymbolFileDWARFDebugMap::ParseTypesForCompileUnit(CompileUnit &comp_unit) {
-  SymbolContext sc;
-  sc.comp_unit = &comp_unit;
-  SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
+size_t SymbolFileDWARFDebugMap::ParseTypes(CompileUnit &comp_unit) {
+  SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
-    return oso_dwarf->ParseTypesForCompileUnit(comp_unit);
+    return oso_dwarf->ParseTypes(comp_unit);
   return 0;
 }
 
 size_t
 SymbolFileDWARFDebugMap::ParseVariablesForContext(const SymbolContext &sc) {
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
   if (oso_dwarf)
     return oso_dwarf->ParseVariablesForContext(sc);

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
 
   uint32_t GetNumCompileUnits() override;
 
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
-  lldb::LanguageType ParseCompileUnitLanguage(const SymbolContext &sc) override;
+  lldb::LanguageType
+  ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
-  size_t ParseCompileUnitFunctions(const SymbolContext &sc) override;
+  size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseCompileUnitLineTable(const SymbolContext &sc) override;
+  bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseCompileUnitDebugMacros(const SymbolContext &sc) override;
+  bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseCompileUnitSupportFiles(const SymbolContext &sc,
-                                    FileSpecList &support_files) override;
+  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
+  size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool
   ParseImportedModules(const SymbolContext &sc,
                        std::vector<ConstString> &imported_modules) override;
 
   size_t ParseFunctionBlocks(const SymbolContext &sc) override;
 
   uint32_t FindGlobalVariables(const ConstString &name,
                                const CompilerDeclContext *parent_decl_ctx,
                                uint32_t max_matches,
                                VariableList &variables) override;
 
-  size_t
-  ParseTypesForCompileUnit(lldb_private::CompileUnit &comp_unit) override;
   size_t ParseVariablesForContext(const SymbolContext &sc) override;
 
   void AddSymbols(Symtab &symtab) override;
 
   CompilerDecl GetDeclForUID(lldb::user_id_t uid) override;
   CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) override;
   CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid) override;
   Type *ResolveTypeUID(lldb::user_id_t type_uid) override;

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

lldb::CompUnitSP SymbolFileNativePDB::ParseCompileUnitAtIndex(uint32_t index) {
   if (index >= UINT16_MAX)
     return nullptr;
 
   CompilandIndexItem &item = m_index->compilands().GetOrCreateCompiland(index);
 
   return GetOrCreateCompileUnit(item);
 }
 
-lldb::LanguageType
-SymbolFileNativePDB::ParseCompileUnitLanguage(const SymbolContext &sc) {
-  // What fields should I expect to be filled out on the SymbolContext?  Is it
-  // safe to assume that `sc.comp_unit` is valid?
-  if (!sc.comp_unit)
-    return lldb::eLanguageTypeUnknown;
-  PdbSymUid uid(sc.comp_unit->GetID());
+lldb::LanguageType SymbolFileNativePDB::ParseLanguage(CompileUnit &comp_unit) {
+  PdbSymUid uid(comp_unit.GetID());
   lldbassert(uid.kind() == PdbSymUidKind::Compiland);
 
   CompilandIndexItem *item =
       m_index->compilands().GetCompiland(uid.asCompiland().modi);
   lldbassert(item);
   if (!item->m_compile_opts)
     return lldb::eLanguageTypeUnknown;
 
   return TranslateLanguage(item->m_compile_opts->getLanguage());
 }
 
 void SymbolFileNativePDB::AddSymbols(Symtab &symtab) { return; }
 
-size_t SymbolFileNativePDB::ParseCompileUnitFunctions(const SymbolContext &sc) {
-  lldbassert(sc.comp_unit);
-
-  PdbSymUid uid{sc.comp_unit->GetID()};
+size_t SymbolFileNativePDB::ParseFunctions(CompileUnit &comp_unit) {
+  PdbSymUid uid{comp_unit.GetID()};
   lldbassert(uid.kind() == PdbSymUidKind::Compiland);
   uint16_t modi = uid.asCompiland().modi;
   CompilandIndexItem &cii = m_index->compilands().GetOrCreateCompiland(modi);
 
-  size_t count = sc.comp_unit->GetNumFunctions();
+  size_t count = comp_unit.GetNumFunctions();
   const CVSymbolArray &syms = cii.m_debug_stream.getSymbolArray();
   for (auto iter = syms.begin(); iter != syms.end(); ++iter) {
     if (iter->kind() != S_LPROC32 && iter->kind() != S_GPROC32)
       continue;
 
     PdbCompilandSymId sym_id{modi, iter.offset()};
 
-    FunctionSP func = GetOrCreateFunction(sym_id, *sc.comp_unit);
+    FunctionSP func = GetOrCreateFunction(sym_id, comp_unit);
   }
 
-  size_t new_count = sc.comp_unit->GetNumFunctions();
+  size_t new_count = comp_unit.GetNumFunctions();
   lldbassert(new_count >= count);
   return new_count - count;
 }
 
 static bool NeedsResolvedCompileUnit(uint32_t resolve_scope) {
   // If any of these flags are set, we need to resolve the compile unit.
   uint32_t flags = eSymbolContextCompUnit;
   flags |= eSymbolContextVariable;
static void TerminateLineSequence(LineTable &table,
                                   std::unique_ptr<LineSequence> seq) {
   // The end is always a terminal entry, so insert it regardless.
   table.AppendLineEntryToSequence(seq.get(), base_addr + block.CodeSize,
                                   last_line, 0, file_number, false, false,
                                   false, false, true);
   table.InsertSequence(seq.release());
 }
 
-bool SymbolFileNativePDB::ParseCompileUnitLineTable(const SymbolContext &sc) {
+bool SymbolFileNativePDB::ParseLineTable(CompileUnit &comp_unit) {
   // Unfortunately LLDB is set up to parse the entire compile unit line table
   // all at once, even if all it really needs is line info for a specific
   // function.  In the future it would be nice if it could set the sc.m_function
   // member, and we could only get the line info for the function in question.
-  lldbassert(sc.comp_unit);
-  PdbSymUid cu_id(sc.comp_unit->GetID());
+  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 line_table = llvm::make_unique<LineTable>(sc.comp_unit);
+  auto line_table = llvm::make_unique<LineTable>(&comp_unit);
 
   // This is basically a copy of the .debug$S subsections from all original COFF
   // object files merged together with address relocations applied.  We are
   // looking for all DEBUG_S_LINES subsections.
   for (const DebugSubsectionRecord &dssr :
        cci->m_debug_stream.getSubsectionsArray()) {
     if (dssr.kind() != DebugSubsectionKind::Lines)
       continue;
for (const LineColumnEntry &group : lines) {
       TerminateLineSequence(*line_table, *lfh, virtual_addr, file_index,
                             last_line.getEndLine(), std::move(sequence));
     }
   }
 
   if (line_table->GetSize() == 0)
     return false;
 
-  sc.comp_unit->SetLineTable(line_table.release());
+  comp_unit.SetLineTable(line_table.release());
   return true;
 }
 
-bool SymbolFileNativePDB::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
+bool SymbolFileNativePDB::ParseDebugMacros(CompileUnit &comp_unit) {
   // PDB doesn't contain information about macros
   return false;
 }
 
-bool SymbolFileNativePDB::ParseCompileUnitSupportFiles(
-    const SymbolContext &sc, FileSpecList &support_files) {
-  lldbassert(sc.comp_unit);
-
-  PdbSymUid cu_id(sc.comp_unit->GetID());
+bool SymbolFileNativePDB::ParseSupportFiles(CompileUnit &comp_unit,
+                                            FileSpecList &support_files) {
+  PdbSymUid cu_id(comp_unit.GetID());
   lldbassert(cu_id.kind() == PdbSymUidKind::Compiland);
   CompilandIndexItem *cci =
       m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
   lldbassert(cci);
 
   for (llvm::StringRef f : cci->m_file_list) {
     FileSpec::Style style =
         f.startswith("/") ? FileSpec::Style::posix : FileSpec::Style::windows;
if (!type)
       continue;
 
     types.Insert(type);
     ++match_count;
   }
   return match_count;
 }
 
-size_t SymbolFileNativePDB::ParseTypesForCompileUnit(CompileUnit &comp_unit) {
+size_t SymbolFileNativePDB::ParseTypes(CompileUnit &comp_unit) {
   // Only do the full type scan the first time.
   if (m_done_full_type_scan)
     return 0;
 
   size_t old_count = m_obj_file->GetModule()->GetTypeList()->GetSize();
   LazyRandomTypeCollection &types = m_index->tpi().typeCollection();
 
   // First process the entire TPI stream.

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
   // Compile Unit function calls
   //------------------------------------------------------------------
 
   uint32_t GetNumCompileUnits() override;
 
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
   lldb::LanguageType
-  ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) override;
+  ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
-  size_t
-  ParseCompileUnitFunctions(const lldb_private::SymbolContext &sc) override;
+  size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
-  bool
-  ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc) override;
+  bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
-  bool
-  ParseCompileUnitDebugMacros(const lldb_private::SymbolContext &sc) override;
+  bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseCompileUnitSupportFiles(
-      const lldb_private::SymbolContext &sc,
+  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
                          lldb_private::FileSpecList &support_files) override;
 
+  size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
+
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::ConstString> &imported_modules) override;
 
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc) override;
 
   size_t
-  ParseTypesForCompileUnit(lldb_private::CompileUnit &comp_unit) override;
-
-  size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,
       const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
struct SecContribInfo {
     uint32_t Size;
     uint32_t CompilandId;
   };
   using SecContribsMap = std::map<uint32_t, std::vector<SecContribInfo>>;
 
   lldb::CompUnitSP ParseCompileUnitForUID(uint32_t id,
                                           uint32_t index = UINT32_MAX);
 
-  bool ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc,
+  bool ParseCompileUnitLineTable(lldb_private::CompileUnit &comp_unit,
                                  uint32_t match_line);
 
   void BuildSupportFileIdToSupportFileIndexMap(
       const llvm::pdb::PDBSymbolCompiland &pdb_compiland,
       llvm::DenseMap<uint32_t, uint32_t> &index_map) const;
 
   void FindTypesByName(llvm::StringRef name,
                        const lldb_private::CompilerDeclContext *parent_decl_ctx,
private:
   typedef std::vector<lldb_private::Type *> TypeCollection;
 
   void GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
                             uint32_t type_mask,
                             TypeCollection &type_collection);
 
   lldb_private::Function *
   ParseCompileUnitFunctionForPDBFunc(const llvm::pdb::PDBSymbolFunc &pdb_func,
-                                     const lldb_private::SymbolContext &sc);
+                                     lldb_private::CompileUnit &comp_unit);
 
   void GetCompileUnitIndex(const llvm::pdb::PDBSymbolCompiland &pdb_compiland,
                            uint32_t &index);
 
   PDBASTParser *GetPDBAstParser();
 
   std::unique_ptr<llvm::pdb::PDBSymbolCompiland>
   GetPDBCompilandByUID(uint32_t uid);

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitAtIndex(uint32_t index) {
   if (!results)
     return CompUnitSP();
   auto compiland_up = results->getChildAtIndex(index);
   if (!compiland_up)
     return CompUnitSP();
   return ParseCompileUnitForUID(compiland_up->getSymIndexId(), index);
 }
 
-lldb::LanguageType
-SymbolFilePDB::ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) {
-  // What fields should I expect to be filled out on the SymbolContext?  Is it
-  // safe to assume that `sc.comp_unit` is valid?
-  if (!sc.comp_unit)
-    return lldb::eLanguageTypeUnknown;
-
-  auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
+lldb::LanguageType SymbolFilePDB::ParseLanguage(CompileUnit &comp_unit) {
+  auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland_up)
     return lldb::eLanguageTypeUnknown;
   auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
   if (!details)
     return lldb::eLanguageTypeUnknown;
   return TranslateLanguage(details->getLanguage());
 }
 
-lldb_private::Function *SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(
-    const PDBSymbolFunc &pdb_func, const lldb_private::SymbolContext &sc) {
-  lldbassert(sc.comp_unit && sc.module_sp.get());
-
-  if (FunctionSP result =
-          sc.comp_unit->FindFunctionByUID(pdb_func.getSymIndexId()))
+lldb_private::Function *
+SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
+                                                  CompileUnit &comp_unit) {
+  if (FunctionSP result = comp_unit.FindFunctionByUID(pdb_func.getSymIndexId()))
     return result.get();
 
   auto file_vm_addr = pdb_func.getVirtualAddress();
   if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
     return nullptr;
 
   auto func_length = pdb_func.getLength();
   AddressRange func_range =
-      AddressRange(file_vm_addr, func_length, sc.module_sp->GetSectionList());
+      AddressRange(file_vm_addr, func_length,
+                   GetObjectFile()->GetModule()->GetSectionList());
   if (!func_range.GetBaseAddress().IsValid())
     return nullptr;
 
   lldb_private::Type *func_type = ResolveTypeUID(pdb_func.getSymIndexId());
   if (!func_type)
     return nullptr;
 
   user_id_t func_type_uid = pdb_func.getSignatureId();
 
   Mangled mangled = GetMangledForPDBFunc(pdb_func);
 
   FunctionSP func_sp =
-      std::make_shared<Function>(sc.comp_unit, pdb_func.getSymIndexId(),
+      std::make_shared<Function>(&comp_unit, pdb_func.getSymIndexId(),
                                  func_type_uid, mangled, func_type, func_range);
 
-  sc.comp_unit->AddFunction(func_sp);
+  comp_unit.AddFunction(func_sp);
 
   TypeSystem *type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (!type_system)
     return nullptr;
   ClangASTContext *clang_type_system =
     llvm::dyn_cast_or_null<ClangASTContext>(type_system);
   if (!clang_type_system)
     return nullptr;
   clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func);
 
   return func_sp.get();
 }
 
-size_t SymbolFilePDB::ParseCompileUnitFunctions(
-    const lldb_private::SymbolContext &sc) {
-  lldbassert(sc.comp_unit);
+size_t SymbolFilePDB::ParseFunctions(CompileUnit &comp_unit) {
   size_t func_added = 0;
-  auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
+  auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland_up)
     return 0;
   auto results_up = compiland_up->findAllChildren<PDBSymbolFunc>();
   if (!results_up)
     return 0;
   while (auto pdb_func_up = results_up->getNext()) {
-    auto func_sp =
-        sc.comp_unit->FindFunctionByUID(pdb_func_up->getSymIndexId());
+    auto func_sp = comp_unit.FindFunctionByUID(pdb_func_up->getSymIndexId());
     if (!func_sp) {
-      if (ParseCompileUnitFunctionForPDBFunc(*pdb_func_up, sc))
+      if (ParseCompileUnitFunctionForPDBFunc(*pdb_func_up, comp_unit))
         ++func_added;
     }
   }
   return func_added;
 }
 
-bool SymbolFilePDB::ParseCompileUnitLineTable(
-    const lldb_private::SymbolContext &sc) {
-  lldbassert(sc.comp_unit);
-  if (sc.comp_unit->GetLineTable())
+bool SymbolFilePDB::ParseLineTable(CompileUnit &comp_unit) {
+  if (comp_unit.GetLineTable())
     return true;
-  return ParseCompileUnitLineTable(sc, 0);
+  return ParseCompileUnitLineTable(comp_unit, 0);
 }
 
-bool SymbolFilePDB::ParseCompileUnitDebugMacros(
-    const lldb_private::SymbolContext &sc) {
+bool SymbolFilePDB::ParseDebugMacros(CompileUnit &comp_unit) {
   // PDB doesn't contain information about macros
   return false;
 }
 
-bool SymbolFilePDB::ParseCompileUnitSupportFiles(
-    const lldb_private::SymbolContext &sc,
-    lldb_private::FileSpecList &support_files) {
-  lldbassert(sc.comp_unit);
+bool SymbolFilePDB::ParseSupportFiles(
+    CompileUnit &comp_unit, lldb_private::FileSpecList &support_files) {
 
   // 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(sc.comp_unit->GetID());
+  auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland_up)
     return false;
   auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
   if (!files || files->getChildCount() == 0)
     return false;
 
   while (auto file = files->getNext()) {
     FileSpec spec(file->getFileName(), FileSpec::Style::windows);
     support_files.AppendIfUnique(spec);
   }
 
   // LLDB uses the DWARF-like file numeration (one based),
   // the zeroth file is the compile unit itself
-  support_files.Insert(0, *sc.comp_unit);
+  support_files.Insert(0, comp_unit);
 
   return true;
 }
 
 bool SymbolFilePDB::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<lldb_private::ConstString> &imported_modules) {
   // PDB does not yet support module debug info
if (!pdb_func_up)
     return 0;
   Block &parent_block = sc.function->GetBlock(false);
   num_added =
       ParseFunctionBlocksForPDBSymbol(sc, pdb_func_up->getVirtualAddress(),
                                       pdb_func_up.get(), &parent_block, true);
   return num_added;
 }
 
-size_t SymbolFilePDB::ParseTypesForCompileUnit(CompileUnit &comp_unit) {
+size_t SymbolFilePDB::ParseTypes(CompileUnit &comp_unit) {
 
   size_t num_added = 0;
   auto compiland = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland)
     return 0;
 
   auto ParseTypesByTagFn = [&num_added, this](const PDBSymbol &raw_sym) {
     std::unique_ptr<IPDBEnumSymbols> results;
if (resolve_scope & eSymbolContextFunction ||
     auto symbol_up =
         m_session_up->findSymbolByAddress(file_vm_addr, PDB_SymType::Function);
     if (symbol_up) {
       auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
       assert(pdb_func);
       auto func_uid = pdb_func->getSymIndexId();
       sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
       if (sc.function == nullptr)
-        sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func, sc);
+        sc.function =
+            ParseCompileUnitFunctionForPDBFunc(*pdb_func, *sc.comp_unit);
       if (sc.function) {
         resolved_flags |= eSymbolContextFunction;
         if (resolve_scope & eSymbolContextBlock) {
           auto block_symbol = m_session_up->findSymbolByAddress(
               file_vm_addr, PDB_SymType::Block);
           auto block_id = block_symbol ? block_symbol->getSymIndexId()
                                        : sc.function->GetID();
           sc.block = sc.function->GetBlock(true).FindBlockByID(block_id);
while (auto compiland = compilands->getNext()) {
         continue;
       sc.comp_unit = cu.get();
       sc.module_sp = cu->GetModule();
 
       // If we were asked to resolve line entries, add all entries to the line
       // table that match the requested line (or all lines if `line` == 0).
       if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock |
                            eSymbolContextLineEntry)) {
-        bool has_line_table = ParseCompileUnitLineTable(sc, line);
+        bool has_line_table = ParseCompileUnitLineTable(*sc.comp_unit, line);
 
         if ((resolve_scope & eSymbolContextLineEntry) && !has_line_table) {
           // The query asks for line entries, but we can't get them for the
           // compile unit. This is not normal for `line` = 0. So just assert
           // it.
           assert(line && "Couldn't get all line entries!\n");
 
           // Current compiland does not have the requested line. Search next.
while (auto compiland = compilands->getNext()) {
             auto symbol_up = m_session_up->findSymbolByAddress(
                 file_vm_addr, PDB_SymType::Function);
             if (symbol_up) {
               auto func_uid = symbol_up->getSymIndexId();
               sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
               if (sc.function == nullptr) {
                 auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
                 assert(pdb_func);
-                sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func, sc);
+                sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func,
+                                                                 *sc.comp_unit);
               }
               if (sc.function && (resolve_scope & eSymbolContextBlock)) {
                 Block &block = sc.function->GetBlock(true);
                 sc.block = block.FindBlockByID(sc.function->GetID());
               }
             }
             sc_list.Append(sc);
           }

 bool SymbolFilePDB::ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
                                     bool include_inlines,
                                     lldb_private::SymbolContextList &sc_list) {
   lldb_private::SymbolContext sc;
   sc.comp_unit = ParseCompileUnitForUID(pdb_func.getCompilandId()).get();
   if (!sc.comp_unit)
     return false;
   sc.module_sp = sc.comp_unit->GetModule();
-  sc.function = ParseCompileUnitFunctionForPDBFunc(pdb_func, sc);
+  sc.function = ParseCompileUnitFunctionForPDBFunc(pdb_func, *sc.comp_unit);
   if (!sc.function)
     return false;
 
   sc_list.Append(sc);
   return true;
 }
 
 bool SymbolFilePDB::ResolveFunction(uint32_t uid, bool include_inlines,
lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitForUID(uint32_t id,
   if (index == UINT32_MAX)
     GetCompileUnitIndex(*compiland_up, index);
   lldbassert(index != UINT32_MAX);
   m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(index,
                                                                     cu_sp);
   return cu_sp;
 }
 
-bool SymbolFilePDB::ParseCompileUnitLineTable(
-    const lldb_private::SymbolContext &sc, uint32_t match_line) {
-  lldbassert(sc.comp_unit);
-
-  auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
+bool SymbolFilePDB::ParseCompileUnitLineTable(CompileUnit &comp_unit,
+                                              uint32_t match_line) {
+  auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland_up)
     return false;
 
   // LineEntry needs the *index* of the file into the list of support files
   // returned by ParseCompileUnitSupportFiles.  But the underlying SDK gives us
   // a globally unique idenfitifier in the namespace of the PDB.  So, we have
   // to do a mapping so that we can hand out indices.
   llvm::DenseMap<uint32_t, uint32_t> index_map;
   BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map);
-  auto line_table = llvm::make_unique<LineTable>(sc.comp_unit);
+  auto line_table = llvm::make_unique<LineTable>(&comp_unit);
 
   // Find contributions to `compiland` from all source and header files.
-  std::string path = sc.comp_unit->GetPath();
+  std::string path = comp_unit.GetPath();
   auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
   if (!files)
     return false;
 
   // For each source and header file, create a LineSequence for contributions
   // to the compiland from that file, and add the sequence.
   while (auto file = files->getNext()) {
     std::unique_ptr<LineSequence> sequence(
if (entry_count > 0 && ShouldAddLine(match_line, prev_line, prev_length)) {
           sequence.get(), prev_addr + prev_length, prev_line, 0,
           prev_source_idx, false, false, false, false, true);
     }
 
     line_table->InsertSequence(sequence.release());
   }
 
   if (line_table->GetSize()) {
-    sc.comp_unit->SetLineTable(line_table.release());
+    comp_unit.SetLineTable(line_table.release());
     return true;
   }
   return false;
 }
 
 void SymbolFilePDB::BuildSupportFileIdToSupportFileIndexMap(
     const PDBSymbolCompiland &compiland,
     llvm::DenseMap<uint32_t, uint32_t> &index_map) const {

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

public:
   //------------------------------------------------------------------
   // Compile Unit function calls
   //------------------------------------------------------------------
   uint32_t GetNumCompileUnits() override;
 
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
   lldb::LanguageType
-  ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) override;
+  ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
-  size_t
-  ParseCompileUnitFunctions(const lldb_private::SymbolContext &sc) override;
+  size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
-  bool
-  ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc) override;
+  bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
-  bool
-  ParseCompileUnitDebugMacros(const lldb_private::SymbolContext &sc) override;
+  bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
-  bool ParseCompileUnitSupportFiles(
-      const lldb_private::SymbolContext &sc,
+  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
                          lldb_private::FileSpecList &support_files) override;
 
+  size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
+
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::ConstString> &imported_modules) override;
 
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc) override;
 
   size_t
-  ParseTypesForCompileUnit(lldb_private::CompileUnit &comp_unit) override;
-
-  size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,
       const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

if (idx < m_source_indexes.size()) {
     if (cu_symbol)
       cu_sp.reset(new CompileUnit(m_obj_file->GetModule(), NULL,
                                   cu_symbol->GetName().AsCString(), 0,
                                   eLanguageTypeUnknown, eLazyBoolNo));
   }
   return cu_sp;
 }
 
-lldb::LanguageType
-SymbolFileSymtab::ParseCompileUnitLanguage(const SymbolContext &sc) {
+lldb::LanguageType SymbolFileSymtab::ParseLanguage(CompileUnit &comp_unit) {
   return eLanguageTypeUnknown;
 }
 
-size_t SymbolFileSymtab::ParseCompileUnitFunctions(const SymbolContext &sc) {
+size_t SymbolFileSymtab::ParseFunctions(CompileUnit &comp_unit) {
   size_t num_added = 0;
   // We must at least have a valid compile unit
-  assert(sc.comp_unit != NULL);
   const Symtab *symtab = m_obj_file->GetSymtab();
   const Symbol *curr_symbol = NULL;
   const Symbol *next_symbol = NULL;
   //  const char *prefix = m_obj_file->SymbolPrefix();
   //  if (prefix == NULL)
   //      prefix == "";
   //
   //  const uint32_t prefix_len = strlen(prefix);
if (!m_code_indexes.empty()) {
               if (next_symbol) {
                 func_range.SetByteSize(
                     next_symbol->GetAddressRef().GetOffset() -
                     curr_symbol->GetAddressRef().GetOffset());
               }
             }
 
             FunctionSP func_sp(
-                new Function(sc.comp_unit,
+                new Function(&comp_unit,
                              symbol_idx,       // UserID is the DIE offset
                              LLDB_INVALID_UID, // We don't have any type info
                                                // for this function
                              curr_symbol->GetMangled(), // Linker/mangled name
                              NULL, // no return type for a code symbol...
                              func_range)); // first address range
 
             if (func_sp.get() != NULL) {
-              sc.comp_unit->AddFunction(func_sp);
+              comp_unit.AddFunction(func_sp);
               ++num_added;
             }
           }
         }
       }
     }
   } else {
     // We assume we
   }
   return num_added;
 }
 
-bool SymbolFileSymtab::ParseCompileUnitLineTable(const SymbolContext &sc) {
-  return false;
-}
+size_t SymbolFileSymtab::ParseTypes(CompileUnit &comp_unit) { return 0; }
+
+bool SymbolFileSymtab::ParseLineTable(CompileUnit &comp_unit) { return false; }
 
-bool SymbolFileSymtab::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
+bool SymbolFileSymtab::ParseDebugMacros(CompileUnit &comp_unit) {
   return false;
 }
 
-bool SymbolFileSymtab::ParseCompileUnitSupportFiles(
-    const SymbolContext &sc, FileSpecList &support_files) {
+bool SymbolFileSymtab::ParseSupportFiles(CompileUnit &comp_unit,
+                                         FileSpecList &support_files) {
   return false;
 }
 
 bool SymbolFileSymtab::ParseImportedModules(
     const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
   return false;
 }
 
 size_t SymbolFileSymtab::ParseFunctionBlocks(const SymbolContext &sc) {
   return 0;
 }
 
-size_t SymbolFileSymtab::ParseTypesForCompileUnit(CompileUnit &comp_unit) {
-  return 0;
-}
-
 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {
   return 0;
 }
 
 Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) {
   return NULL;
 }
 

source/Symbol/CompileUnit.cpp

 }
 
 lldb::LanguageType CompileUnit::GetLanguage() {
   if (m_language == eLanguageTypeUnknown) {
     if (m_flags.IsClear(flagsParsedLanguage)) {
       m_flags.Set(flagsParsedLanguage);
       SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor();
       if (symbol_vendor) {
-        SymbolContext sc;
-        CalculateSymbolContext(&sc);
-        m_language = symbol_vendor->ParseCompileUnitLanguage(sc);
+        m_language = symbol_vendor->ParseLanguage(*this);
       }
     }
   }
   return m_language;
 }
 
 LineTable *CompileUnit::GetLineTable() {
   if (m_line_table_ap.get() == nullptr) {
     if (m_flags.IsClear(flagsParsedLineTable)) {
       m_flags.Set(flagsParsedLineTable);
       SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor();
-      if (symbol_vendor) {
-        SymbolContext sc;
-        CalculateSymbolContext(&sc);
-        symbol_vendor->ParseCompileUnitLineTable(sc);
-      }
+      if (symbol_vendor)
+        symbol_vendor->ParseLineTable(*this);
     }
   }
   return m_line_table_ap.get();
 }
 
 void CompileUnit::SetLineTable(LineTable *line_table) {
   if (line_table == nullptr)
     m_flags.Clear(flagsParsedLineTable);
   else
     m_flags.Set(flagsParsedLineTable);
   m_line_table_ap.reset(line_table);
 }
 
 DebugMacros *CompileUnit::GetDebugMacros() {
   if (m_debug_macros_sp.get() == nullptr) {
     if (m_flags.IsClear(flagsParsedDebugMacros)) {
       m_flags.Set(flagsParsedDebugMacros);
       SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor();
       if (symbol_vendor) {
-        SymbolContext sc;
-        CalculateSymbolContext(&sc);
-        symbol_vendor->ParseCompileUnitDebugMacros(sc);
+        symbol_vendor->ParseDebugMacros(*this);
       }
     }
   }
 
   return m_debug_macros_sp.get();
 }
 
 void CompileUnit::SetDebugMacros(const DebugMacrosSP &debug_macros_sp) {
uint32_t CompileUnit::ResolveSymbolContext(const FileSpec &file_spec,
   }
   return sc_list.GetSize() - prev_size;
 }
 
 bool CompileUnit::GetIsOptimized() {
   if (m_is_optimized == eLazyBoolCalculate) {
     m_is_optimized = eLazyBoolNo;
     if (SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor()) {
-      SymbolContext sc;
-      CalculateSymbolContext(&sc);
-      if (symbol_vendor->ParseCompileUnitIsOptimized(sc))
+      if (symbol_vendor->ParseIsOptimized(*this))
         m_is_optimized = eLazyBoolYes;
     }
   }
   return m_is_optimized;
 }
 
 void CompileUnit::SetVariableList(VariableListSP &variables) {
   m_variables = variables;

 }
 
 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) {
-        SymbolContext sc;
-        CalculateSymbolContext(&sc);
-        symbol_vendor->ParseCompileUnitSupportFiles(sc, m_support_files);
+        symbol_vendor->ParseSupportFiles(*this, m_support_files);
       }
     }
   }
   return m_support_files;
 }
 
 void *CompileUnit::GetUserData() const { return m_user_data; }

source/Symbol/SymbolVendor.cpp

if (m_compile_units.empty()) {
         // parse this compile unit information.
         m_compile_units.resize(m_sym_file_ap->GetNumCompileUnits());
       }
     }
   }
   return m_compile_units.size();
 }
 
-lldb::LanguageType
-SymbolVendor::ParseCompileUnitLanguage(const SymbolContext &sc) {
+lldb::LanguageType SymbolVendor::ParseLanguage(CompileUnit &comp_unit) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
-      return m_sym_file_ap->ParseCompileUnitLanguage(sc);
+      return m_sym_file_ap->ParseLanguage(comp_unit);
   }
   return eLanguageTypeUnknown;
 }
 
-size_t SymbolVendor::ParseCompileUnitFunctions(const SymbolContext &sc) {
+size_t SymbolVendor::ParseFunctions(CompileUnit &comp_unit) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
-      return m_sym_file_ap->ParseCompileUnitFunctions(sc);
+      return m_sym_file_ap->ParseFunctions(comp_unit);
   }
   return 0;
 }
 
-bool SymbolVendor::ParseCompileUnitLineTable(const SymbolContext &sc) {
+bool SymbolVendor::ParseLineTable(CompileUnit &comp_unit) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
-      return m_sym_file_ap->ParseCompileUnitLineTable(sc);
+      return m_sym_file_ap->ParseLineTable(comp_unit);
   }
   return false;
 }
 
-bool SymbolVendor::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
+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_ap.get())
-      return m_sym_file_ap->ParseCompileUnitDebugMacros(sc);
+      return m_sym_file_ap->ParseDebugMacros(comp_unit);
   }
   return false;
 }
-bool SymbolVendor::ParseCompileUnitSupportFiles(const SymbolContext &sc,
-                                                FileSpecList &support_files) {
+bool 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_ap.get())
-      return m_sym_file_ap->ParseCompileUnitSupportFiles(sc, support_files);
+      return m_sym_file_ap->ParseSupportFiles(comp_unit, support_files);
   }
   return false;
 }
 
-bool SymbolVendor::ParseCompileUnitIsOptimized(const SymbolContext &sc) {
+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_ap.get())
-      return m_sym_file_ap->ParseCompileUnitIsOptimized(sc);
+      return m_sym_file_ap->ParseIsOptimized(comp_unit);
   }
   return false;
 }
 
 bool SymbolVendor::ParseImportedModules(
     const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
size_t SymbolVendor::ParseFunctionBlocks(const SymbolContext &sc) {
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
       return m_sym_file_ap->ParseFunctionBlocks(sc);
   }
   return 0;
 }
 
-size_t SymbolVendor::ParseTypesForCompileUnit(CompileUnit &comp_unit) {
+size_t SymbolVendor::ParseTypes(CompileUnit &comp_unit) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
-      return m_sym_file_ap->ParseTypesForCompileUnit(comp_unit);
+      return m_sym_file_ap->ParseTypes(comp_unit);
   }
   return 0;
 }
 
 size_t SymbolVendor::ParseVariablesForContext(const SymbolContext &sc) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());