SymbolFileSymtab.cpp

Go to the documentation of this file.

//===-- SymbolFileSymtab.cpp ----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "SymbolFileSymtab.h"
 
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Symtab.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Timer.h"
 
#include <memory>
#include <optional>
 
using namespace lldb;
using namespace lldb_private;
 
LLDB_PLUGIN_DEFINE(SymbolFileSymtab)
 
char SymbolFileSymtab::ID;
 
void SymbolFileSymtab::Initialize() {
  PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                GetPluginDescriptionStatic(), CreateInstance);
}
 
void SymbolFileSymtab::Terminate() {
  PluginManager::UnregisterPlugin(CreateInstance);
}
 
llvm::StringRef SymbolFileSymtab::GetPluginDescriptionStatic() {
  return "Reads debug symbols from an object file's symbol table.";
}
 
SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFileSP objfile_sp) {
  return new SymbolFileSymtab(std::move(objfile_sp));
}
 
void SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope,
                                TypeClass type_mask,
                                lldb_private::TypeList &type_list) {}
 
SymbolFileSymtab::SymbolFileSymtab(ObjectFileSP objfile_sp)
    : SymbolFileCommon(std::move(objfile_sp)), m_source_indexes(),
      m_func_indexes(), m_code_indexes(), m_objc_class_name_to_index() {}
 
uint32_t SymbolFileSymtab::CalculateAbilities() {
  uint32_t abilities = 0;
  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;
      }
 
      if (symtab->AppendSymbolIndexesWithType(
              eSymbolTypeCode, Symtab::eDebugYes, Symtab::eVisibilityAny,
              m_func_indexes)) {
        symtab->SortSymbolIndexesByValue(m_func_indexes, true);
        abilities |= Functions;
      }
 
      if (symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugNo,
                                              Symtab::eVisibilityAny,
                                              m_code_indexes)) {
        symtab->SortSymbolIndexesByValue(m_code_indexes, true);
        abilities |= Functions;
      }
 
      if (symtab->AppendSymbolIndexesWithType(eSymbolTypeData,
                                              m_data_indexes)) {
        symtab->SortSymbolIndexesByValue(m_data_indexes, true);
        abilities |= GlobalVariables;
      }
 
      lldb_private::Symtab::IndexCollection objc_class_indexes;
      if (symtab->AppendSymbolIndexesWithType(eSymbolTypeObjCClass,
                                              objc_class_indexes)) {
        symtab->AppendSymbolNamesToMap(objc_class_indexes, true, true,
                                       m_objc_class_name_to_index);
        m_objc_class_name_to_index.Sort();
      }
    }
  }
  return abilities;
}
 
uint32_t SymbolFileSymtab::CalculateNumCompileUnits() {
  // 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())
    return 0;
 
  // If we have any source file symbols we will logically organize the object
  // symbols using these.
  return m_source_indexes.size();
}
 
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_objfile_sp->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]);
    if (cu_symbol)
      cu_sp =
          std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
                                        cu_symbol->GetName().AsCString(nullptr),
                                        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_objfile_sp->GetSymtab();
  const Symbol *curr_symbol = nullptr;
  const Symbol *next_symbol = nullptr;
  //  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()) {
    // The only time we will have a user ID of zero is when we don't have and
    // source file symbols and we declare one compile unit for the entire
    // object file
    if (!m_func_indexes.empty()) {
    }
 
    if (!m_code_indexes.empty()) {
      //          StreamFile s(stdout);
      //          symtab->Dump(&s, m_code_indexes);
 
      uint32_t idx = 0; // Index into the indexes
      const uint32_t num_indexes = m_code_indexes.size();
      for (idx = 0; idx < num_indexes; ++idx) {
        uint32_t symbol_idx = m_code_indexes[idx];
        curr_symbol = symtab->SymbolAtIndex(symbol_idx);
        if (curr_symbol) {
          // Union of all ranges in the function DIE (if the function is
          // discontiguous)
          AddressRange func_range(curr_symbol->GetAddress(), 0);
          if (func_range.GetBaseAddress().IsSectionOffset()) {
            uint32_t symbol_size = curr_symbol->GetByteSize();
            if (symbol_size != 0 && !curr_symbol->GetSizeIsSibling())
              func_range.SetByteSize(symbol_size);
            else if (idx + 1 < num_indexes) {
              next_symbol = symtab->SymbolAtIndex(m_code_indexes[idx + 1]);
              if (next_symbol) {
                func_range.SetByteSize(
                    next_symbol->GetAddressRef().GetOffset() -
                    curr_symbol->GetAddressRef().GetOffset());
              }
            }
 
            FunctionSP func_sp(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
                nullptr, // no return type for a code symbol...
                curr_symbol->GetAddress(), AddressRanges{func_range}));
 
            if (func_sp.get() != nullptr) {
              comp_unit.AddFunction(func_sp);
              ++num_added;
            }
          }
        }
      }
    }
  } else {
    // We assume we
  }
  return num_added;
}
 
size_t SymbolFileSymtab::ParseTypes(CompileUnit &comp_unit) { return 0; }
 
bool SymbolFileSymtab::ParseLineTable(CompileUnit &comp_unit) { return false; }
 
bool SymbolFileSymtab::ParseDebugMacros(CompileUnit &comp_unit) {
  return false;
}
 
bool SymbolFileSymtab::ParseSupportFiles(CompileUnit &comp_unit,
                                         SupportFileList &support_files) {
  return false;
}
 
bool SymbolFileSymtab::ParseImportedModules(
    const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
  return false;
}
 
size_t SymbolFileSymtab::ParseBlocksRecursive(Function &func) { return 0; }
 
size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {
  return 0;
}
 
Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) {
  return nullptr;
}
 
std::optional<SymbolFile::ArrayInfo>
SymbolFileSymtab::GetDynamicArrayInfoForUID(
    lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
  return std::nullopt;
}
 
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_objfile_sp->GetSymtab() == nullptr)
    return 0;
 
  uint32_t resolved_flags = 0;
  if (resolve_scope & eSymbolContextSymbol) {
    sc.symbol = m_objfile_sp->GetSymtab()->FindSymbolContainingFileAddress(
        so_addr.GetFileAddress());
    if (sc.symbol)
      resolved_flags |= eSymbolContextSymbol;
  }
  return resolved_flags;
}