intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-13 19:08:21 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
9df05fbb7f651ee824c80161db5833bf412f9997
llvm/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
Sean Callanan 9df05fbb7f Extended function lookup to allow the user to 
indicate whether inline functions are desired.
This allows the expression parser, for instance,
to filter out inlined functions when looking for
functions it can call.

llvm-svn: 150279
2012-02-10 22:52:19 +00:00

1192 lines
47 KiB
C++
Raw Blame History

//===-- SymbolFileDWARFDebugMap.cpp ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "SymbolFileDWARFDebugMap.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Core/Timer.h"
#include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/VariableList.h"
#include "SymbolFileDWARF.h"
using namespace lldb;
using namespace lldb_private;
void
SymbolFileDWARFDebugMap::Initialize()
{
PluginManager::RegisterPlugin (GetPluginNameStatic(),
GetPluginDescriptionStatic(),
CreateInstance);
}
void
SymbolFileDWARFDebugMap::Terminate()
{
PluginManager::UnregisterPlugin (CreateInstance);
}
const char *
SymbolFileDWARFDebugMap::GetPluginNameStatic()
{
return "dwarf-debugmap";
}
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);
}
SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap (ObjectFile* ofile) :
SymbolFile(ofile),
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()
{
// Install our external AST source callbacks so we can complete Clang types.
llvm::OwningPtr<clang::ExternalASTSource> ast_source_ap (
new ClangExternalASTSourceCallbacks (SymbolFileDWARFDebugMap::CompleteTagDecl,
SymbolFileDWARFDebugMap::CompleteObjCInterfaceDecl,
NULL,
SymbolFileDWARFDebugMap::LayoutRecordType,
this));
GetClangASTContext().SetExternalSource (ast_source_ap);
}
void
SymbolFileDWARFDebugMap::InitOSO ()
{
if (m_flags.test(kHaveInitializedOSOs))
return;
m_flags.set(kHaveInitializedOSOs);
// 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();
if (symtab)
{
std::vector<uint32_t> oso_indexes;
// StreamFile s(stdout);
// symtab->Dump(&s, NULL, eSortOrderNone);
// 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 only object file symbols with the flags value as follows:
// bits 23:16 == 0x66 (N_OSO)
// bits 15: 0 == 0x0001 (specifies this is a debug map object file)
const uint32_t k_oso_symbol_flags_value = 0x660001u;
const uint32_t oso_index_count = symtab->AppendSymbolIndexesWithTypeAndFlagsValue(eSymbolTypeObjectFile, k_oso_symbol_flags_value, oso_indexes);
if (oso_index_count > 0)
{
symtab->AppendSymbolIndexesWithType (eSymbolTypeCode, Symtab::eDebugYes, Symtab::eVisibilityAny, m_func_indexes);
symtab->AppendSymbolIndexesWithType (eSymbolTypeData, Symtab::eDebugYes, Symtab::eVisibilityAny, m_glob_indexes);
symtab->SortSymbolIndexesByValue(m_func_indexes, true);
symtab->SortSymbolIndexesByValue(m_glob_indexes, true);
m_compile_unit_infos.resize(oso_index_count);
// s.Printf("%s N_OSO symbols:\n", __PRETTY_FUNCTION__);
// symtab->Dump(&s, oso_indexes);
for (uint32_t i=0; i<oso_index_count; ++i)
{
m_compile_unit_infos[i].so_symbol = symtab->SymbolAtIndex(oso_indexes[i] - 1);
if (m_compile_unit_infos[i].so_symbol->GetSiblingIndex() == 0)
m_compile_unit_infos[i].so_symbol = symtab->SymbolAtIndex(oso_indexes[i] - 2);
m_compile_unit_infos[i].oso_symbol = symtab->SymbolAtIndex(oso_indexes[i]);
uint32_t sibling_idx = m_compile_unit_infos[i].so_symbol->GetSiblingIndex();
assert (sibling_idx != 0);
assert (sibling_idx > i + 1);
m_compile_unit_infos[i].last_symbol = symtab->SymbolAtIndex (sibling_idx - 1);
m_compile_unit_infos[i].first_symbol_index = symtab->GetIndexForSymbol(m_compile_unit_infos[i].so_symbol);
m_compile_unit_infos[i].last_symbol_index = symtab->GetIndexForSymbol(m_compile_unit_infos[i].last_symbol);
}
}
}
}
Module *
SymbolFileDWARFDebugMap::GetModuleByOSOIndex (uint32_t oso_idx)
{
const uint32_t cu_count = GetNumCompileUnits();
if (oso_idx < cu_count)
return GetModuleByCompUnitInfo (&m_compile_unit_infos[oso_idx]);
return NULL;
}
Module *
SymbolFileDWARFDebugMap::GetModuleByCompUnitInfo (CompileUnitInfo *comp_unit_info)
{
if (comp_unit_info->oso_module_sp.get() == NULL)
{
Symbol *oso_symbol = comp_unit_info->oso_symbol;
if (oso_symbol)
{
FileSpec oso_file_spec(oso_symbol->GetMangled().GetName().AsCString(), true);
// Always create a new module for .o files. Why? Because we
// use the debug 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.
comp_unit_info->oso_module_sp.reset (new Module (oso_file_spec,
m_obj_file->GetModule()->GetArchitecture(),
NULL,
0));
}
}
return comp_unit_info->oso_module_sp.get();
}
bool
SymbolFileDWARFDebugMap::GetFileSpecForSO (uint32_t oso_idx, FileSpec &file_spec)
{
if (oso_idx < m_compile_unit_infos.size())
{
if (!m_compile_unit_infos[oso_idx].so_file)
{
if (m_compile_unit_infos[oso_idx].so_symbol == NULL)
return false;
std::string so_path (m_compile_unit_infos[oso_idx].so_symbol->GetMangled().GetName().AsCString());
if (m_compile_unit_infos[oso_idx].so_symbol[1].GetType() == eSymbolTypeSourceFile)
so_path += m_compile_unit_infos[oso_idx].so_symbol[1].GetMangled().GetName().AsCString();
m_compile_unit_infos[oso_idx].so_file.SetFile(so_path.c_str(), true);
}
file_spec = m_compile_unit_infos[oso_idx].so_file;
return true;
}
return false;
}
ObjectFile *
SymbolFileDWARFDebugMap::GetObjectFileByOSOIndex (uint32_t oso_idx)
{
Module *oso_module = GetModuleByOSOIndex (oso_idx);
if (oso_module)
return oso_module->GetObjectFile();
return NULL;
}
SymbolFileDWARF *
SymbolFileDWARFDebugMap::GetSymbolFile (const SymbolContext& sc)
{
CompileUnitInfo *comp_unit_info = GetCompUnitInfo (sc);
if (comp_unit_info)
return GetSymbolFileByCompUnitInfo (comp_unit_info);
return NULL;
}
ObjectFile *
SymbolFileDWARFDebugMap::GetObjectFileByCompUnitInfo (CompileUnitInfo *comp_unit_info)
{
Module *oso_module = GetModuleByCompUnitInfo (comp_unit_info);
if (oso_module)
return oso_module->GetObjectFile();
return NULL;
}
uint32_t
SymbolFileDWARFDebugMap::GetCompUnitInfoIndex (const CompileUnitInfo *comp_unit_info)
{
if (!m_compile_unit_infos.empty())
{
const CompileUnitInfo *first_comp_unit_info = &m_compile_unit_infos.front();
const CompileUnitInfo *last_comp_unit_info = &m_compile_unit_infos.back();
if (first_comp_unit_info <= comp_unit_info && comp_unit_info <= last_comp_unit_info)
return comp_unit_info - first_comp_unit_info;
}
return UINT32_MAX;
}
SymbolFileDWARF *
SymbolFileDWARFDebugMap::GetSymbolFileByOSOIndex (uint32_t oso_idx)
{
if (oso_idx < m_compile_unit_infos.size())
return GetSymbolFileByCompUnitInfo (&m_compile_unit_infos[oso_idx]);
return NULL;
}
SymbolFileDWARF *
SymbolFileDWARFDebugMap::GetSymbolFileByCompUnitInfo (CompileUnitInfo *comp_unit_info)
{
if (comp_unit_info->oso_symbol_vendor == NULL)
{
ObjectFile *oso_objfile = GetObjectFileByCompUnitInfo (comp_unit_info);
if (oso_objfile)
{
comp_unit_info->oso_symbol_vendor = oso_objfile->GetModule()->GetSymbolVendor();
// SymbolFileDWARF *oso_dwarf = new SymbolFileDWARF(oso_objfile);
// comp_unit_info->oso_dwarf_sp.reset (oso_dwarf);
if (comp_unit_info->oso_symbol_vendor)
{
// Set a a pointer to this class to set our OSO DWARF file know
// that the DWARF is being used along with a debug map and that
// it will have the remapped sections that we do below.
SymbolFileDWARF *oso_symfile = (SymbolFileDWARF *)comp_unit_info->oso_symbol_vendor->GetSymbolFile();
oso_symfile->SetDebugMapSymfile(this);
// Set the ID of the symbol file DWARF to the index of the OSO
// shifted left by 32 bits to provide a unique prefix for any
// UserID's that get created in the symbol file.
oso_symfile->SetID (((uint64_t)GetCompUnitInfoIndex(comp_unit_info) + 1ull) << 32ull);
comp_unit_info->debug_map_sections_sp.reset(new SectionList);
Symtab *exe_symtab = m_obj_file->GetSymtab();
Module *oso_module = oso_objfile->GetModule();
Symtab *oso_symtab = oso_objfile->GetSymtab();
//#define DEBUG_OSO_DMAP // Do not check in with this defined...
#if defined(DEBUG_OSO_DMAP)
StreamFile s(stdout);
s << "OSO symtab:\n";
oso_symtab->Dump(&s, NULL);
s << "OSO sections before:\n";
oso_objfile->GetSectionList()->Dump(&s, NULL, true);
#endif
///const uint32_t fun_resolve_flags = SymbolContext::Module | eSymbolContextCompUnit | eSymbolContextFunction;
//SectionList *oso_sections = oso_objfile->Sections();
// Now we need to make sections that map from zero based object
// file addresses to where things eneded up in the main executable.
uint32_t oso_start_idx = exe_symtab->GetIndexForSymbol (comp_unit_info->oso_symbol);
assert (oso_start_idx != UINT32_MAX);
oso_start_idx += 1;
const uint32_t oso_end_idx = comp_unit_info->so_symbol->GetSiblingIndex();
uint32_t sect_id = 0x10000;
for (uint32_t idx = oso_start_idx; idx < oso_end_idx; ++idx)
{
Symbol *exe_symbol = exe_symtab->SymbolAtIndex(idx);
if (exe_symbol)
{
if (exe_symbol->IsDebug() == false)
continue;
switch (exe_symbol->GetType())
{
default:
break;
case eSymbolTypeCode:
{
// For each N_FUN, or function that we run into in the debug map
// we make a new section that we add to the sections found in the
// .o file. This new section has the file address set to what the
// addresses are in the .o file, and the load address is adjusted
// to match where it ended up in the final executable! We do this
// before we parse any dwarf info so that when it goes get parsed
// all section/offset addresses that get registered will resolve
// correctly to the new addresses in the main executable.
// First we find the original symbol in the .o file's symbol table
Symbol *oso_fun_symbol = oso_symtab->FindFirstSymbolWithNameAndType(exe_symbol->GetMangled().GetName(Mangled::ePreferMangled), eSymbolTypeCode, Symtab::eDebugNo, Symtab::eVisibilityAny);
if (oso_fun_symbol)
{
// If we found the symbol, then we
Section* exe_fun_section = const_cast<Section *>(exe_symbol->GetAddressRangePtr()->GetBaseAddress().GetSection());
Section* oso_fun_section = const_cast<Section *>(oso_fun_symbol->GetAddressRangePtr()->GetBaseAddress().GetSection());
if (oso_fun_section)
{
// Now we create a section that we will add as a child of the
// section in which the .o symbol (the N_FUN) exists.
// We use the exe_symbol size because the one in the .o file
// will just be a symbol with no size, and the exe_symbol
// size will reflect any size changes (ppc has been known to
// shrink function sizes when it gets rid of jump islands that
// aren't needed anymore).
SectionSP oso_fun_section_sp (new Section (const_cast<Section *>(oso_fun_symbol->GetAddressRangePtr()->GetBaseAddress().GetSection()),
oso_module, // Module (the .o file)
sect_id++, // Section ID starts at 0x10000 and increments so the section IDs don't overlap with the standard mach IDs
exe_symbol->GetMangled().GetName(Mangled::ePreferMangled), // Name the section the same as the symbol for which is was generated!
eSectionTypeDebug,
oso_fun_symbol->GetAddressRangePtr()->GetBaseAddress().GetOffset(), // File VM address offset in the current section
exe_symbol->GetByteSize(), // File size (we need the size from the executable)
0, 0, 0));
oso_fun_section_sp->SetLinkedLocation (exe_fun_section,
exe_symbol->GetValue().GetFileAddress() - exe_fun_section->GetFileAddress());
oso_fun_section->GetChildren().AddSection(oso_fun_section_sp);
comp_unit_info->debug_map_sections_sp->AddSection(oso_fun_section_sp);
}
}
}
break;
case eSymbolTypeData:
{
// For each N_GSYM we remap the address for the global by making
// a new section that we add to the sections found in the .o file.
// This new section has the file address set to what the
// addresses are in the .o file, and the load address is adjusted
// to match where it ended up in the final executable! We do this
// before we parse any dwarf info so that when it goes get parsed
// all section/offset addresses that get registered will resolve
// correctly to the new addresses in the main executable. We
// initially set the section size to be 1 byte, but will need to
// fix up these addresses further after all globals have been
// parsed to span the gaps, or we can find the global variable
// sizes from the DWARF info as we are parsing.
// Next we find the non-stab entry that corresponds to the N_GSYM in the .o file
Symbol *oso_gsym_symbol = oso_symtab->FindFirstSymbolWithNameAndType (exe_symbol->GetMangled().GetName(),
eSymbolTypeData,
Symtab::eDebugNo,
Symtab::eVisibilityAny);
if (exe_symbol && oso_gsym_symbol && exe_symbol->GetAddressRangePtr() && oso_gsym_symbol->GetAddressRangePtr())
{
// If we found the symbol, then we
Section* exe_gsym_section = const_cast<Section *>(exe_symbol->GetAddressRangePtr()->GetBaseAddress().GetSection());
Section* oso_gsym_section = const_cast<Section *>(oso_gsym_symbol->GetAddressRangePtr()->GetBaseAddress().GetSection());
if (oso_gsym_section)
{
SectionSP oso_gsym_section_sp (new Section (const_cast<Section *>(oso_gsym_symbol->GetAddressRangePtr()->GetBaseAddress().GetSection()),
oso_module, // Module (the .o file)
sect_id++, // Section ID starts at 0x10000 and increments so the section IDs don't overlap with the standard mach IDs
exe_symbol->GetMangled().GetName(Mangled::ePreferMangled), // Name the section the same as the symbol for which is was generated!
eSectionTypeDebug,
oso_gsym_symbol->GetAddressRangePtr()->GetBaseAddress().GetOffset(), // File VM address offset in the current section
1, // We don't know the size of the global, just do the main address for now.
0, 0, 0));
oso_gsym_section_sp->SetLinkedLocation (exe_gsym_section,
exe_symbol->GetValue().GetFileAddress() - exe_gsym_section->GetFileAddress());
oso_gsym_section->GetChildren().AddSection(oso_gsym_section_sp);
comp_unit_info->debug_map_sections_sp->AddSection(oso_gsym_section_sp);
}
}
}
break;
}
}
}
#if defined(DEBUG_OSO_DMAP)
s << "OSO sections after:\n";
oso_objfile->GetSectionList()->Dump(&s, NULL, true);
#endif
}
}
}
if (comp_unit_info->oso_symbol_vendor)
return (SymbolFileDWARF *)comp_unit_info->oso_symbol_vendor->GetSymbolFile();
return NULL;
}
uint32_t
SymbolFileDWARFDebugMap::CalculateAbilities ()
{
// 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.
const uint32_t oso_index_count = GetNumCompileUnits();
if (oso_index_count > 0)
{
const uint32_t dwarf_abilities = SymbolFile::CompileUnits |
SymbolFile::Functions |
SymbolFile::Blocks |
SymbolFile::GlobalVariables |
SymbolFile::LocalVariables |
SymbolFile::VariableTypes |
SymbolFile::LineTables;
for (uint32_t oso_idx=0; oso_idx<oso_index_count; ++oso_idx)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
if (oso_dwarf)
{
uint32_t oso_abilities = oso_dwarf->GetAbilities();
if ((oso_abilities & dwarf_abilities) == dwarf_abilities)
return oso_abilities;
}
}
}
return 0;
}
uint32_t
SymbolFileDWARFDebugMap::GetNumCompileUnits()
{
InitOSO ();
return m_compile_unit_infos.size();
}
CompUnitSP
SymbolFileDWARFDebugMap::ParseCompileUnitAtIndex(uint32_t cu_idx)
{
CompUnitSP comp_unit_sp;
const uint32_t cu_count = GetNumCompileUnits();
if (cu_idx < cu_count)
{
if (m_compile_unit_infos[cu_idx].oso_compile_unit_sp.get() == NULL)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (cu_idx);
if (oso_dwarf)
{
// There is only one compile unit for N_OSO entry right now, so
// it will always exist at index zero.
m_compile_unit_infos[cu_idx].oso_compile_unit_sp = m_compile_unit_infos[cu_idx].oso_symbol_vendor->GetCompileUnitAtIndex (0);
}
if (m_compile_unit_infos[cu_idx].oso_compile_unit_sp.get() == NULL)
{
// We weren't able to get the DWARF for this N_OSO entry (the
// .o file may be missing or not at the specified path), make
// one up as best we can from the debug map. We set the uid
// of the compile unit to the symbol index with the MSBit set
// so that it doesn't collide with any uid values from the DWARF
Symbol *so_symbol = m_compile_unit_infos[cu_idx].so_symbol;
if (so_symbol)
{
m_compile_unit_infos[cu_idx].oso_compile_unit_sp.reset(new CompileUnit (m_obj_file->GetModule(),
NULL,
so_symbol->GetMangled().GetName().AsCString(),
cu_idx,
eLanguageTypeUnknown));
// Let our symbol vendor know about this compile unit
m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex (m_compile_unit_infos[cu_idx].oso_compile_unit_sp,
cu_idx);
}
}
}
comp_unit_sp = m_compile_unit_infos[cu_idx].oso_compile_unit_sp;
}
return comp_unit_sp;
}
SymbolFileDWARFDebugMap::CompileUnitInfo *
SymbolFileDWARFDebugMap::GetCompUnitInfo (const SymbolContext& sc)
{
const uint32_t cu_count = GetNumCompileUnits();
for (uint32_t i=0; i<cu_count; ++i)
{
if (sc.comp_unit == m_compile_unit_infos[i].oso_compile_unit_sp.get())
return &m_compile_unit_infos[i];
}
return NULL;
}
size_t
SymbolFileDWARFDebugMap::ParseCompileUnitFunctions (const SymbolContext& sc)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
if (oso_dwarf)
return oso_dwarf->ParseCompileUnitFunctions (sc);
return 0;
}
bool
SymbolFileDWARFDebugMap::ParseCompileUnitLineTable (const SymbolContext& sc)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
if (oso_dwarf)
return oso_dwarf->ParseCompileUnitLineTable (sc);
return false;
}
bool
SymbolFileDWARFDebugMap::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList &support_files)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
if (oso_dwarf)
return oso_dwarf->ParseCompileUnitSupportFiles (sc, support_files);
return false;
}
size_t
SymbolFileDWARFDebugMap::ParseFunctionBlocks (const SymbolContext& sc)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
if (oso_dwarf)
return oso_dwarf->ParseFunctionBlocks (sc);
return 0;
}
size_t
SymbolFileDWARFDebugMap::ParseTypes (const SymbolContext& sc)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
if (oso_dwarf)
return oso_dwarf->ParseTypes (sc);
return 0;
}
size_t
SymbolFileDWARFDebugMap::ParseVariablesForContext (const SymbolContext& sc)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
if (oso_dwarf)
return oso_dwarf->ParseTypes (sc);
return 0;
}
Type*
SymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid)
{
const uint64_t oso_idx = GetOSOIndexFromUserID (type_uid);
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
if (oso_dwarf)
oso_dwarf->ResolveTypeUID (type_uid);
return NULL;
}
lldb::clang_type_t
SymbolFileDWARFDebugMap::ResolveClangOpaqueTypeDefinition (lldb::clang_type_t clang_type)
{
// We have a struct/union/class/enum that needs to be fully resolved.
return NULL;
}
uint32_t
SymbolFileDWARFDebugMap::ResolveSymbolContext (const Address& exe_so_addr, uint32_t resolve_scope, SymbolContext& sc)
{
uint32_t resolved_flags = 0;
Symtab* symtab = m_obj_file->GetSymtab();
if (symtab)
{
const addr_t exe_file_addr = exe_so_addr.GetFileAddress();
sc.symbol = symtab->FindSymbolContainingFileAddress (exe_file_addr, &m_func_indexes[0], m_func_indexes.size());
if (sc.symbol != NULL)
{
resolved_flags |= eSymbolContextSymbol;
uint32_t oso_idx = 0;
CompileUnitInfo* comp_unit_info = GetCompileUnitInfoForSymbolWithID (sc.symbol->GetID(), &oso_idx);
if (comp_unit_info)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
ObjectFile *oso_objfile = GetObjectFileByOSOIndex (oso_idx);
if (oso_dwarf && oso_objfile)
{
SectionList *oso_section_list = oso_objfile->GetSectionList();
SectionSP oso_symbol_section_sp (oso_section_list->FindSectionContainingLinkedFileAddress (exe_file_addr, UINT32_MAX));
if (oso_symbol_section_sp)
{
const addr_t linked_file_addr = oso_symbol_section_sp->GetLinkedFileAddress();
Address oso_so_addr (oso_symbol_section_sp.get(), exe_file_addr - linked_file_addr);
if (oso_so_addr.IsSectionOffset())
resolved_flags |= oso_dwarf->ResolveSymbolContext (oso_so_addr, resolve_scope, sc);
}
}
}
}
}
return resolved_flags;
}
uint32_t
SymbolFileDWARFDebugMap::ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
{
uint32_t initial = sc_list.GetSize();
const uint32_t cu_count = GetNumCompileUnits();
FileSpec so_file_spec;
for (uint32_t i=0; i<cu_count; ++i)
{
if (GetFileSpecForSO (i, so_file_spec))
{
// By passing false to the comparison we will be able to match
// and files given a filename only. If both file_spec and
// so_file_spec have directories, we will still do a full match.
if (FileSpec::Compare (file_spec, so_file_spec, false) == 0)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (i);
if (oso_dwarf)
oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, sc_list);
}
}
}
return sc_list.GetSize() - initial;
}
uint32_t
SymbolFileDWARFDebugMap::PrivateFindGlobalVariables
(
const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
const std::vector<uint32_t> &indexes, // Indexes into the symbol table that match "name"
uint32_t max_matches,
VariableList& variables
)
{
const uint32_t original_size = variables.GetSize();
const size_t match_count = indexes.size();
for (size_t i=0; i<match_count; ++i)
{
uint32_t oso_idx;
CompileUnitInfo* comp_unit_info = GetCompileUnitInfoForSymbolWithIndex (indexes[i], &oso_idx);
if (comp_unit_info)
{
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
if (oso_dwarf)
{
if (oso_dwarf->FindGlobalVariables(name, namespace_decl, true, max_matches, variables))
if (variables.GetSize() > max_matches)
break;
}
}
}
return variables.GetSize() - original_size;
}
uint32_t
SymbolFileDWARFDebugMap::FindGlobalVariables (const ConstString &name, const ClangNamespaceDecl *namespace_decl, bool append, uint32_t max_matches, VariableList& variables)
{
// If we aren't appending the results to this list, then clear the list
if (!append)
variables.Clear();
// Remember how many variables are in the list before we search in case
// we are appending the results to a variable list.
const uint32_t original_size = variables.GetSize();
uint32_t total_matches = 0;
SymbolFileDWARF *oso_dwarf;
for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
{
const uint32_t oso_matches = oso_dwarf->FindGlobalVariables (name,
namespace_decl,
true,
max_matches,
variables);
if (oso_matches > 0)
{
total_matches += oso_matches;
// Are we getting all matches?
if (max_matches == UINT32_MAX)
continue; // Yep, continue getting everything
// If we have found enough matches, lets get out
if (max_matches >= total_matches)
break;
// Update the max matches for any subsequent calls to find globals
// in any other object files with DWARF
max_matches -= oso_matches;
}
}
// Return the number of variable that were appended to the list
return variables.GetSize() - original_size;
}
uint32_t
SymbolFileDWARFDebugMap::FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables)
{
// If we aren't appending the results to this list, then clear the list
if (!append)
variables.Clear();
// Remember how many variables are in the list before we search in case
// we are appending the results to a variable list.
const uint32_t original_size = variables.GetSize();
uint32_t total_matches = 0;
SymbolFileDWARF *oso_dwarf;
for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
{
const uint32_t oso_matches = oso_dwarf->FindGlobalVariables (regex,
true,
max_matches,
variables);
if (oso_matches > 0)
{
total_matches += oso_matches;
// Are we getting all matches?
if (max_matches == UINT32_MAX)
continue; // Yep, continue getting everything
// If we have found enough matches, lets get out
if (max_matches >= total_matches)
break;
// Update the max matches for any subsequent calls to find globals
// in any other object files with DWARF
max_matches -= oso_matches;
}
}
// Return the number of variable that were appended to the list
return variables.GetSize() - original_size;
}
int
SymbolFileDWARFDebugMap::SymbolContainsSymbolWithIndex (uint32_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info)
{
const uint32_t symbol_idx = *symbol_idx_ptr;
if (symbol_idx < comp_unit_info->first_symbol_index)
return -1;
if (symbol_idx <= comp_unit_info->last_symbol_index)
return 0;
return 1;
}
int
SymbolFileDWARFDebugMap::SymbolContainsSymbolWithID (user_id_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info)
{
const user_id_t symbol_id = *symbol_idx_ptr;
if (symbol_id < comp_unit_info->so_symbol->GetID())
return -1;
if (symbol_id <= comp_unit_info->last_symbol->GetID())
return 0;
return 1;
}
SymbolFileDWARFDebugMap::CompileUnitInfo*
SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithIndex (uint32_t symbol_idx, uint32_t *oso_idx_ptr)
{
const uint32_t oso_index_count = m_compile_unit_infos.size();
CompileUnitInfo *comp_unit_info = NULL;
if (oso_index_count)
{
comp_unit_info = (CompileUnitInfo*)bsearch(&symbol_idx,
&m_compile_unit_infos[0],
m_compile_unit_infos.size(),
sizeof(CompileUnitInfo),
(ComparisonFunction)SymbolContainsSymbolWithIndex);
}
if (oso_idx_ptr)
{
if (comp_unit_info != NULL)
*oso_idx_ptr = comp_unit_info - &m_compile_unit_infos[0];
else
*oso_idx_ptr = UINT32_MAX;
}
return comp_unit_info;
}
SymbolFileDWARFDebugMap::CompileUnitInfo*
SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithID (user_id_t symbol_id, uint32_t *oso_idx_ptr)
{
const uint32_t oso_index_count = m_compile_unit_infos.size();
CompileUnitInfo *comp_unit_info = NULL;
if (oso_index_count)
{
comp_unit_info = (CompileUnitInfo*)::bsearch (&symbol_id,
&m_compile_unit_infos[0],
m_compile_unit_infos.size(),
sizeof(CompileUnitInfo),
(ComparisonFunction)SymbolContainsSymbolWithID);
}
if (oso_idx_ptr)
{
if (comp_unit_info != NULL)
*oso_idx_ptr = comp_unit_info - &m_compile_unit_infos[0];
else
*oso_idx_ptr = UINT32_MAX;
}
return comp_unit_info;
}
static void
RemoveFunctionsWithModuleNotEqualTo (Module *module, SymbolContextList &sc_list, uint32_t start_idx)
{
// We found functions in .o files. Not all functions in the .o files
// will have made it into the final output file. The ones that did
// make it into the final output file will have a section whose module
// matches the module from the ObjectFile for this SymbolFile. When
// the modules don't match, then we have something that was in a
// .o file, but doesn't map to anything in the final executable.
uint32_t i=start_idx;
while (i < sc_list.GetSize())
{
SymbolContext sc;
sc_list.GetContextAtIndex(i, sc);
if (sc.function)
{
const Section *section = sc.function->GetAddressRange().GetBaseAddress().GetSection();
if (section->GetModule() != module)
{
sc_list.RemoveContextAtIndex(i);
continue;
}
}
++i;
}
}
uint32_t
SymbolFileDWARFDebugMap::FindFunctions(const ConstString &name, const ClangNamespaceDecl *namespace_decl, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list)
{
Timer scoped_timer (__PRETTY_FUNCTION__,
"SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
name.GetCString());
uint32_t initial_size = 0;
if (append)
initial_size = sc_list.GetSize();
else
sc_list.Clear();
uint32_t oso_idx = 0;
SymbolFileDWARF *oso_dwarf;
while ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx++)) != NULL)
{
uint32_t sc_idx = sc_list.GetSize();
if (oso_dwarf->FindFunctions(name, namespace_decl, name_type_mask, include_inlines, true, sc_list))
{
RemoveFunctionsWithModuleNotEqualTo (m_obj_file->GetModule(), sc_list, sc_idx);
}
}
return sc_list.GetSize() - initial_size;
}
uint32_t
SymbolFileDWARFDebugMap::FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
{
Timer scoped_timer (__PRETTY_FUNCTION__,
"SymbolFileDWARFDebugMap::FindFunctions (regex = '%s')",
regex.GetText());
uint32_t initial_size = 0;
if (append)
initial_size = sc_list.GetSize();
else
sc_list.Clear();
uint32_t oso_idx = 0;
SymbolFileDWARF *oso_dwarf;
while ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx++)) != NULL)
{
uint32_t sc_idx = sc_list.GetSize();
if (oso_dwarf->FindFunctions(regex, include_inlines, true, sc_list))
{
RemoveFunctionsWithModuleNotEqualTo (m_obj_file->GetModule(), sc_list, sc_idx);
}
}
return sc_list.GetSize() - initial_size;
}
TypeSP
SymbolFileDWARFDebugMap::FindDefinitionTypeForDIE (DWARFCompileUnit* cu,
const DWARFDebugInfoEntry *die,
const ConstString &type_name)
{
TypeSP type_sp;
SymbolFileDWARF *oso_dwarf;
for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
{
type_sp = oso_dwarf->FindDefinitionTypeForDIE (cu, die, type_name);
if (type_sp)
break;
}
return type_sp;
}
bool
SymbolFileDWARFDebugMap::Supports_DW_AT_APPLE_objc_complete_type (SymbolFileDWARF *skip_dwarf_oso)
{
if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate)
{
m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
SymbolFileDWARF *oso_dwarf;
for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
{
if (skip_dwarf_oso != oso_dwarf && oso_dwarf->Supports_DW_AT_APPLE_objc_complete_type(NULL))
{
m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
break;
}
}
}
return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
}
TypeSP
SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE (const DWARFDebugInfoEntry *die,
const ConstString &type_name,
bool must_be_implementation)
{
TypeSP type_sp;
SymbolFileDWARF *oso_dwarf;
for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
{
type_sp = oso_dwarf->FindCompleteObjCDefinitionTypeForDIE (die, type_name, must_be_implementation);
if (type_sp)
break;
}
return type_sp;
}
uint32_t
SymbolFileDWARFDebugMap::FindTypes
(
const SymbolContext& sc,
const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
bool append,
uint32_t max_matches,
TypeList& types
)
{
if (!append)
types.Clear();
const uint32_t initial_types_size = types.GetSize();
SymbolFileDWARF *oso_dwarf;
if (sc.comp_unit)
{
oso_dwarf = GetSymbolFile (sc);
if (oso_dwarf)
return oso_dwarf->FindTypes (sc, name, namespace_decl, append, max_matches, types);
}
else
{
uint32_t oso_idx = 0;
while ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx++)) != NULL)
oso_dwarf->FindTypes (sc, name, namespace_decl, append, max_matches, types);
}
return types.GetSize() - initial_types_size;
}
//
//uint32_t
//SymbolFileDWARFDebugMap::FindTypes (const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, Type::Encoding encoding, lldb::user_id_t udt_uid, TypeList& types)
//{
// SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
// if (oso_dwarf)
// return oso_dwarf->FindTypes (sc, regex, append, max_matches, encoding, udt_uid, types);
// return 0;
//}
ClangNamespaceDecl
SymbolFileDWARFDebugMap::FindNamespace (const lldb_private::SymbolContext& sc,
const lldb_private::ConstString &name,
const ClangNamespaceDecl *parent_namespace_decl)
{
ClangNamespaceDecl matching_namespace;
SymbolFileDWARF *oso_dwarf;
if (sc.comp_unit)
{
oso_dwarf = GetSymbolFile (sc);
if (oso_dwarf)
matching_namespace = oso_dwarf->FindNamespace (sc, name, parent_namespace_decl);
}
else
{
for (uint32_t oso_idx = 0;
((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL);
++oso_idx)
{
matching_namespace = oso_dwarf->FindNamespace (sc, name, parent_namespace_decl);
if (matching_namespace)
break;
}
}
return matching_namespace;
}
//------------------------------------------------------------------
// PluginInterface protocol
//------------------------------------------------------------------
const char *
SymbolFileDWARFDebugMap::GetPluginName()
{
return "SymbolFileDWARFDebugMap";
}
const char *
SymbolFileDWARFDebugMap::GetShortPluginName()
{
return GetPluginNameStatic();
}
uint32_t
SymbolFileDWARFDebugMap::GetPluginVersion()
{
return 1;
}
void
SymbolFileDWARFDebugMap::SetCompileUnit (SymbolFileDWARF *oso_dwarf, const CompUnitSP &cu_sp)
{
const uint32_t cu_count = GetNumCompileUnits();
for (uint32_t i=0; i<cu_count; ++i)
{
if (m_compile_unit_infos[i].oso_symbol_vendor &&
m_compile_unit_infos[i].oso_symbol_vendor->GetSymbolFile() == oso_dwarf)
{
if (m_compile_unit_infos[i].oso_compile_unit_sp)
{
assert (m_compile_unit_infos[i].oso_compile_unit_sp.get() == cu_sp.get());
}
else
{
m_compile_unit_infos[i].oso_compile_unit_sp = cu_sp;
}
}
}
}
void
SymbolFileDWARFDebugMap::CompleteTagDecl (void *baton, clang::TagDecl *decl)
{
SymbolFileDWARFDebugMap *symbol_file_dwarf = (SymbolFileDWARFDebugMap *)baton;
clang_type_t clang_type = symbol_file_dwarf->GetClangASTContext().GetTypeForDecl (decl);
if (clang_type)
{
SymbolFileDWARF *oso_dwarf;
for (uint32_t oso_idx = 0; ((oso_dwarf = symbol_file_dwarf->GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
{
if (oso_dwarf->HasForwardDeclForClangType (clang_type))
{
oso_dwarf->ResolveClangOpaqueTypeDefinition (clang_type);
return;
}
}
}
}
void
SymbolFileDWARFDebugMap::CompleteObjCInterfaceDecl (void *baton, clang::ObjCInterfaceDecl *decl)
{
SymbolFileDWARFDebugMap *symbol_file_dwarf = (SymbolFileDWARFDebugMap *)baton;
clang_type_t clang_type = symbol_file_dwarf->GetClangASTContext().GetTypeForDecl (decl);
if (clang_type)
{
SymbolFileDWARF *oso_dwarf;
for (uint32_t oso_idx = 0; ((oso_dwarf = symbol_file_dwarf->GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
{
if (oso_dwarf->HasForwardDeclForClangType (clang_type))
{
oso_dwarf->ResolveClangOpaqueTypeDefinition (clang_type);
return;
}
}
}
}
bool
SymbolFileDWARFDebugMap::LayoutRecordType (void *baton,
const clang::RecordDecl *record_decl,
uint64_t &size,
uint64_t &alignment,
llvm::DenseMap <const clang::FieldDecl *, uint64_t> &field_offsets,
llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
{
SymbolFileDWARFDebugMap *symbol_file_dwarf = (SymbolFileDWARFDebugMap *)baton;
SymbolFileDWARF *oso_dwarf;
for (uint32_t oso_idx = 0; ((oso_dwarf = symbol_file_dwarf->GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
{
if (oso_dwarf->LayoutRecordType (record_decl, size, alignment, field_offsets, base_offsets, vbase_offsets))
return true;
}
return false;
}
clang::DeclContext*
SymbolFileDWARFDebugMap::GetClangDeclContextContainingTypeUID (lldb::user_id_t type_uid)
{
const uint64_t oso_idx = GetOSOIndexFromUserID (type_uid);
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
if (oso_dwarf)
return oso_dwarf->GetClangDeclContextContainingTypeUID (type_uid);
return NULL;
}
clang::DeclContext*
SymbolFileDWARFDebugMap::GetClangDeclContextForTypeUID (const lldb_private::SymbolContext &sc, lldb::user_id_t type_uid)
{
const uint64_t oso_idx = GetOSOIndexFromUserID (type_uid);
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
if (oso_dwarf)
return oso_dwarf->GetClangDeclContextForTypeUID (sc, type_uid);
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink