SymbolVendor: Remove the object file member variable

[labath]

Summary

The last responsibility of the SymbolVendor was to hold an owning
reference to the object file (in case symbols are being read from a
different file than the main module). As SymbolFile classes already hold
a non-owning reference to the object file, we can easily remove this
responsibility of the SymbolVendor by making the SymbolFile reference
owning.

[clayborg]

So previously the SymbolVendor would only make a strong reference to the object file if it didn't match the object file of the module. Now it always makes one. Might be ok since the Module owns the SymbolVendor and thus owns the SymbolFile. We should make sure we don't end up keeping an object file alive when a module goes away due to multiple strong references. I am guessing it will be ok, but good to verify.

[labath]

In D65401#1604870, @clayborg wrote:

So previously the SymbolVendor would only make a strong reference to the object file if it didn't match the object file of the module. Now it always makes one. Might be ok since the Module owns the SymbolVendor and thus owns the SymbolFile. We should make sure we don't end up keeping an object file alive when a module goes away due to multiple strong references. I am guessing it will be ok, but good to verify.

I've checked that the ObjectFile goes away when the owning Module is destroyed (e.g., in response to SBDebugger::MemoryPressureDetected), but I don't think this patch actually changes anything in terms of who-owns-who. The SymbolVendor was already storing a pointer to the object file even in case this was the main module object file (it stored the pointer "in case the object file is different", but the actual storing was unconditional).

lldb/trunk/include/lldb/Symbol/SymbolFile.h

enum Abilities {
     Functions = (1u << 2),
     Blocks = (1u << 3),
     GlobalVariables = (1u << 4),
     LocalVariables = (1u << 5),
     VariableTypes = (1u << 6),
     kAllAbilities = ((1u << 7) - 1u)
   };
 
-  static SymbolFile *FindPlugin(ObjectFile *obj_file);
+  static SymbolFile *FindPlugin(lldb::ObjectFileSP objfile_sp);
 
   // Constructors and Destructors
-  SymbolFile(ObjectFile *obj_file)
-      : m_obj_file(obj_file), m_abilities(0), m_calculated_abilities(false) {}
+  SymbolFile(lldb::ObjectFileSP objfile_sp)
+      : m_objfile_sp(std::move(objfile_sp)), m_abilities(0),
+        m_calculated_abilities(false) {}
 
   ~SymbolFile() override {}
 
   /// Get a mask of what this symbol file supports for the object file
   /// that it was constructed with.
   ///
   /// Each symbol file gets to respond with a mask of abilities that
   /// it supports for each object file. This happens when we are
public:
   GetTypeSystemForLanguage(lldb::LanguageType language);
 
   virtual CompilerDeclContext
   FindNamespace(ConstString name,
                 const CompilerDeclContext *parent_decl_ctx) {
     return CompilerDeclContext();
   }
 
-  ObjectFile *GetObjectFile() { return m_obj_file; }
-  const ObjectFile *GetObjectFile() const { return m_obj_file; }
+  ObjectFile *GetObjectFile() { return m_objfile_sp.get(); }
+  const ObjectFile *GetObjectFile() const { return m_objfile_sp.get(); }
   ObjectFile *GetMainObjectFile();
 
   virtual std::vector<CallEdge> ParseCallEdgesInFunction(UserID func_id) {
     return {};
   }
 
   virtual void AddSymbols(Symtab &symtab) {}
 

 protected:
   void AssertModuleLock();
   virtual uint32_t CalculateNumCompileUnits() = 0;
   virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t idx) = 0;
   virtual TypeList &GetTypeList() { return m_type_list; }
 
   void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp);
 
-  ObjectFile *m_obj_file; // The object file that symbols can be extracted from.
+  lldb::ObjectFileSP m_objfile_sp; // Keep a reference to the object file in
+                                   // case it isn't the same as the module
+                                   // object file (debug symbols in a separate
+                                   // file)
   llvm::Optional<std::vector<lldb::CompUnitSP>> m_compile_units;
   TypeList m_type_list;
   Symtab *m_symtab = nullptr;
   uint32_t m_abilities;
   bool m_calculated_abilities;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(SymbolFile);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_SymbolFile_h_

lldb/trunk/include/lldb/Symbol/SymbolVendor.h

public:
   virtual void SectionFileAddressesChanged();
 
   // PluginInterface protocol
   ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
 protected:
-  lldb::ObjectFileSP m_objfile_sp; // Keep a reference to the object file in
-                                   // case it isn't the same as the module
-                                   // object file (debug symbols in a separate
-                                   // file)
   std::unique_ptr<SymbolFile> m_sym_file_up; // A single symbol file. Subclasses
                                              // can add more of these if needed.
 
 private:
   // For SymbolVendor only
   DISALLOW_COPY_AND_ASSIGN(SymbolVendor);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_SymbolVendor_h_

lldb/trunk/include/lldb/lldb-private-interfaces.h

 typedef SystemRuntime *(*SystemRuntimeCreateInstance)(Process *process);
 typedef lldb::PlatformSP (*PlatformCreateInstance)(bool force,
                                                    const ArchSpec *arch);
 typedef lldb::ProcessSP (*ProcessCreateInstance)(
     lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
     const FileSpec *crash_file_path);
 typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)(
     Debugger &debugger);
-typedef SymbolFile *(*SymbolFileCreateInstance)(ObjectFile *obj_file);
+typedef SymbolFile *(*SymbolFileCreateInstance)(lldb::ObjectFileSP objfile_sp);
 typedef SymbolVendor *(*SymbolVendorCreateInstance)(
     const lldb::ModuleSP &module_sp,
     lldb_private::Stream
         *feedback_strm); // Module can be NULL for default system symbol vendor
 typedef bool (*BreakpointHitCallback)(void *baton,
                                       StoppointCallbackContext *context,
                                       lldb::user_id_t break_id,
                                       lldb::user_id_t break_loc_id);

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

public:
   static void Terminate();
   static void DebuggerInitialize(Debugger &debugger) {}
   static ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic() {
     return "Breakpad debug symbol file reader.";
   }
 
-  static SymbolFile *CreateInstance(ObjectFile *obj_file) {
-    return new SymbolFileBreakpad(obj_file);
+  static SymbolFile *CreateInstance(lldb::ObjectFileSP objfile_sp) {
+    return new SymbolFileBreakpad(std::move(objfile_sp));
   }
 
   // Constructors and Destructors
-  SymbolFileBreakpad(ObjectFile *object_file) : SymbolFile(object_file) {}
+  SymbolFileBreakpad(lldb::ObjectFileSP objfile_sp)
+      : SymbolFile(std::move(objfile_sp)) {}
 
   ~SymbolFileBreakpad() override {}
 
   uint32_t CalculateAbilities() override;
 
   void InitializeObject() override {}
 
   // Compile Unit function calls

lldb/trunk/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

SymbolFileBreakpad::LineIterator::operator++() {
   }
   // We've reached the end.
   m_current_line = m_next_line;
   return *this;
 }
 
 llvm::iterator_range<SymbolFileBreakpad::LineIterator>
 SymbolFileBreakpad::lines(Record::Kind section_type) {
-  return llvm::make_range(LineIterator(*m_obj_file, section_type),
-                          LineIterator(*m_obj_file));
+  return llvm::make_range(LineIterator(*m_objfile_sp, section_type),
+                          LineIterator(*m_objfile_sp));
 }
 
 namespace {
 // A helper class for constructing the list of support files for a given compile
 // unit.
 class SupportFileMap {
 public:
   // Given a breakpad file ID, return a file ID to be used in the support files

 }
 
 ConstString SymbolFileBreakpad::GetPluginNameStatic() {
   static ConstString g_name("breakpad");
   return g_name;
 }
 
 uint32_t SymbolFileBreakpad::CalculateAbilities() {
-  if (!m_obj_file)
+  if (!m_objfile_sp)
     return 0;
-  if (m_obj_file->GetPluginName() != ObjectFileBreakpad::GetPluginNameStatic())
+  if (m_objfile_sp->GetPluginName() !=
+      ObjectFileBreakpad::GetPluginNameStatic())
     return 0;
 
   return CompileUnits | Functions | LineTables;
 }
 
 uint32_t SymbolFileBreakpad::CalculateNumCompileUnits() {
   ParseCUData();
   return m_cu_data->GetSize();
 }
 
 CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) {
   if (index >= m_cu_data->GetSize())
     return nullptr;
 
   CompUnitData &data = m_cu_data->GetEntryRef(index).data;
 
   ParseFileRecords();
 
   FileSpec spec;
 
   // The FileSpec of the compile unit will be the file corresponding to the
   // first LINE record.
-  LineIterator It(*m_obj_file, Record::Func, data.bookmark), End(*m_obj_file);
+  LineIterator It(*m_objfile_sp, Record::Func, data.bookmark),
+      End(*m_objfile_sp);
   assert(Record::classify(*It) == Record::Func);
   ++It; // Skip FUNC record.
   if (It != End) {
     auto record = LineRecord::parse(*It);
     if (record && record->FileNum < m_files->size())
       spec = (*m_files)[record->FileNum];
   }
 
-  auto cu_sp = std::make_shared<CompileUnit>(m_obj_file->GetModule(),
+  auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(),
                                              /*user_data*/ nullptr, spec, index,
                                              eLanguageTypeUnknown,
                                              /*is_optimized*/ eLazyBoolNo);
 
   SetCompileUnitAtIndex(index, cu_sp);
   return cu_sp;
 }
 
