[lldb] Fix symbol table use after free

[augusto2112]

Summary

The symbol file stores a raw pointer to the main object file's symbol
table. This pointer, however, can be freed, if ObjectFile::ClearSymtab
is ever called. This patch makes sure the pointer to the symbol file
is valid before using it.

[JDevlieghere]

LGTM

lldb/source/Symbol/SymbolFile.cpp

188–190

lldb/include/lldb/Symbol/SymbolFile.h

protected:
   void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp);
 
   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 = 0;
   bool m_calculated_abilities = false;
   bool m_index_was_loaded_from_cache = false;
   bool m_index_was_saved_to_cache = false;
   /// Set to true if any variable feteching errors have been found when calling
   /// GetFrameVariableError(). This will be emitted in the "statistics dump"
   /// information for a module.
   bool m_debug_info_had_variable_errors = false;
 
 private:
   SymbolFileCommon(const SymbolFileCommon &) = delete;
   const SymbolFileCommon &operator=(const SymbolFileCommon &) = delete;
+
+  /// Do not use m_symtab directly, as it may be freed. Use GetSymtab()
+  /// to access it instead.
+  Symtab *m_symtab = nullptr;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_SYMBOLFILE_H

lldb/source/Symbol/SymbolFile.cpp

assert(std::async(
          "Module is not locked");
 #endif
 }
 
 SymbolFile::RegisterInfoResolver::~RegisterInfoResolver() = default;
 
 Symtab *SymbolFileCommon::GetSymtab() {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  if (m_symtab)
-    return m_symtab;
-
   // Fetch the symtab from the main object file.
-  m_symtab = GetMainObjectFile()->GetSymtab();
+  auto *symtab = GetMainObjectFile()->GetSymtab();
+  if (m_symtab != symtab) {
+    m_symtab = symtab;
 
     // Then add our symbols to it.
     if (m_symtab)
       AddSymbols(*m_symtab);
-
+  }
   return m_symtab;
 }
 
 ObjectFile *SymbolFileCommon::GetMainObjectFile() {
   return m_objfile_sp->GetModule()->GetObjectFile();
 }
 
 void SymbolFileCommon::SectionFileAddressesChanged() {
   ObjectFile *module_objfile = GetMainObjectFile();
   ObjectFile *symfile_objfile = GetObjectFile();
   if (symfile_objfile != module_objfile)
     symfile_objfile->SectionFileAddressesChanged();
-  if (m_symtab)
-    m_symtab->SectionFileAddressesChanged();
+  auto *symtab = GetSymtab();
+  if (symtab)
+    symtab->SectionFileAddressesChanged();
 }
 
 uint32_t SymbolFileCommon::GetNumCompileUnits() {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!m_compile_units) {
     // Create an array of compile unit shared pointers -- which will each
     // remain NULL until someone asks for the actual compile unit information.
     m_compile_units.emplace(CalculateNumCompileUnits());