[SymbolFile] Change ParseFunctionBlocks(SymbolContext&) to ParseBlocksRecursive(Function&)

[zturner]

Summary

This limits the API surface by providing only the necessary and sufficient information through the parameter list, while also making the expectations of the API self-documenting, since we include the word Recursive in the function name.

[labath]

looks good to me.

lldb/include/lldb/Symbol/SymbolFile.h

public:
   virtual bool ParseSupportFiles(CompileUnit &comp_unit,
                                  FileSpecList &support_files) = 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<ConstString> &imported_modules) = 0;
-  virtual size_t ParseFunctionBlocks(const SymbolContext &sc) = 0;
+  virtual size_t ParseBlocksRecursive(Function &func) = 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;

lldb/include/lldb/Symbol/SymbolVendor.h

public:
 
   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 ParseBlocksRecursive(Function &func);
 
   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);

lldb/source/Core/Module.cpp

for (size_t cu_idx = 0; cu_idx < num_comp_units; cu_idx++) {
     if (!sc.comp_unit)
       continue;
 
     symbols->ParseVariablesForContext(sc);
 
     symbols->ParseFunctions(*sc.comp_unit);
 
     sc.comp_unit->ForeachFunction([&sc, &symbols](const FunctionSP &f) {
-      sc.function = f.get();
-      symbols->ParseFunctionBlocks(sc);
+      symbols->ParseBlocksRecursive(*f);
+
       // Parse the variables for this function and all its blocks
+      sc.function = f.get();
       symbols->ParseVariablesForContext(sc);
       return false;
     });
 
     // Parse all types for this compile unit
     symbols->ParseTypes(*sc.comp_unit);
   }
 }

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

public:
   size_t ParseTypes(CompileUnit &cu) override { return 0; }
 
   bool
   ParseImportedModules(const SymbolContext &sc,
                        std::vector<ConstString> &imported_modules) override {
     return false;
   }
 
-  size_t ParseFunctionBlocks(const SymbolContext &sc) override { return 0; }
+  size_t ParseBlocksRecursive(Function &func) override { return 0; }
 
   uint32_t FindGlobalVariables(const ConstString &name,
                                const CompilerDeclContext *parent_decl_ctx,
                                uint32_t max_matches,
                                VariableList &variables) override {
     return 0;
   }
 

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

public:
   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 ParseBlocksRecursive(lldb_private::Function &func) 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;
protected:
 
   DWARFUnit *GetNextUnparsedDWARFCompileUnit(DWARFUnit *prev_cu);
 
   bool GetFunction(const DWARFDIE &die, lldb_private::SymbolContext &sc);
 
   lldb_private::Function *ParseFunction(lldb_private::CompileUnit &comp_unit,
                                         const DWARFDIE &die);
 
-  size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc,
+  size_t ParseBlocksRecursive(lldb_private::CompileUnit &comp_unit,
                               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);
 
   lldb::TypeSP ParseType(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die, bool *type_is_new);
 
   lldb_private::Type *ResolveTypeUID(const DWARFDIE &die,

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

bool SymbolFileDWARF::ParseDebugMacros(CompileUnit &comp_unit) {
   if (sect_offset == DW_INVALID_OFFSET)
     return false;
 
   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,
-                                            uint32_t depth) {
+size_t SymbolFileDWARF::ParseBlocksRecursive(
+    lldb_private::CompileUnit &comp_unit, Block *parent_block,
+    const DWARFDIE &orig_die, addr_t subprogram_low_pc, uint32_t depth) {
   size_t blocks_added = 0;
   DWARFDIE die = orig_die;
   while (die) {
     dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_inlined_subroutine:
     case DW_TAG_subprogram:
case DW_TAG_lexical_block: {
         }
         block->FinalizeRanges();
 
         if (tag != DW_TAG_subprogram &&
             (name != NULL || mangled_name != NULL)) {
           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));
 
           std::unique_ptr<Declaration> call_ap;
           if (call_file != 0 || call_line != 0 || call_column != 0)
             call_ap.reset(new Declaration(
-                sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(call_file),
+                comp_unit.GetSupportFiles().GetFileSpecAtIndex(call_file),
                 call_line, call_column));
 
           block->SetInlinedFunctionInfo(name, mangled_name, decl_ap.get(),
                                         call_ap.get());
         }
 
         ++blocks_added;
 
         if (die.HasChildren()) {
-          blocks_added += ParseFunctionBlocks(sc, block, die.GetFirstChild(),
-                                              subprogram_low_pc, depth + 1);
+          blocks_added +=
+              ParseBlocksRecursive(comp_unit, block, die.GetFirstChild(),
         }
       }
     } break;
     default:
       break;
     }
 
     // Only parse siblings of the block if we are not at depth zero. A depth of