SymbolFileBreakpad::FindTypes(const std::vector<CompilerContext> &context,
                               bool append, TypeMap &types) {
   if (!append)
     types.Clear();
   return types.GetSize();
 }
 
 void SymbolFileBreakpad::AddSymbols(Symtab &symtab) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
-  Module &module = *m_obj_file->GetModule();
+  Module &module = *m_objfile_sp->GetModule();
   addr_t base = GetBaseFileAddress();
   if (base == LLDB_INVALID_ADDRESS) {
     LLDB_LOG(log, "Unable to fetch the base address of object file. Skipping "
                   "symtab population.");
     return;
   }
 
   const SectionList &list = *module.GetSectionList();
bool success = postfix::ResolveSymbols(
           return nullptr;
         });
 
     if (!success) {
       LLDB_LOG(log, "Resolving symbols in `{0}` failed.", rule->second);
       return false;
     }
 
-    ArchSpec arch = m_obj_file->GetArchitecture();
+    ArchSpec arch = m_objfile_sp->GetArchitecture();
     StreamString dwarf(Stream::eBinary, arch.GetAddressByteSize(),
                        arch.GetByteOrder());
     ToDWARF(*rhs, dwarf);
     uint8_t *saved = m_allocator.Allocate<uint8_t>(dwarf.GetSize());
     std::memcpy(saved, dwarf.GetData(), dwarf.GetSize());
 
     if (lhs == ".cfa") {
       row.GetCFAValue().SetIsDWARFExpression(saved, dwarf.GetSize());
const UnwindMap::Entry *entry =
       m_unwind_data->FindEntryThatContains(address.GetFileAddress());
   if (!entry)
     return nullptr;
 
   addr_t base = GetBaseFileAddress();
   if (base == LLDB_INVALID_ADDRESS)
     return nullptr;
 
-  LineIterator It(*m_obj_file, Record::StackCFI, entry->data), End(*m_obj_file);
+  LineIterator It(*m_objfile_sp, Record::StackCFI, entry->data),
+      End(*m_objfile_sp);
   llvm::Optional<StackCFIRecord> init_record = StackCFIRecord::parse(*It);
   assert(init_record.hasValue());
   assert(init_record->Size.hasValue());
 
   auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindLLDB);
   plan_sp->SetSourceName("breakpad STACK CFI");
   plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
   plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo);
   plan_sp->SetSourcedFromCompiler(eLazyBoolYes);
   plan_sp->SetPlanValidAddressRange(
       AddressRange(base + init_record->Address, *init_record->Size,
-                   m_obj_file->GetModule()->GetSectionList()));
+                   m_objfile_sp->GetModule()->GetSectionList()));
 
   auto row_sp = std::make_shared<UnwindPlan::Row>();
   row_sp->SetOffset(0);
   if (!ParseUnwindRow(init_record->UnwindRules, resolver, *row_sp))
     return nullptr;
   plan_sp->AppendRow(row_sp);
   for (++It; It != End; ++It) {
     llvm::Optional<StackCFIRecord> record = StackCFIRecord::parse(*It);
     if (!record.hasValue())
       return nullptr;
     if (record->Size.hasValue())
       break;
 
     row_sp = std::make_shared<UnwindPlan::Row>(*row_sp);
     row_sp->SetOffset(record->Address - init_record->Address);
     if (!ParseUnwindRow(record->UnwindRules, resolver, *row_sp))
       return nullptr;
     plan_sp->AppendRow(row_sp);
   }
   return plan_sp;
 }
 
 addr_t SymbolFileBreakpad::GetBaseFileAddress() {
-  return m_obj_file->GetModule()
+  return m_objfile_sp->GetModule()
       ->GetObjectFile()
       ->GetBaseAddress()
       .GetFileAddress();
 }
 
 // Parse out all the FILE records from the breakpad file. These will be needed
 // when constructing the support file lists for individual compile units.
 void SymbolFileBreakpad::ParseFileRecords() {
void SymbolFileBreakpad::ParseCUData() {
   addr_t base = GetBaseFileAddress();
   if (base == LLDB_INVALID_ADDRESS) {
     LLDB_LOG(log, "SymbolFile parsing failed: Unable to fetch the base address "
                   "of object file.");
   }
 
   // We shall create one compile unit for each FUNC record. So, count the number
   // of FUNC records, and store them in m_cu_data, together with their ranges.
-  for (LineIterator It(*m_obj_file, Record::Func), End(*m_obj_file); It != End;
-       ++It) {
+  for (LineIterator It(*m_objfile_sp, Record::Func), End(*m_objfile_sp);
+       It != End; ++It) {
     if (auto record = FuncRecord::parse(*It)) {
       m_cu_data->Append(CompUnitMap::Entry(base + record->Address, record->Size,
                                            CompUnitData(It.GetBookmark())));
     } else
       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It);
   }
   m_cu_data->Sort();
 }
data.line_table_up->AppendLineEntryToSequence(
         line_seq_up.get(), *next_addr, /*line*/ 0, /*column*/ 0,
         /*file_idx*/ 0, /*is_start_of_statement*/ false,
         /*is_start_of_basic_block*/ false, /*is_prologue_end*/ false,
         /*is_epilogue_begin*/ false, /*is_terminal_entry*/ true);
     data.line_table_up->InsertSequence(line_seq_up.get());
     line_seq_up->Clear();
   };
 
