source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

   1 //===-- SymbolFileSymtab.cpp ------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "SymbolFileSymtab.h"
  11 #include "lldb/Core/Module.h"
  12 #include "lldb/Core/PluginManager.h"
  13 #include "lldb/Core/Timer.h"
  14 #include "lldb/Symbol/CompileUnit.h"
  15 #include "lldb/Symbol/Function.h"
  16 #include "lldb/Symbol/ObjectFile.h"
  17 #include "lldb/Symbol/Symbol.h"
  18 #include "lldb/Symbol/SymbolContext.h"
  19 #include "lldb/Symbol/Symtab.h"
  20 #include "lldb/Symbol/TypeList.h"
  21 #include "lldb/Utility/RegularExpression.h"
  22
  23 using namespace lldb;
  24 using namespace lldb_private;
  25
  26 void SymbolFileSymtab::Initialize() {
  27   PluginManager::RegisterPlugin(GetPluginNameStatic(),
  28                                 GetPluginDescriptionStatic(), CreateInstance);
  29 }
  30
  31 void SymbolFileSymtab::Terminate() {
  32   PluginManager::UnregisterPlugin(CreateInstance);
  33 }
  34
  35 lldb_private::ConstString SymbolFileSymtab::GetPluginNameStatic() {
  36   static ConstString g_name("symtab");
  37   return g_name;
  38 }
  39
  40 const char *SymbolFileSymtab::GetPluginDescriptionStatic() {
  41   return "Reads debug symbols from an object file's symbol table.";
  42 }
  43
  44 SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFile *obj_file) {
  45   return new SymbolFileSymtab(obj_file);
  46 }
  47
  48 size_t SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope,
  49                                   uint32_t type_mask,
  50                                   lldb_private::TypeList &type_list) {
  51   return 0;
  52 }
  53
  54 SymbolFileSymtab::SymbolFileSymtab(ObjectFile *obj_file)
  55     : SymbolFile(obj_file), m_source_indexes(), m_func_indexes(),
  56       m_code_indexes(), m_objc_class_name_to_index() {}
  57
  58 SymbolFileSymtab::~SymbolFileSymtab() {}
  59
  60 uint32_t SymbolFileSymtab::CalculateAbilities() {
  61   uint32_t abilities = 0;
  62   if (m_obj_file) {
  63     const Symtab *symtab = m_obj_file->GetSymtab();
  64     if (symtab) {
  65       //----------------------------------------------------------------------
  66       // The snippet of code below will get the indexes the module symbol
  67       // table entries that are code, data, or function related (debug info),
  68       // sort them by value (address) and dump the sorted symbols.
  69       //----------------------------------------------------------------------
  70       if (symtab->AppendSymbolIndexesWithType(eSymbolTypeSourceFile,
  71                                               m_source_indexes)) {
  72         abilities |= CompileUnits;
  73       }
  74
  75       if (symtab->AppendSymbolIndexesWithType(
  76               eSymbolTypeCode, Symtab::eDebugYes, Symtab::eVisibilityAny,
  77               m_func_indexes)) {
  78         symtab->SortSymbolIndexesByValue(m_func_indexes, true);
  79         abilities |= Functions;
  80       }
  81
  82       if (symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugNo,
  83                                               Symtab::eVisibilityAny,
  84                                               m_code_indexes)) {
  85         symtab->SortSymbolIndexesByValue(m_code_indexes, true);
  86         abilities |= Functions;
  87       }
  88
  89       if (symtab->AppendSymbolIndexesWithType(eSymbolTypeData,
  90                                               m_data_indexes)) {
  91         symtab->SortSymbolIndexesByValue(m_data_indexes, true);
  92         abilities |= GlobalVariables;
  93       }
  94
  95       lldb_private::Symtab::IndexCollection objc_class_indexes;
  96       if (symtab->AppendSymbolIndexesWithType(eSymbolTypeObjCClass,
  97                                               objc_class_indexes)) {
  98         symtab->AppendSymbolNamesToMap(objc_class_indexes, true, true,
  99                                        m_objc_class_name_to_index);
 100         m_objc_class_name_to_index.Sort();
 101       }
 102     }
 103   }
 104   return abilities;
 105 }
 106
 107 uint32_t SymbolFileSymtab::GetNumCompileUnits() {
 108   // If we don't have any source file symbols we will just have one compile unit
 109   // for
 110   // the entire object file
 111   if (m_source_indexes.empty())
 112     return 0;
 113
 114   // If we have any source file symbols we will logically organize the object
 115   // symbols
 116   // using these.
 117   return m_source_indexes.size();
 118 }
 119
 120 CompUnitSP SymbolFileSymtab::ParseCompileUnitAtIndex(uint32_t idx) {
 121   CompUnitSP cu_sp;
 122
 123   // If we don't have any source file symbols we will just have one compile unit
 124   // for
 125   // the entire object file
 126   if (idx < m_source_indexes.size()) {
 127     const Symbol *cu_symbol =
 128         m_obj_file->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]);
 129     if (cu_symbol)
 130       cu_sp.reset(new CompileUnit(m_obj_file->GetModule(), NULL,
 131                                   cu_symbol->GetName().AsCString(), 0,
 132                                   eLanguageTypeUnknown, eLazyBoolNo));
 133   }
 134   return cu_sp;
 135 }
 136
 137 lldb::LanguageType
 138 SymbolFileSymtab::ParseCompileUnitLanguage(const SymbolContext &sc) {
 139   return eLanguageTypeUnknown;
 140 }
 141
 142 size_t SymbolFileSymtab::ParseCompileUnitFunctions(const SymbolContext &sc) {
 143   size_t num_added = 0;
 144   // We must at least have a valid compile unit
 145   assert(sc.comp_unit != NULL);
 146   const Symtab *symtab = m_obj_file->GetSymtab();
 147   const Symbol *curr_symbol = NULL;
 148   const Symbol *next_symbol = NULL;
 149   //  const char *prefix = m_obj_file->SymbolPrefix();
 150   //  if (prefix == NULL)
 151   //      prefix == "";
 152   //
 153   //  const uint32_t prefix_len = strlen(prefix);
 154
 155   // If we don't have any source file symbols we will just have one compile unit
 156   // for
 157   // the entire object file
 158   if (m_source_indexes.empty()) {
 159     // The only time we will have a user ID of zero is when we don't have
 160     // and source file symbols and we declare one compile unit for the
 161     // entire object file
 162     if (!m_func_indexes.empty()) {
 163     }
 164
 165     if (!m_code_indexes.empty()) {
 166       //          StreamFile s(stdout);
 167       //          symtab->Dump(&s, m_code_indexes);
 168
 169       uint32_t idx = 0; // Index into the indexes
 170       const uint32_t num_indexes = m_code_indexes.size();
 171       for (idx = 0; idx < num_indexes; ++idx) {
 172         uint32_t symbol_idx = m_code_indexes[idx];
 173         curr_symbol = symtab->SymbolAtIndex(symbol_idx);
 174         if (curr_symbol) {
 175           // Union of all ranges in the function DIE (if the function is
 176           // discontiguous)
 177           AddressRange func_range(curr_symbol->GetAddress(), 0);
 178           if (func_range.GetBaseAddress().IsSectionOffset()) {
 179             uint32_t symbol_size = curr_symbol->GetByteSize();
 180             if (symbol_size != 0 && !curr_symbol->GetSizeIsSibling())
 181               func_range.SetByteSize(symbol_size);
 182             else if (idx + 1 < num_indexes) {
 183               next_symbol = symtab->SymbolAtIndex(m_code_indexes[idx + 1]);
 184               if (next_symbol) {
 185                 func_range.SetByteSize(
 186                     next_symbol->GetAddressRef().GetOffset() -
 187                     curr_symbol->GetAddressRef().GetOffset());
 188               }
 189             }
 190
 191             FunctionSP func_sp(
 192                 new Function(sc.comp_unit,
 193                              symbol_idx,       // UserID is the DIE offset
 194                              LLDB_INVALID_UID, // We don't have any type info
 195                                                // for this function
 196                              curr_symbol->GetMangled(), // Linker/mangled name
 197                              NULL, // no return type for a code symbol...
 198                              func_range)); // first address range
 199
 200             if (func_sp.get() != NULL) {
 201               sc.comp_unit->AddFunction(func_sp);
 202               ++num_added;
 203             }
 204           }
 205         }
 206       }
 207     }
 208   } else {
 209     // We assume we
 210   }
 211   return num_added;
 212 }
 213
 214 bool SymbolFileSymtab::ParseCompileUnitLineTable(const SymbolContext &sc) {
 215   return false;
 216 }
 217
 218 bool SymbolFileSymtab::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
 219   return false;
 220 }
 221
 222 bool SymbolFileSymtab::ParseCompileUnitSupportFiles(
 223     const SymbolContext &sc, FileSpecList &support_files) {
 224   return false;
 225 }
 226
 227 bool SymbolFileSymtab::ParseImportedModules(
 228     const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
 229   return false;
 230 }
 231
 232 size_t SymbolFileSymtab::ParseFunctionBlocks(const SymbolContext &sc) {
 233   return 0;
 234 }
 235
 236 size_t SymbolFileSymtab::ParseTypes(const SymbolContext &sc) { return 0; }
 237
 238 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {
 239   return 0;
 240 }
 241
 242 Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) {
 243   return NULL;
 244 }
 245
 246 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) {
 247   return false;
 248 }
 249
 250 uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr,
 251                                                 uint32_t resolve_scope,
 252                                                 SymbolContext &sc) {
 253   if (m_obj_file->GetSymtab() == NULL)
 254     return 0;
 255
 256   uint32_t resolved_flags = 0;
 257   if (resolve_scope & eSymbolContextSymbol) {
 258     sc.symbol = m_obj_file->GetSymtab()->FindSymbolContainingFileAddress(
 259         so_addr.GetFileAddress());
 260     if (sc.symbol)
 261       resolved_flags |= eSymbolContextSymbol;
 262   }
 263   return resolved_flags;
 264 }
 265
 266 //------------------------------------------------------------------
 267 // PluginInterface protocol
 268 //------------------------------------------------------------------
 269 lldb_private::ConstString SymbolFileSymtab::GetPluginName() {
 270   return GetPluginNameStatic();
 271 }
 272
 273 uint32_t SymbolFileSymtab::GetPluginVersion() { return 1; }