while (die) {
     if (parse_siblings)
       die = die.GetSibling();
     else
       die.Clear();
   }
   return types_added;
 }
 
-size_t SymbolFileDWARF::ParseFunctionBlocks(const SymbolContext &sc) {
+size_t SymbolFileDWARF::ParseBlocksRecursive(Function &func) {
   ASSERT_MODULE_LOCK(this);
-  assert(sc.comp_unit && sc.function);
+  CompileUnit *comp_unit = func.GetCompileUnit();
+  lldbassert(comp_unit);
+
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
+  if (!dwarf_cu)
+    return 0;
+
   size_t functions_added = 0;
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
-  if (dwarf_cu) {
-    const dw_offset_t function_die_offset = sc.function->GetID();
-    DWARFDIE function_die = dwarf_cu->GetDIE(function_die_offset);
-    if (function_die) {
-      ParseFunctionBlocks(sc, &sc.function->GetBlock(false), function_die,
-                          LLDB_INVALID_ADDRESS, 0);
-    }
-  }
+  const dw_offset_t function_die_offset = func.GetID();
+    ParseBlocksRecursive(*comp_unit, &func.GetBlock(false), function_die,
 
   return functions_added;
 }
 
 size_t SymbolFileDWARF::ParseTypes(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
   size_t types_added = 0;
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);

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

public:
 
   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 ParseBlocksRecursive(lldb_private::Function &func) 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/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 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);
+size_t SymbolFileDWARFDebugMap::ParseBlocksRecursive(Function &func) {
+  CompileUnit *comp_unit = func.GetCompileUnit();
+  if (!comp_unit)
+    return 0;
+
+  SymbolFileDWARF *oso_dwarf = GetSymbolFile(*comp_unit);
   if (oso_dwarf)
-    return oso_dwarf->ParseFunctionBlocks(sc);
+    return oso_dwarf->ParseBlocksRecursive(func);
   return 0;
 }
 
 size_t SymbolFileDWARFDebugMap::ParseTypes(CompileUnit &comp_unit) {
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseTypes(comp_unit);
   return 0;

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
   bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
                          FileSpecList &support_files) override;
   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;
+  size_t ParseBlocksRecursive(Function &func) override;
 
   uint32_t FindGlobalVariables(const ConstString &name,
                                const CompilerDeclContext *parent_decl_ctx,
                                uint32_t max_matches,
                                VariableList &variables) override;
 
   size_t ParseVariablesForContext(const SymbolContext &sc) override;
 

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 }
 
 bool SymbolFileNativePDB::ParseImportedModules(
     const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
   // PDB does not yet support module debug info
   return false;
 }
 
-size_t SymbolFileNativePDB::ParseFunctionBlocks(const SymbolContext &sc) {
-  lldbassert(sc.comp_unit && sc.function);
-  GetOrCreateBlock(PdbSymUid(sc.function->GetID()).asCompilandSym());
+size_t SymbolFileNativePDB::ParseBlocksRecursive(Function &func) {
+  GetOrCreateBlock(PdbSymUid(func.GetID()).asCompilandSym());
   // FIXME: Parse child blocks
   return 1;
 }
 
 void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); }
 
 uint32_t SymbolFileNativePDB::FindGlobalVariables(
     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

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 ParseBlocksRecursive(lldb_private::Function &func) 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/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

 bool SymbolFilePDB::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<lldb_private::ConstString> &imported_modules) {
   // PDB does not yet support module debug info
   return false;
 }
 
 static size_t ParseFunctionBlocksForPDBSymbol(
-    const lldb_private::SymbolContext &sc, uint64_t func_file_vm_addr,
-    const llvm::pdb::PDBSymbol *pdb_symbol, lldb_private::Block *parent_block,
-    bool is_top_parent) {
+    uint64_t func_file_vm_addr, const llvm::pdb::PDBSymbol *pdb_symbol,
+    lldb_private::Block *parent_block, bool is_top_parent) {
   assert(pdb_symbol && parent_block);
 
   size_t num_added = 0;
   switch (pdb_symbol->getSymTag()) {
   case PDB_SymType::Block:
   case PDB_SymType::Function: {
     Block *block = nullptr;
     auto &raw_sym = pdb_symbol->getRawSymbol();
case PDB_SymType::Function: {
     block->FinalizeRanges();
     ++num_added;
 
     auto results_up = pdb_symbol->findAllChildren();
     if (!results_up)
       break;
     while (auto symbol_up = results_up->getNext()) {
       num_added += ParseFunctionBlocksForPDBSymbol(
-          sc, func_file_vm_addr, symbol_up.get(), block, false);
+          func_file_vm_addr, symbol_up.get(), block, false);
     }
   } break;
   default:
     break;
   }
   return num_added;
 }
 
-size_t
-SymbolFilePDB::ParseFunctionBlocks(const lldb_private::SymbolContext &sc) {
-  lldbassert(sc.comp_unit && sc.function);
+size_t SymbolFilePDB::ParseBlocksRecursive(Function &func) {
   size_t num_added = 0;
-  auto uid = sc.function->GetID();
+  auto uid = func.GetID();
   auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
   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);
+  Block &parent_block = func.GetBlock(false);
+  num_added = ParseFunctionBlocksForPDBSymbol(
+      pdb_func_up->getVirtualAddress(), pdb_func_up.get(), &parent_block, true);
   return num_added;
 }
 
 size_t SymbolFilePDB::ParseTypes(CompileUnit &comp_unit) {
 
   size_t num_added = 0;
   auto compiland = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland)

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

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 ParseBlocksRecursive(lldb_private::Function &func) 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/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

bool SymbolFileSymtab::ParseSupportFiles(CompileUnit &comp_unit,
   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::ParseBlocksRecursive(Function &func) { return 0; }
 
 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {
   return 0;
 }
 
 Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) {
   return NULL;
 }

lldb/source/Symbol/Function.cpp

llvm::MutableArrayRef<CallEdge> Function::GetTailCallingEdges() {
   // return PCs. Find them at the end of the list.
   return GetCallEdges().drop_until([](const CallEdge &edge) {
     return edge.GetUnresolvedReturnPCAddress() == LLDB_INVALID_ADDRESS;
   });
 }
 
 Block &Function::GetBlock(bool can_create) {
   if (!m_block.BlockInfoHasBeenParsed() && can_create) {
-    SymbolContext sc;
-    CalculateSymbolContext(&sc);
-    if (sc.module_sp) {
-      sc.module_sp->GetSymbolVendor()->ParseFunctionBlocks(sc);
+    ModuleSP module_sp = CalculateSymbolContextModule();
+    if (module_sp) {
+      module_sp->GetSymbolVendor()->ParseBlocksRecursive(*this);
     } else {
-      Host::SystemLog(Host::eSystemLogError, "error: unable to find module "
-                                             "shared pointer for function '%s' "
-                                             "in %s\n",
+      Host::SystemLog(Host::eSystemLogError,
+                      "error: unable to find module "
                       GetName().GetCString(), m_comp_unit->GetPath().c_str());
     }
     m_block.SetBlockInfoHasBeenParsed(true, true);
   }
   return m_block;
 }
 
 CompileUnit *Function::GetCompileUnit() { return m_comp_unit; }

lldb/source/Symbol/SymbolVendor.cpp

bool SymbolVendor::ParseImportedModules(
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
       return m_sym_file_ap->ParseImportedModules(sc, imported_modules);
   }
   return false;
 }
 
-size_t SymbolVendor::ParseFunctionBlocks(const SymbolContext &sc) {
+size_t SymbolVendor::ParseBlocksRecursive(Function &func) {
   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->ParseFunctionBlocks(sc);
+      return m_sym_file_ap->ParseBlocksRecursive(func);
   }
   return 0;
 }
 
 size_t SymbolVendor::ParseTypes(CompileUnit &comp_unit) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());