-  LineIterator It(*m_obj_file, Record::Func, data.bookmark), End(*m_obj_file);
+  LineIterator It(*m_objfile_sp, Record::Func, data.bookmark),
+      End(*m_objfile_sp);
   assert(Record::classify(*It) == Record::Func);
   for (++It; It != End; ++It) {
     auto record = LineRecord::parse(*It);
     if (!record)
       break;
 
     record->Address += base;
 
void SymbolFileBreakpad::ParseUnwindData() {
   m_unwind_data.emplace();
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
   addr_t base = GetBaseFileAddress();
   if (base == LLDB_INVALID_ADDRESS) {
     LLDB_LOG(log, "SymbolFile parsing failed: Unable to fetch the base address "
                   "of object file.");
   }
 
-  for (LineIterator It(*m_obj_file, Record::StackCFI), End(*m_obj_file);
+  for (LineIterator It(*m_objfile_sp, Record::StackCFI), End(*m_objfile_sp);
        It != End; ++It) {
     if (auto record = StackCFIRecord::parse(*It)) {
       if (record->Size)
         m_unwind_data->Append(UnwindMap::Entry(
             base + record->Address, *record->Size, It.GetBookmark()));
     } else
       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It);
   }
   m_unwind_data->Sort();
 }

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

public:
 
   static void DebuggerInitialize(lldb_private::Debugger &debugger);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolFile *
-  CreateInstance(lldb_private::ObjectFile *obj_file);
+  CreateInstance(lldb::ObjectFileSP objfile_sp);
 
   static lldb_private::FileSpecList GetSymlinkPaths();
 
   // Constructors and Destructors
 
-  SymbolFileDWARF(lldb_private::ObjectFile *ofile,
+  SymbolFileDWARF(lldb::ObjectFileSP objfile_sp,
                   lldb_private::SectionList *dwo_section_list);
 
   ~SymbolFileDWARF() override;
 
   uint32_t CalculateAbilities() override;
 
   void InitializeObject() override;
 

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

lldb_private::ConstString SymbolFileDWARF::GetPluginNameStatic() {
   static ConstString g_name("dwarf");
   return g_name;
 }
 
 const char *SymbolFileDWARF::GetPluginDescriptionStatic() {
   return "DWARF and DWARF3 debug symbol file reader.";
 }
 
-SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFile *obj_file) {
-  return new SymbolFileDWARF(obj_file,
+SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFileSP objfile_sp) {
+  return new SymbolFileDWARF(std::move(objfile_sp),
                              /*dwo_section_list*/ nullptr);
 }
 
 TypeList &SymbolFileDWARF::GetTypeList() {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
     return debug_map_symfile->GetTypeList();
   return SymbolFile::GetTypeList();
for (die = child_die.GetParent(); die; die = die.GetParent()) {
     case DW_TAG_inlined_subroutine:
     case DW_TAG_lexical_block:
       return die;
     }
   }
   return DWARFDIE();
 }
 
-SymbolFileDWARF::SymbolFileDWARF(ObjectFile *objfile,
+SymbolFileDWARF::SymbolFileDWARF(ObjectFileSP objfile_sp,
                                  SectionList *dwo_section_list)
-    : SymbolFile(objfile),
+    : SymbolFile(std::move(objfile_sp)),
       UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to
                                   // when this class parses .o files to
                                   // contain the .o file index/ID
       m_debug_map_module_wp(), m_debug_map_symfile(nullptr),
-      m_context(objfile->GetModule()->GetSectionList(), dwo_section_list),
+      m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
       m_data_debug_loc(), m_abbr(), m_info(), m_fetched_external_modules(false),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate),
       m_unique_ast_type_map() {}
 
 SymbolFileDWARF::~SymbolFileDWARF() {}
 
 static ConstString GetDWARFMachOSegmentName() {
   static ConstString g_dwarf_section_name("__DWARF");

 }
 
 llvm::Expected<TypeSystem &>
 SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
     return debug_map_symfile->GetTypeSystemForLanguage(language);
 
   auto type_system_or_err =
-      m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
+      m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system_or_err) {
     type_system_or_err->SetSymbolFile(this);
   }
   return type_system_or_err;
 }
 
 void SymbolFileDWARF::InitializeObject() {
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);

 }
 
 bool SymbolFileDWARF::SupportedVersion(uint16_t version) {
   return version >= 2 && version <= 5;
 }
 
 uint32_t SymbolFileDWARF::CalculateAbilities() {
   uint32_t abilities = 0;
-  if (m_obj_file != nullptr) {
+  if (m_objfile_sp != nullptr) {
     const Section *section = nullptr;
-    const SectionList *section_list = m_obj_file->GetSectionList();
+    const SectionList *section_list = m_objfile_sp->GetSectionList();
     if (section_list == nullptr)
       return 0;
 
     uint64_t debug_abbrev_file_size = 0;
     uint64_t debug_info_file_size = 0;
     uint64_t debug_line_file_size = 0;
 
     section = section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();
if (section != nullptr) {
       if (abbrev) {
         std::set<dw_form_t> invalid_forms;
         abbrev->GetUnsupportedForms(invalid_forms);
         if (!invalid_forms.empty()) {
           StreamString error;
           error.Printf("unsupported DW_FORM value%s:", invalid_forms.size() > 1 ? "s" : "");
           for (auto form : invalid_forms)
             error.Printf(" %#x", form);
-          m_obj_file->GetModule()->ReportWarning("%s", error.GetString().str().c_str());
+          m_objfile_sp->GetModule()->ReportWarning(
+              "%s", error.GetString().str().c_str());
           return 0;
         }
       }
 
       section =
           section_list->FindSectionByType(eSectionTypeDWARFDebugLine, true)
               .get();
       if (section)
         debug_line_file_size = section->GetFileSize();
     } else {
       const char *symfile_dir_cstr =
-          m_obj_file->GetFileSpec().GetDirectory().GetCString();
+          m_objfile_sp->GetFileSpec().GetDirectory().GetCString();
       if (symfile_dir_cstr) {
         if (strcasestr(symfile_dir_cstr, ".dsym")) {
-          if (m_obj_file->GetType() == ObjectFile::eTypeDebugInfo) {
+          if (m_objfile_sp->GetType() == ObjectFile::eTypeDebugInfo) {
             // We have a dSYM file that didn't have a any debug info. If the
             // string table has a size of 1, then it was made from an
             // executable with no debug info, or from an executable that was
             // stripped.
             section =
                 section_list->FindSectionByType(eSectionTypeDWARFDebugStr, true)
                     .get();
             if (section && section->GetFileSize() == 1) {
-              m_obj_file->GetModule()->ReportWarning(
+              m_objfile_sp->GetModule()->ReportWarning(
                   "empty dSYM file detected, dSYM was created with an "
                   "executable with no debug info.");
             }
           }
         }
       }
     }
 
SymbolFileDWARF::GetCachedSectionData(lldb::SectionType sect_type,
   llvm::call_once(data_segment.m_flag, [this, sect_type, &data_segment] {
     this->LoadSectionData(sect_type, std::ref(data_segment.m_data));
   });
   return data_segment.m_data;
 }
 
 void SymbolFileDWARF::LoadSectionData(lldb::SectionType sect_type,
                                       DWARFDataExtractor &data) {
-  ModuleSP module_sp(m_obj_file->GetModule());
+  ModuleSP module_sp(m_objfile_sp->GetModule());
   const SectionList *section_list = module_sp->GetSectionList();
   if (!section_list)
     return;
 
   SectionSP section_sp(section_list->FindSectionByType(sect_type, true));
   if (!section_sp)
     return;
 
   data.Clear();
-  m_obj_file->ReadSectionData(section_sp.get(), data);
+  m_objfile_sp->ReadSectionData(section_sp.get(), data);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::DebugLocData() {
   const DWARFDataExtractor &debugLocData = get_debug_loc_data();
   if (debugLocData.GetByteSize() > 0)
     return debugLocData;
   return get_debug_loclists_data();
 }
lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) {
   } else {
     if (&dwarf_cu.GetSymbolFileDWARF() != this) {
       return dwarf_cu.GetSymbolFileDWARF().ParseCompileUnit(dwarf_cu);
     } else if (dwarf_cu.GetOffset() == 0 && GetDebugMapSymfile()) {
       // Let the debug map create the compile unit
       cu_sp = m_debug_map_symfile->GetCompileUnit(this);
       dwarf_cu.SetUserData(cu_sp.get());
     } else {
-      ModuleSP module_sp(m_obj_file->GetModule());
+      ModuleSP module_sp(m_objfile_sp->GetModule());
       if (module_sp) {
         const DWARFDIE cu_die = dwarf_cu.DIE();
         if (cu_die) {
           FileSpec cu_file_spec(cu_die.GetName(), dwarf_cu.GetPathStyle());
           if (cu_file_spec) {
             // If we have a full path to the compile unit, we don't need to
             // resolve the file.  This can be expensive e.g. when the source
             // files are NFS mounted.
if (die && !die.HasChildren()) {
               if (comp_dir) {
                 dwo_module_spec.GetFileSpec().SetFile(comp_dir,
                                                       FileSpec::Style::native);
                 FileSystem::Instance().Resolve(dwo_module_spec.GetFileSpec());
                 dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path);
               }
             }
             dwo_module_spec.GetArchitecture() =
-                m_obj_file->GetModule()->GetArchitecture();
+                m_objfile_sp->GetModule()->GetArchitecture();
 
             // When LLDB loads "external" modules it looks at the presence of
             // DW_AT_GNU_dwo_name. However, when the already created module
             // (corresponding to .dwo itself) is being processed, it will see
             // the presence of DW_AT_GNU_dwo_name (which contains the name of
             // dwo file) and will try to call ModuleList::GetSharedModule
             // again. In some cases (i.e. for empty files) Clang 4.0 generates
             // a *.dwo file which has DW_AT_GNU_dwo_name, but no
             // DW_AT_comp_dir. In this case the method
             // ModuleList::GetSharedModule will fail and the warning will be
             // printed. However, as one can notice in this case we don't
             // actually need to try to load the already loaded module
             // (corresponding to .dwo) so we simply skip it.
-            if (m_obj_file->GetFileSpec().GetFileNameExtension() == ".dwo" &&
-                llvm::StringRef(m_obj_file->GetFileSpec().GetPath())
+            if (m_objfile_sp->GetFileSpec().GetFileNameExtension() == ".dwo" &&
+                llvm::StringRef(m_objfile_sp->GetFileSpec().GetPath())
                     .endswith(dwo_module_spec.GetFileSpec().GetPath())) {
               continue;
             }
 
             Status error = ModuleList::GetSharedModule(
                 dwo_module_spec, module_sp, nullptr, nullptr, nullptr);
             if (!module_sp) {
               GetObjectFile()->GetModule()->ReportWarning(
for (uint32_t cu_idx = 0, num_cus = GetNumCompileUnits(); cu_idx < num_cus;
       CompileUnit *dc_cu = ParseCompileUnitAtIndex(cu_idx).get();
       if (!dc_cu)
         continue;
 
       const bool full_match = (bool)file_spec.GetDirectory();
       bool file_spec_matches_cu_file_spec =
           FileSpec::Equal(file_spec, *dc_cu, full_match);
       if (check_inlines || file_spec_matches_cu_file_spec) {
-        SymbolContext sc(m_obj_file->GetModule());
+        SymbolContext sc(m_objfile_sp->GetModule());
         sc.comp_unit = dc_cu;
         uint32_t file_idx = UINT32_MAX;
 
         // If we are looking for inline functions only and we don't find it
         // in the support files, we are done.
         if (check_inlines) {
           file_idx =
               sc.comp_unit->GetSupportFiles().FindFileIndex(1, file_spec, true);
if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name.GetCString(),
                                                       context, basename))
     basename = name.GetStringRef();
 
   DIEArray die_offsets;
   m_index->GetGlobalVariables(ConstString(basename), die_offsets);
   const size_t num_die_matches = die_offsets.size();
   if (num_die_matches) {
     SymbolContext sc;
-    sc.module_sp = m_obj_file->GetModule();
+    sc.module_sp = m_objfile_sp->GetModule();
     assert(sc.module_sp);
 
     // Loop invariant: Variables up to this index have been checked for context
     // matches.
     uint32_t pruned_idx = original_size;
 
     bool done = false;
     for (size_t i = 0; i < num_die_matches && !done; ++i) {
uint32_t SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
 
   // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
 
   DIEArray die_offsets;
   m_index->GetGlobalVariables(regex, die_offsets);
 
   SymbolContext sc;
-  sc.module_sp = m_obj_file->GetModule();
+  sc.module_sp = m_objfile_sp->GetModule();
   assert(sc.module_sp);
 
   const size_t num_matches = die_offsets.size();
   if (num_matches) {
     for (size_t i = 0; i < num_matches; ++i) {
       const DIERef &die_ref = die_offsets[i];
       DWARFDIE die = GetDIE(die_ref);
 
if (orig_die) {
     }
   }
   return DWARFDIE();
 }
 
 Symbol *
 SymbolFileDWARF::GetObjCClassSymbol(ConstString objc_class_name) {
   Symbol *objc_class_symbol = nullptr;
-  if (m_obj_file) {
-    Symtab *symtab = m_obj_file->GetSymtab();
+  if (m_objfile_sp) {
+    Symtab *symtab = m_objfile_sp->GetSymtab();
     if (symtab) {
       objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(
           objc_class_name, eSymbolTypeObjCClass, Symtab::eDebugNo,
           Symtab::eVisibilityAny);
     }
   }
   return objc_class_symbol;
 }
for (size_t i = 0; i < num_matches; ++i) {
                 DW_AT_APPLE_objc_complete_type, 0);
 
           if (try_resolving_type) {
             Type *resolved_type = ResolveType(type_die, false, true);
             if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) {
               DEBUG_PRINTF("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
                            " (cu 0x%8.8" PRIx64 ")\n",
                            die.GetID(),
-                           m_obj_file->GetFileSpec().GetFilename().AsCString(
+                           m_objfile_sp->GetFileSpec().GetFilename().AsCString(
                                "<Unknown>"),
                            type_die.GetID(), type_cu->GetID());
 
               if (die)
                 GetDIEToType()[die.GetDIE()] = resolved_type;
               type_sp = resolved_type->shared_from_this();
               break;
             }
SymbolFileDWARF::GetLocationListFormat() const {
   if (m_data_debug_loclists.m_data.GetByteSize() > 0)
     return DWARFExpression::LocLists;
   return DWARFExpression::RegularLocationList;
 }
 
 SymbolFileDWARFDwp *SymbolFileDWARF::GetDwpSymbolFile() {
   llvm::call_once(m_dwp_symfile_once_flag, [this]() {
     ModuleSpec module_spec;
-    module_spec.GetFileSpec() = m_obj_file->GetFileSpec();
+    module_spec.GetFileSpec() = m_objfile_sp->GetFileSpec();
     module_spec.GetSymbolFileSpec() =
-        FileSpec(m_obj_file->GetFileSpec().GetPath() + ".dwp");
+        FileSpec(m_objfile_sp->GetFileSpec().GetPath() + ".dwp");
 
     FileSpecList search_paths = Target::GetDefaultDebugFileSearchPaths();
     FileSpec dwp_filespec =
         Symbols::LocateExecutableSymbolFile(module_spec, search_paths);
     if (FileSystem::Instance().Exists(dwp_filespec)) {
       m_dwp_symfile = SymbolFileDWARFDwp::Create(GetObjectFile()->GetModule(),
                                                  dwp_filespec);
     }
   });
   return m_dwp_symfile.get();
 }

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

public:
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolFile *
-  CreateInstance(lldb_private::ObjectFile *obj_file);
+  CreateInstance(lldb::ObjectFileSP objfile_sp);
 
   // Constructors and Destructors
-  SymbolFileDWARFDebugMap(lldb_private::ObjectFile *ofile);
+  SymbolFileDWARFDebugMap(lldb::ObjectFileSP objfile_sp);
   ~SymbolFileDWARFDebugMap() override;
 
   uint32_t CalculateAbilities() override;
   void InitializeObject() override;
 
   // Compile Unit function calls
   lldb::LanguageType
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

lldb_private::ConstString SymbolFileDWARFDebugMap::GetPluginNameStatic() {
   static ConstString g_name("dwarf-debugmap");
   return g_name;
 }
 
 const char *SymbolFileDWARFDebugMap::GetPluginDescriptionStatic() {
   return "DWARF and DWARF3 debug symbol file reader (debug map).";
 }
 
-SymbolFile *SymbolFileDWARFDebugMap::CreateInstance(ObjectFile *obj_file) {
-  return new SymbolFileDWARFDebugMap(obj_file);
+SymbolFile *SymbolFileDWARFDebugMap::CreateInstance(ObjectFileSP objfile_sp) {
+  return new SymbolFileDWARFDebugMap(std::move(objfile_sp));
 }
 
-SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap(ObjectFile *ofile)
-    : SymbolFile(ofile), m_flags(), m_compile_unit_infos(), m_func_indexes(),
-      m_glob_indexes(),
+SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap(ObjectFileSP objfile_sp)
+    : SymbolFile(std::move(objfile_sp)), m_flags(), m_compile_unit_infos(),
+      m_func_indexes(), m_glob_indexes(),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
 
 SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap() {}
 
 void SymbolFileDWARFDebugMap::InitializeObject() {}
 
 void SymbolFileDWARFDebugMap::InitOSO() {
   if (m_flags.test(kHaveInitializedOSOs))
     return;
 
   m_flags.set(kHaveInitializedOSOs);
 
   // If the object file has been stripped, there is no sense in looking further
   // as all of the debug symbols for the debug map will not be available
-  if (m_obj_file->IsStripped())
+  if (m_objfile_sp->IsStripped())
     return;
 
   // Also make sure the file type is some sort of executable. Core files, debug
   // info files (dSYM), object files (.o files), and stub libraries all can
-  switch (m_obj_file->GetType()) {
+  switch (m_objfile_sp->GetType()) {
   case ObjectFile::eTypeInvalid:
   case ObjectFile::eTypeCoreFile:
   case ObjectFile::eTypeDebugInfo:
   case ObjectFile::eTypeObjectFile:
   case ObjectFile::eTypeStubLibrary:
   case ObjectFile::eTypeUnknown:
   case ObjectFile::eTypeJIT:
     return;
 
   case ObjectFile::eTypeExecutable:
   case ObjectFile::eTypeDynamicLinker:
   case ObjectFile::eTypeSharedLibrary:
     break;
   }
 
   // In order to get the abilities of this plug-in, we look at the list of
   // N_OSO entries (object files) from the symbol table and make sure that
   // these files exist and also contain valid DWARF. If we get any of that then
   // we return the abilities of the first N_OSO's DWARF.
 
-  Symtab *symtab = m_obj_file->GetSymtab();
+  Symtab *symtab = m_objfile_sp->GetSymtab();
   if (symtab) {
     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
 
     std::vector<uint32_t> oso_indexes;
     // When a mach-o symbol is encoded, the n_type field is encoded in bits
     // 23:16, and the n_desc field is encoded in bits 15:0.
     //
     // To find all N_OSO entries that are part of the DWARF + debug map we find
if (oso_index_count > 0) {
               so_symbol->GetName().AsCString(), FileSpec::Style::native);
           m_compile_unit_infos[i].oso_path = oso_symbol->GetName();
           m_compile_unit_infos[i].oso_mod_time =
               llvm::sys::toTimePoint(oso_symbol->GetIntegerValue(0));
           uint32_t sibling_idx = so_symbol->GetSiblingIndex();
           // The sibling index can't be less that or equal to the current index
           // "i"
           if (sibling_idx == UINT32_MAX) {
-            m_obj_file->GetModule()->ReportError(
+            m_objfile_sp->GetModule()->ReportError(
                 "N_SO in symbol with UID %u has invalid sibling in debug map, "
                 "please file a bug and attach the binary listed in this error",
                 so_symbol->GetID());
           } else {
             const Symbol *last_symbol = symtab->SymbolAtIndex(sibling_idx - 1);
             m_compile_unit_infos[i].first_symbol_index = so_idx;
             m_compile_unit_infos[i].last_symbol_index = sibling_idx - 1;
             m_compile_unit_infos[i].first_symbol_id = so_symbol->GetID();
             m_compile_unit_infos[i].last_symbol_id = last_symbol->GetID();
 
             LLDB_LOGF(log, "Initialized OSO 0x%8.8x: file=%s", i,
                       oso_symbol->GetName().GetCString());
           }
         } else {
           if (oso_symbol == nullptr)
-            m_obj_file->GetModule()->ReportError(
+            m_objfile_sp->GetModule()->ReportError(
                 "N_OSO symbol[%u] can't be found, please file a bug and attach "
                 "the binary listed in this error",
                 oso_idx);
           else if (so_symbol == nullptr)
-            m_obj_file->GetModule()->ReportError(
+            m_objfile_sp->GetModule()->ReportError(
                 "N_SO not found for N_OSO symbol[%u], please file a bug and "
                 "attach the binary listed in this error",
                 oso_idx);
           else if (so_symbol->GetType() != eSymbolTypeSourceFile)
-            m_obj_file->GetModule()->ReportError(
+            m_objfile_sp->GetModule()->ReportError(
                 "N_SO has incorrect symbol type (%u) for N_OSO symbol[%u], "
                 "please file a bug and attach the binary listed in this error",
                 so_symbol->GetType(), oso_idx);
           else if (oso_symbol->GetType() != eSymbolTypeSourceFile)
-            m_obj_file->GetModule()->ReportError(
+            m_objfile_sp->GetModule()->ReportError(
                 "N_OSO has incorrect symbol type (%u) for N_OSO symbol[%u], "
                 "please file a bug and attach the binary listed in this error",
                 oso_symbol->GetType(), oso_idx);
         }
       }
     }
   }
 }
if (pos != m_oso_map.end()) {
       // map, to add new sections to each .o file and even though a .o file
       // might not have changed, the sections that get added to the .o file can
       // change.
       ArchSpec oso_arch;
       // Only adopt the architecture from the module (not the vendor or OS)
       // since .o files for "i386-apple-ios" will historically show up as "i386
       // -apple-macosx" due to the lack of a LC_VERSION_MIN_MACOSX or
       // LC_VERSION_MIN_IPHONEOS load command...
-      oso_arch.SetTriple(m_obj_file->GetModule()
+      oso_arch.SetTriple(m_objfile_sp->GetModule()
                              ->GetArchitecture()
                              .GetTriple()
                              .getArchName()
                              .str()
                              .c_str());
       comp_unit_info->oso_sp->module_sp = std::make_shared<DebugMapModule>(
           obj_file->GetModule(), GetCompUnitInfoIndex(comp_unit_info), oso_file,
           oso_arch, oso_object ? &oso_object : nullptr, 0,
if (cu_idx < cu_count) {
     if (oso_module) {
       FileSpec so_file_spec;
       if (GetFileSpecForSO(cu_idx, so_file_spec)) {
         // User zero as the ID to match the compile unit at offset zero in each
         // .o file since each .o file can only have one compile unit for now.
         lldb::user_id_t cu_id = 0;
         m_compile_unit_infos[cu_idx].compile_unit_sp =
             std::make_shared<CompileUnit>(
-                m_obj_file->GetModule(), nullptr, so_file_spec, cu_id,
+                m_objfile_sp->GetModule(), nullptr, so_file_spec, cu_id,
                 eLanguageTypeUnknown, eLazyBoolCalculate);
 
         if (m_compile_unit_infos[cu_idx].compile_unit_sp) {
           SetCompileUnitAtIndex(cu_idx,
                                 m_compile_unit_infos[cu_idx].compile_unit_sp);
         }
       }
     }

 }
 
 uint32_t
 SymbolFileDWARFDebugMap::ResolveSymbolContext(const Address &exe_so_addr,
                                               SymbolContextItem resolve_scope,
                                               SymbolContext &sc) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   uint32_t resolved_flags = 0;
-  Symtab *symtab = m_obj_file->GetSymtab();
+  Symtab *symtab = m_objfile_sp->GetSymtab();
   if (symtab) {
     const addr_t exe_file_addr = exe_so_addr.GetFileAddress();
 
     const DebugMap::Entry *debug_map_entry =
         m_debug_map.FindEntryThatContains(exe_file_addr);
     if (debug_map_entry) {
 
       sc.symbol =
if (append)
     initial_size = sc_list.GetSize();
   else
     sc_list.Clear();
 
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     uint32_t sc_idx = sc_list.GetSize();
     if (oso_dwarf->FindFunctions(name, parent_decl_ctx, name_type_mask,
                                  include_inlines, true, sc_list)) {
-      RemoveFunctionsWithModuleNotEqualTo(m_obj_file->GetModule(), sc_list,
+      RemoveFunctionsWithModuleNotEqualTo(m_objfile_sp->GetModule(), sc_list,
                                           sc_idx);
     }
     return false;
   });
 
   return sc_list.GetSize() - initial_size;
 }
 
if (append)
     initial_size = sc_list.GetSize();
   else
     sc_list.Clear();
 
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     uint32_t sc_idx = sc_list.GetSize();
 
     if (oso_dwarf->FindFunctions(regex, include_inlines, true, sc_list)) {
-      RemoveFunctionsWithModuleNotEqualTo(m_obj_file->GetModule(), sc_list,
+      RemoveFunctionsWithModuleNotEqualTo(m_objfile_sp->GetModule(), sc_list,
                                           sc_idx);
     }
     return false;
   });
 
   return sc_list.GetSize() - initial_size;
 }
 
TypeSP SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE(
   // If we have a debug map, we will have an Objective-C symbol whose name is
   // the type name and whose type is eSymbolTypeObjCClass. If we can find that
   // symbol and find its containing parent, we can locate the .o file that will
   // contain the implementation definition since it will be scoped inside the
   // N_SO and we can then locate the SymbolFileDWARF that corresponds to that
   // N_SO.
   SymbolFileDWARF *oso_dwarf = nullptr;
   TypeSP type_sp;
-  ObjectFile *module_objfile = m_obj_file->GetModule()->GetObjectFile();
+  ObjectFile *module_objfile = m_objfile_sp->GetModule()->GetObjectFile();
   if (module_objfile) {
     Symtab *symtab = module_objfile->GetSymtab();
     if (symtab) {
       Symbol *objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(
           type_name, eSymbolTypeObjCClass, Symtab::eDebugAny,
           Symtab::eVisibilityAny);
       if (objc_class_symbol) {
         // Get the N_SO symbol that contains the objective C class symbol as

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

protected:
   lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, lldb_private::ConstString type_name,
       bool must_be_implementation) override;
 
   SymbolFileDWARF &GetBaseSymbolFile();
 
   DWARFCompileUnit *ComputeCompileUnit();
 
-  lldb::ObjectFileSP m_obj_file_sp;
   DWARFCompileUnit &m_base_dwarf_cu;
   DWARFCompileUnit *m_cu = nullptr;
 };
 
 #endif // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

 #include "DWARFDebugInfo.h"
 #include "DWARFUnit.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SymbolFileDWARFDwo::SymbolFileDWARFDwo(ObjectFileSP objfile,
                                        DWARFCompileUnit &dwarf_cu)
-    : SymbolFileDWARF(objfile.get(), objfile->GetSectionList(
-                                         /*update_module_section_list*/ false)),
-      m_obj_file_sp(objfile), m_base_dwarf_cu(dwarf_cu) {
+    : SymbolFileDWARF(objfile, objfile->GetSectionList(
+      m_base_dwarf_cu(dwarf_cu) {
   SetID(((lldb::user_id_t)dwarf_cu.GetID()) << 32);
 }
 
 void SymbolFileDWARFDwo::LoadSectionData(lldb::SectionType sect_type,
                                          DWARFDataExtractor &data) {
   const SectionList *section_list =
-      m_obj_file->GetSectionList(false /* update_module_section_list */);
+      m_objfile_sp->GetSectionList(false /* update_module_section_list */);
   if (section_list) {
     SectionSP section_sp(section_list->FindSectionByType(sect_type, true));
     if (section_sp) {
 
-      if (m_obj_file->ReadSectionData(section_sp.get(), data) != 0)
+      if (m_objfile_sp->ReadSectionData(section_sp.get(), data) != 0)
         return;
 
       data.Clear();
     }
   }
 
   SymbolFileDWARF::LoadSectionData(sect_type, data);
 }

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

public:
   static void Terminate();
 
   static void DebuggerInitialize(Debugger &debugger);
 
   static ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
-  static SymbolFile *CreateInstance(ObjectFile *obj_file);
+  static SymbolFile *CreateInstance(lldb::ObjectFileSP objfile_sp);
 
   // Constructors and Destructors
-  SymbolFileNativePDB(ObjectFile *ofile);
+  SymbolFileNativePDB(lldb::ObjectFileSP objfile_sp);
 
   ~SymbolFileNativePDB() override;
 
   uint32_t CalculateAbilities() override;
 
   void InitializeObject() override;
 
   // Compile Unit function calls

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

ConstString SymbolFileNativePDB::GetPluginNameStatic() {
   static ConstString g_name("native-pdb");
   return g_name;
 }
 
 const char *SymbolFileNativePDB::GetPluginDescriptionStatic() {
   return "Microsoft PDB debug symbol cross-platform file reader.";
 }
 
-SymbolFile *SymbolFileNativePDB::CreateInstance(ObjectFile *obj_file) {
-  return new SymbolFileNativePDB(obj_file);
+SymbolFile *SymbolFileNativePDB::CreateInstance(ObjectFileSP objfile_sp) {
+  return new SymbolFileNativePDB(std::move(objfile_sp));
 }
 
-SymbolFileNativePDB::SymbolFileNativePDB(ObjectFile *object_file)
-    : SymbolFile(object_file) {}
+SymbolFileNativePDB::SymbolFileNativePDB(ObjectFileSP objfile_sp)
+    : SymbolFile(std::move(objfile_sp)) {}
 
 SymbolFileNativePDB::~SymbolFileNativePDB() {}
 
 uint32_t SymbolFileNativePDB::CalculateAbilities() {
   uint32_t abilities = 0;
-  if (!m_obj_file)
+  if (!m_objfile_sp)
     return 0;
 
   if (!m_index) {
     // Lazily load and match the PDB file, but only do this once.
     std::unique_ptr<PDBFile> file_up =
-        loadMatchingPDBFile(m_obj_file->GetFileSpec().GetPath(), m_allocator);
+        loadMatchingPDBFile(m_objfile_sp->GetFileSpec().GetPath(), m_allocator);
 
     if (!file_up) {
-      auto module_sp = m_obj_file->GetModule();
+      auto module_sp = m_objfile_sp->GetModule();
       if (!module_sp)
         return 0;
       // See if any symbol file is specified through `--symfile` option.
       FileSpec symfile = module_sp->GetSymbolFileFileSpec();
       if (!symfile)
         return 0;
       file_up = loadPDBFile(symfile.GetPath(), m_allocator);
     }
uint32_t SymbolFileNativePDB::CalculateAbilities() {
   abilities = kAllAbilities;
 
   if (m_index->dbi().isStripped())
     abilities &= ~(Blocks | LocalVariables);
   return abilities;
 }
 
 void SymbolFileNativePDB::InitializeObject() {
-  m_obj_load_address = m_obj_file->GetBaseAddress().GetFileAddress();
+  m_obj_load_address = m_objfile_sp->GetBaseAddress().GetFileAddress();
   m_index->SetLoadAddress(m_obj_load_address);
   m_index->ParseSectionContribs();
 
-  auto ts_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage(
+  auto ts_or_err = m_objfile_sp->GetModule()->GetTypeSystemForLanguage(
       lldb::eLanguageTypeC_plus_plus);
   if (auto err = ts_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Failed to initialize");
   } else {
     ts_or_err->SetSymbolFile(this);
     auto *clang = llvm::cast_or_null<ClangASTContext>(&ts_or_err.get());
     lldbassert(clang);
-    m_ast = llvm::make_unique<PdbAstBuilder>(*m_obj_file, *m_index, *clang);
+    m_ast = llvm::make_unique<PdbAstBuilder>(*m_objfile_sp, *m_index, *clang);
   }
 }
 
 uint32_t SymbolFileNativePDB::CalculateNumCompileUnits() {
   const DbiModuleList &modules = m_index->dbi().modules();
   uint32_t count = modules.getModuleCount();
   if (count == 0)
     return count;
SymbolFileNativePDB::CreateCompileUnit(const CompilandIndexItem &cci) {
   if (cci.m_compile_opts && cci.m_compile_opts->hasOptimizations())
     optimized = eLazyBoolYes;
 
   llvm::SmallString<64> source_file_name =
       m_index->compilands().GetMainSourceFile(cci);
   FileSpec fs(source_file_name);
 
   CompUnitSP cu_sp =
-      std::make_shared<CompileUnit>(m_obj_file->GetModule(), nullptr, fs,
+      std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr, fs,
                                     toOpaqueUid(cci.m_id), lang, optimized);
 
   SetCompileUnitAtIndex(cci.m_id.modi, cu_sp);
   return cu_sp;
 }
 
 lldb::TypeSP SymbolFileNativePDB::CreateModifierType(PdbTypeSymId type_id,
                                                      const ModifierRecord &mr,

 SymbolFileNativePDB::FindNamespace(ConstString name,
                                    const CompilerDeclContext *parent_decl_ctx) {
   return {};
 }
 
 llvm::Expected<TypeSystem &>
 SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
   auto type_system_or_err =
-      m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
+      m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system_or_err) {
     type_system_or_err->SetSymbolFile(this);
   }
   return type_system_or_err;
 }
 
 ConstString SymbolFileNativePDB::GetPluginName() {
   static ConstString g_name("pdb");
   return g_name;
 }
 
 uint32_t SymbolFileNativePDB::GetPluginVersion() { return 1; }

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

public:
 
   static void DebuggerInitialize(lldb_private::Debugger &debugger);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolFile *
-  CreateInstance(lldb_private::ObjectFile *obj_file);
+  CreateInstance(lldb::ObjectFileSP objfile_sp);
 
   // Constructors and Destructors
-  SymbolFilePDB(lldb_private::ObjectFile *ofile);
+  SymbolFilePDB(lldb::ObjectFileSP objfile_sp);
 
   ~SymbolFilePDB() override;
 
   uint32_t CalculateAbilities() override;
 
   void InitializeObject() override;
 
   // Compile Unit function calls

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

lldb_private::ConstString SymbolFilePDB::GetPluginNameStatic() {
   return g_name;
 }
 
 const char *SymbolFilePDB::GetPluginDescriptionStatic() {
   return "Microsoft PDB debug symbol file reader.";
 }
 
 lldb_private::SymbolFile *
-SymbolFilePDB::CreateInstance(lldb_private::ObjectFile *obj_file) {
-  return new SymbolFilePDB(obj_file);
+SymbolFilePDB::CreateInstance(ObjectFileSP objfile_sp) {
+  return new SymbolFilePDB(std::move(objfile_sp));
 }
 
-SymbolFilePDB::SymbolFilePDB(lldb_private::ObjectFile *object_file)
-    : SymbolFile(object_file), m_session_up(), m_global_scope_up() {}
+SymbolFilePDB::SymbolFilePDB(lldb::ObjectFileSP objfile_sp)
+    : SymbolFile(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}
 
 SymbolFilePDB::~SymbolFilePDB() {}
 
 uint32_t SymbolFilePDB::CalculateAbilities() {
   uint32_t abilities = 0;
-  if (!m_obj_file)
+  if (!m_objfile_sp)
     return 0;
 
   if (!m_session_up) {
     // Lazily load and match the PDB file, but only do this once.
-    std::string exePath = m_obj_file->GetFileSpec().GetPath();
+    std::string exePath = m_objfile_sp->GetFileSpec().GetPath();
     auto error = loadDataForEXE(PDB_ReaderType::DIA, llvm::StringRef(exePath),
                                 m_session_up);
     if (error) {
       llvm::consumeError(std::move(error));
-      auto module_sp = m_obj_file->GetModule();
+      auto module_sp = m_objfile_sp->GetModule();
       if (!module_sp)
         return 0;
       // See if any symbol file is specified through `--symfile` option.
       FileSpec symfile = module_sp->GetSymbolFileFileSpec();
       if (!symfile)
         return 0;
       error = loadDataForPDB(PDB_ReaderType::DIA,
                              llvm::StringRef(symfile.GetPath()), m_session_up);
while (auto table_up = enum_tables_up->getNext()) {
     default:
       break;
     }
   }
   return abilities;
 }
 
 void SymbolFilePDB::InitializeObject() {
-  lldb::addr_t obj_load_address = m_obj_file->GetBaseAddress().GetFileAddress();
+  lldb::addr_t obj_load_address =
+      m_objfile_sp->GetBaseAddress().GetFileAddress();
   lldbassert(obj_load_address && obj_load_address != LLDB_INVALID_ADDRESS);
   m_session_up->setLoadAddress(obj_load_address);
   if (!m_global_scope_up)
     m_global_scope_up = m_session_up->getGlobalScope();
   lldbassert(m_global_scope_up.get());
 }
 
 uint32_t SymbolFilePDB::CalculateNumCompileUnits() {
uint32_t SymbolFilePDB::FindGlobalVariables(
   uint32_t matches = 0;
   size_t old_size = variables.GetSize();
   while (auto result = results->getNext()) {
     auto pdb_data = llvm::dyn_cast<PDBSymbolData>(result.get());
     if (max_matches > 0 && matches >= max_matches)
       break;
 
     SymbolContext sc;
-    sc.module_sp = m_obj_file->GetModule();
+    sc.module_sp = m_objfile_sp->GetModule();
     lldbassert(sc.module_sp.get());
 
     if (!name.GetStringRef().equals(
             MSVCUndecoratedNameParser::DropScope(pdb_data->getName())))
       continue;
 
     sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
     // FIXME: We are not able to determine the compile unit.
if (max_matches > 0 && matches >= max_matches)
       break;
 
     auto var_name = pdb_data->getName();
     if (var_name.empty())
       continue;
     if (!regex.Execute(var_name))
       continue;
     SymbolContext sc;
-    sc.module_sp = m_obj_file->GetModule();
+    sc.module_sp = m_objfile_sp->GetModule();
     lldbassert(sc.module_sp.get());
 
     sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
     // FIXME: We are not able to determine the compile unit.
     if (sc.comp_unit == nullptr)
       continue;
 
     ParseVariables(sc, *pdb_data, &variables);
void SymbolFilePDB::AddSymbols(lldb_private::Symtab &symtab) {
   std::set<lldb::addr_t> sym_addresses;
   for (size_t i = 0; i < symtab.GetNumSymbols(); i++)
     sym_addresses.insert(symtab.SymbolAtIndex(i)->GetFileAddress());
 
   auto results = m_global_scope_up->findAllChildren<PDBSymbolPublicSymbol>();
   if (!results)
     return;
 
-  auto section_list = m_obj_file->GetSectionList();
+  auto section_list = m_objfile_sp->GetSectionList();
   if (!section_list)
     return;
 
   while (auto pub_symbol = results->getNext()) {
     auto section_id = pub_symbol->getAddressSection();
 
     auto section = section_list->FindSectionByID(section_id);
     if (!section)
for (auto type : type_collection) {
     type_list.Insert(type->shared_from_this());
   }
   return type_list.GetSize() - old_size;
 }
 
 llvm::Expected<lldb_private::TypeSystem &>
 SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
   auto type_system_or_err =
-      m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
+      m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system_or_err) {
     type_system_or_err->SetSymbolFile(this);
   }
   return type_system_or_err;
 }
 
 PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
   auto type_system_or_err =
lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitForUID(uint32_t id,
 
   std::string path = compiland_up->getSourceFileFullPath();
   if (path.empty())
     return CompUnitSP();
 
   // Don't support optimized code for now, DebugInfoPDB does not return this
   // information.
   LazyBool optimized = eLazyBoolNo;
-  auto cu_sp = std::make_shared<CompileUnit>(m_obj_file->GetModule(), nullptr,
+  auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
                                              path.c_str(), id, lang, optimized);
 
   if (!cu_sp)
     return CompUnitSP();
 
   m_comp_units.insert(std::make_pair(id, cu_sp));
   if (index == UINT32_MAX)
     GetCompileUnitIndex(*compiland_up, index);

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

 #include <vector>
 
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Symtab.h"
 
 class SymbolFileSymtab : public lldb_private::SymbolFile {
 public:
   // Constructors and Destructors
-  SymbolFileSymtab(lldb_private::ObjectFile *obj_file);
+  SymbolFileSymtab(lldb::ObjectFileSP objfile_sp);
 
   ~SymbolFileSymtab() override;
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolFile *
-  CreateInstance(lldb_private::ObjectFile *obj_file);
+  CreateInstance(lldb::ObjectFileSP objfile_sp);
 
   uint32_t CalculateAbilities() override;
 
   // Compile Unit function calls
   lldb::LanguageType
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;

lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

lldb_private::ConstString SymbolFileSymtab::GetPluginNameStatic() {
   static ConstString g_name("symtab");
   return g_name;
 }
 
 const char *SymbolFileSymtab::GetPluginDescriptionStatic() {
   return "Reads debug symbols from an object file's symbol table.";
 }
 
-SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFile *obj_file) {
-  return new SymbolFileSymtab(obj_file);
+SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFileSP objfile_sp) {
+  return new SymbolFileSymtab(std::move(objfile_sp));
 }
 
 size_t SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope,
                                   TypeClass type_mask,
                                   lldb_private::TypeList &type_list) {
   return 0;
 }
 
-SymbolFileSymtab::SymbolFileSymtab(ObjectFile *obj_file)
-    : SymbolFile(obj_file), m_source_indexes(), m_func_indexes(),
+SymbolFileSymtab::SymbolFileSymtab(ObjectFileSP objfile_sp)
+    : SymbolFile(std::move(objfile_sp)), m_source_indexes(), m_func_indexes(),
       m_code_indexes(), m_objc_class_name_to_index() {}
 
 SymbolFileSymtab::~SymbolFileSymtab() {}
 
 uint32_t SymbolFileSymtab::CalculateAbilities() {
   uint32_t abilities = 0;
-  if (m_obj_file) {
-    const Symtab *symtab = m_obj_file->GetSymtab();
+  if (m_objfile_sp) {
+    const Symtab *symtab = m_objfile_sp->GetSymtab();
     if (symtab) {
       // The snippet of code below will get the indexes the module symbol table
       // entries that are code, data, or function related (debug info), sort
       // them by value (address) and dump the sorted symbols.
       if (symtab->AppendSymbolIndexesWithType(eSymbolTypeSourceFile,
                                               m_source_indexes)) {
         abilities |= CompileUnits;
       }

 
 CompUnitSP SymbolFileSymtab::ParseCompileUnitAtIndex(uint32_t idx) {
   CompUnitSP cu_sp;
 
   // If we don't have any source file symbols we will just have one compile
   // unit for the entire object file
   if (idx < m_source_indexes.size()) {
     const Symbol *cu_symbol =
-        m_obj_file->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]);
+        m_objfile_sp->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]);
     if (cu_symbol)
-      cu_sp = std::make_shared<CompileUnit>(m_obj_file->GetModule(), nullptr,
+      cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
                                             cu_symbol->GetName().AsCString(), 0,
                                             eLanguageTypeUnknown, eLazyBoolNo);
   }
   return cu_sp;
 }
 
 lldb::LanguageType SymbolFileSymtab::ParseLanguage(CompileUnit &comp_unit) {
   return eLanguageTypeUnknown;
 }
 
 size_t SymbolFileSymtab::ParseFunctions(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   size_t num_added = 0;
   // We must at least have a valid compile unit
-  const Symtab *symtab = m_obj_file->GetSymtab();
+  const Symtab *symtab = m_objfile_sp->GetSymtab();
   const Symbol *curr_symbol = nullptr;
   const Symbol *next_symbol = nullptr;
-  //  const char *prefix = m_obj_file->SymbolPrefix();
+  //  const char *prefix = m_objfile_sp->SymbolPrefix();
   //  if (prefix == NULL)
   //      prefix == "";
   //
   //  const uint32_t prefix_len = strlen(prefix);
 
   // If we don't have any source file symbols we will just have one compile
   // unit for the entire object file
   if (m_source_indexes.empty()) {

 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) {
   return false;
 }
 
 uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr,
                                                 SymbolContextItem resolve_scope,
                                                 SymbolContext &sc) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  if (m_obj_file->GetSymtab() == nullptr)
+  if (m_objfile_sp->GetSymtab() == nullptr)
     return 0;
 
   uint32_t resolved_flags = 0;
   if (resolve_scope & eSymbolContextSymbol) {
-    sc.symbol = m_obj_file->GetSymtab()->FindSymbolContainingFileAddress(
+    sc.symbol = m_objfile_sp->GetSymtab()->FindSymbolContainingFileAddress(
         so_addr.GetFileAddress());
     if (sc.symbol)
       resolved_flags |= eSymbolContextSymbol;
   }
   return resolved_flags;
 }
 
 // PluginInterface protocol
 lldb_private::ConstString SymbolFileSymtab::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t SymbolFileSymtab::GetPluginVersion() { return 1; }

lldb/trunk/source/Symbol/SymbolFile.cpp

 void SymbolFile::PreloadSymbols() {
   // No-op for most implementations.
 }
 
 std::recursive_mutex &SymbolFile::GetModuleMutex() const {
   return GetObjectFile()->GetModule()->GetMutex();
 }
 ObjectFile *SymbolFile::GetMainObjectFile() {
-  return m_obj_file->GetModule()->GetObjectFile();
+  return m_objfile_sp->GetModule()->GetObjectFile();
 }
 
-SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) {
+SymbolFile *SymbolFile::FindPlugin(ObjectFileSP objfile_sp) {
   std::unique_ptr<SymbolFile> best_symfile_up;
-  if (obj_file != nullptr) {
+  if (objfile_sp != nullptr) {
 
     // We need to test the abilities of this section list. So create what it
-    // would be with this new obj_file.
-    lldb::ModuleSP module_sp(obj_file->GetModule());
+    // would be with this new objfile_sp.
+    lldb::ModuleSP module_sp(objfile_sp->GetModule());
     if (module_sp) {
       // Default to the main module section list.
       ObjectFile *module_obj_file = module_sp->GetObjectFile();
-      if (module_obj_file != obj_file) {
+      if (module_obj_file != objfile_sp.get()) {
         // Make sure the main object file's sections are created
         module_obj_file->GetSectionList();
-        obj_file->CreateSections(*module_sp->GetUnifiedSectionList());
+        objfile_sp->CreateSections(*module_sp->GetUnifiedSectionList());
       }
     }
 
     // TODO: Load any plug-ins in the appropriate plug-in search paths and
     // iterate over all of them to find the best one for the job.
 
     uint32_t best_symfile_abilities = 0;
 
     SymbolFileCreateInstance create_callback;
     for (uint32_t idx = 0;
          (create_callback = PluginManager::GetSymbolFileCreateCallbackAtIndex(
               idx)) != nullptr;
          ++idx) {
-      std::unique_ptr<SymbolFile> curr_symfile_up(create_callback(obj_file));
+      std::unique_ptr<SymbolFile> curr_symfile_up(create_callback(objfile_sp));
 
       if (curr_symfile_up) {
         const uint32_t sym_file_abilities = curr_symfile_up->GetAbilities();
         if (sym_file_abilities > best_symfile_abilities) {
           best_symfile_abilities = sym_file_abilities;
           best_symfile_up.reset(curr_symfile_up.release());
           // If any symbol file parser has all of the abilities, then we should
           // just stop looking.
if (objfile_sp != nullptr) {
     }
   }
   return best_symfile_up.release();
 }
 
 llvm::Expected<TypeSystem &>
 SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) {
   auto type_system_or_err =
-      m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
+      m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system_or_err) {
     type_system_or_err->SetSymbolFile(this);
   }
   return type_system_or_err;
 }
 
 uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec,
                                           uint32_t line, bool check_inlines,

lldb/trunk/source/Symbol/SymbolVendor.cpp

 // Destructor
 SymbolVendor::~SymbolVendor() {}
 
 // Add a representation given an object file.
 void SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (objfile_sp) {
-      m_objfile_sp = objfile_sp;
-      m_sym_file_up.reset(SymbolFile::FindPlugin(objfile_sp.get()));
-    }
+    if (objfile_sp)
+      m_sym_file_up.reset(SymbolFile::FindPlugin(objfile_sp));
   }
 }
 
 size_t SymbolVendor::GetNumCompileUnits() {
   if (m_sym_file_up)
     return m_sym_file_up->GetNumCompileUnits();
   return 0;
 }