bool
SymbolContext::GetAddressRange (uint32_t scope, AddressRange &range) const
{
if ((scope & eSymbolContextLineEntry) && line_entry.IsValid())
{
range = line_entry.range;
return true;
}
else if ((scope & eSymbolContextFunction) && function != NULL)
{
range = function->GetAddressRange();
return true;
}
else if ((scope & eSymbolContextSymbol) && symbol != NULL && symbol->GetAddressRangePtr())
{
range = *symbol->GetAddressRangePtr();
if (range.GetByteSize() == 0)
{
if (module_sp)
{
ObjectFile *objfile = module_sp->GetObjectFile();
if (objfile)
{
Symtab *symtab = objfile->GetSymtab();
if (symtab)
range.SetByteSize(symtab->CalculateSymbolSize (symbol));
}
}
}
return true;
}
range.Clear();
return false;
}
DysectAPI::DysectErrorCode SymbolTable::getFileLineByAddr(string& fileName, int& line, Dyninst::Address addr, Dyninst::Stackwalker::Walker* proc) {
bool ret;
LibAddrPair lib;
vector<LineNoTuple *> lines;
if(SymbolTable::getLibraryByAddr(lib, addr, proc) != OK) {
fileName = "?";
line = 0;
return OK;
}
Symtab* symtab = 0;
string libName = lib.first;
if(SymbolTable::getSymbolTable(libName, symtab) != OK) {
return Err::warn(Error, "Could not load symbol table for library '%s'", libName.c_str());
}
symtab->setTruncateLinePaths(false);
Address loadAddr = lib.second;
ret = symtab->getSourceLines(lines, addr - loadAddr);
if (!ret)
{
fileName = "?";
line = 0;
return OK;
}
fileName = string(lines[0]->getFile());
line = lines[0]->getLine();
return OK;
}
lldb::SBSymbolContextList
SBModule::FindSymbols (const char *name, lldb::SymbolType symbol_type)
{
SBSymbolContextList sb_sc_list;
if (name && name[0])
{
ModuleSP module_sp (GetSP ());
Symtab *symtab = GetUnifiedSymbolTable (module_sp);
if (symtab)
{
std::vector<uint32_t> matching_symbol_indexes;
const size_t num_matches = symtab->FindAllSymbolsWithNameAndType(ConstString(name), symbol_type, matching_symbol_indexes);
if (num_matches)
{
SymbolContext sc;
sc.module_sp = module_sp;
SymbolContextList &sc_list = *sb_sc_list;
for (size_t i=0; i<num_matches; ++i)
{
sc.symbol = symtab->SymbolAtIndex (matching_symbol_indexes[i]);
if (sc.symbol)
sc_list.Append(sc);
}
}
}
}
return sb_sc_list;
}
virtual bool check(SpPoint* pt) {
PatchFunction* f = sp::Callee(pt);
if (!f) return false;
sp_print("StackArrayChecker");
// getAllVariables
PatchObject* obj = pt->obj();
using namespace Dyninst::ParseAPI;
using namespace Dyninst::SymtabAPI;
SymtabCodeSource* cs = static_cast<SymtabCodeSource*>(obj->co()->cs());
Symtab* sym = cs->getSymtabObject();
std::vector<Symbol*> symbols;
std::vector<SymtabAPI::Function*> funcs;
sym->getAllFunctions(funcs);
for (unsigned i = 0; i < funcs.size(); i ++) {
if (funcs[i]->getOffset() == f->addr()) {
std::vector<localVar*> vars;
funcs[i]->getLocalVariables(vars);
for (unsigned j = 0; j < vars.size(); j ++) {
typeArray* t = vars[j]->getType()->getArrayType();
if (!t) continue;
sp_print("%s: [%lx, %lx]", vars[j]->getName().c_str(), t->getLow(), t->getHigh());
}
}
}
return true;
}
size_t
Module::FindSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, SymbolContextList &sc_list)
{
// No need to protect this call using m_mutex all other method calls are
// already thread safe.
Timer scoped_timer(__PRETTY_FUNCTION__,
"Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
name.AsCString(),
symbol_type);
const size_t initial_size = sc_list.GetSize();
ObjectFile *objfile = GetObjectFile ();
if (objfile)
{
Symtab *symtab = objfile->GetSymtab();
if (symtab)
{
std::vector<uint32_t> symbol_indexes;
symtab->FindAllSymbolsWithNameAndType (name, symbol_type, symbol_indexes);
SymbolIndicesToSymbolContextList (symtab, symbol_indexes, sc_list);
}
}
return sc_list.GetSize() - initial_size;
}
bool BinaryEdit::createMemoryBackingStore(mapped_object *obj) {
// We want to create a buffer for every section in the
// binary so that we can store updates.
Symtab *symObj = obj->parse_img()->getObject();
vector<Region*> regs;
symObj->getAllRegions(regs);
for (unsigned i = 0; i < regs.size(); i++) {
memoryTracker *newTracker = NULL;
if (regs[i]->getRegionType() == Region::RT_BSS || (regs[i]->getMemSize() == 0))
{
continue;
}
else {
newTracker = new memoryTracker(regs[i]->getMemOffset(),
regs[i]->getMemSize(),
regs[i]->getPtrToRawData());
}
newTracker->alloced = false;
if (!memoryTracker_)
memoryTracker_ = new codeRangeTree();
memoryTracker_->insert(newTracker);
}
return true;
}
bool BinaryEdit::getAllDependencies(std::map<std::string, BinaryEdit*>& deps)
{
Symtab *symtab = mobj->parse_img()->getObject();
std::deque<std::string> depends;
depends.insert(depends.end(), symtab->getDependencies().begin(), symtab->getDependencies().end());
while(!depends.empty())
{
std::string lib = depends.front();
if(deps.find(lib) == deps.end()) {
std::map<std::string, BinaryEdit*> res;
if(!openResolvedLibraryName(lib, res)) return false;
std::map<std::string, BinaryEdit*>::iterator bedit_it;
for(bedit_it = res.begin(); bedit_it != res.end(); ++bedit_it) {
if (bedit_it->second) {
deps.insert(*bedit_it);
if(!bedit_it->second->getAllDependencies(deps))
{
return false;
}
} else {
return false;
}
}
}
depends.pop_front();
}
return true;
}
SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
SBSymbol sb_symbol;
ModuleSP module_sp(GetSP());
Symtab *symtab = GetUnifiedSymbolTable(module_sp);
if (symtab)
sb_symbol.SetSymbol(symtab->SymbolAtIndex(idx));
return sb_symbol;
}
size_t SBModule::GetNumSymbols() {
ModuleSP module_sp(GetSP());
if (module_sp) {
Symtab *symtab = GetUnifiedSymbolTable(module_sp);
if (symtab)
return symtab->GetNumSymbols();
}
return 0;
}
void DICFG::parse_all(void)
{
BPatch_addressSpace *handle = cfg_handle;
SymtabCodeSource *sts = cfg_sts;
CodeObject *co = cfg_co;
// Parse the binary
co->parse();
/* Parse the functions found by the BPatch API */
BPatch_image *image = handle->getImage();
std::vector<BPatch_module *> *mods = image->getModules();
std::vector<BPatch_module *>::iterator mods_iter;
for (mods_iter = mods->begin(); mods_iter != mods->end(); mods_iter++) {
address_t mod_start = (address_t)(*mods_iter)->getBaseAddr();
address_t mod_end = (address_t)(*mods_iter)->getBaseAddr() + (*mods_iter)->getSize();
if((get_start_addr() == 0) || (mod_start < get_start_addr())) {
set_start_addr(mod_start);
}
if((get_end_addr() == 0) || (mod_end > get_end_addr())) {
set_end_addr(mod_end);
}
std::vector<BPatch_function *> *funcs = (*mods_iter)->getProcedures(false);
std::vector<BPatch_function *>::iterator funcs_iter = funcs->begin();
for(; funcs_iter != funcs->end(); funcs_iter++) {
co->parse((Address)(*funcs_iter)->getBaseAddr(), true);
}
}
/* Parse PLT entries */
Symtab *symtab = Symtab::findOpenSymtab(string((char *) this->get_module_name().c_str()));
vector<SymtabAPI::relocationEntry> fbt;
vector<SymtabAPI::relocationEntry>::iterator fbt_iter;
symtab->getFuncBindingTable(fbt);
for (fbt_iter = fbt.begin(); fbt_iter != fbt.end(); fbt_iter++) {
co->parse((Address)((*fbt_iter).target_addr()), true);
}
const CodeObject::funclist& funcs = co->funcs();
insert_functions_and_bbs(funcs);
for (fbt_iter = fbt.begin(); fbt_iter != fbt.end(); fbt_iter++) {
address_t plt_fun_addr = (address_t)(*fbt_iter).target_addr();
if((get_start_addr() == 0) || (plt_fun_addr < get_start_addr())) {
set_start_addr(plt_fun_addr);
}
if((get_end_addr() == 0) || (plt_fun_addr > get_end_addr())) {
set_end_addr(plt_fun_addr);
}
mark_function_as_plt(plt_fun_addr);
}
}
void
SymtabAPISymbols::getDepenentLibs(const std::string& objname,
std::vector<std::string>& dependencies)
{
Symtab *symtab;
bool err = Symtab::openFile(symtab, objname);
if (symtab) {
dependencies = symtab->getDependencies();
}
}
uint32_t
Module::ResolveSymbolContextForAddress (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc)
{
Mutex::Locker locker (m_mutex);
uint32_t resolved_flags = 0;
// Clear the result symbol context in case we don't find anything
sc.Clear();
// Get the section from the section/offset address.
const Section *section = so_addr.GetSection();
// Make sure the section matches this module before we try and match anything
if (section && section->GetModule() == this)
{
// If the section offset based address resolved itself, then this
// is the right module.
sc.module_sp = GetSP();
resolved_flags |= eSymbolContextModule;
// Resolve the compile unit, function, block, line table or line
// entry if requested.
if (resolve_scope & eSymbolContextCompUnit ||
resolve_scope & eSymbolContextFunction ||
resolve_scope & eSymbolContextBlock ||
resolve_scope & eSymbolContextLineEntry )
{
SymbolVendor *symbols = GetSymbolVendor ();
if (symbols)
resolved_flags |= symbols->ResolveSymbolContext (so_addr, resolve_scope, sc);
}
// Resolve the symbol if requested, but don't re-look it up if we've already found it.
if (resolve_scope & eSymbolContextSymbol && !(resolved_flags & eSymbolContextSymbol))
{
ObjectFile* ofile = GetObjectFile();
if (ofile)
{
Symtab *symtab = ofile->GetSymtab();
if (symtab)
{
if (so_addr.IsSectionOffset())
{
sc.symbol = symtab->FindSymbolContainingFileAddress(so_addr.GetFileAddress());
if (sc.symbol)
resolved_flags |= eSymbolContextSymbol;
}
}
}
}
}
return resolved_flags;
}
lldb::SBSymbol SBModule::FindSymbol(const char *name,
lldb::SymbolType symbol_type) {
SBSymbol sb_symbol;
if (name && name[0]) {
ModuleSP module_sp(GetSP());
Symtab *symtab = GetUnifiedSymbolTable(module_sp);
if (symtab)
sb_symbol.SetSymbol(symtab->FindFirstSymbolWithNameAndType(
ConstString(name), symbol_type, Symtab::eDebugAny,
Symtab::eVisibilityAny));
}
return sb_symbol;
}
DysectErrorCode Backend::writeModuleVariable(Dyninst::ProcControlAPI::Process::ptr process, std::string variableName, std::string libraryPath, void *value, int size) {
bool result, found = false;
string libraryName;
Symtab *symtab = NULL;
Offset varOffset;
Address loadAddress;
vector<SymtabAPI::Variable *> variables;
LibraryPool::iterator libsIter;
if (symtabs.find(libraryPath) == symtabs.end()) {
result = Symtab::openFile(symtab, libraryPath.c_str());
if (result == false) {
DYSECTWARN(false, "Failed to find file %s for symtab", libraryPath.c_str());
return Error;
}
}
else {
symtab = symtabs[libraryPath];
}
result = symtab->findVariablesByName(variables, variableName);
if (result == false || variables.size() < 1) {
DYSECTWARN(false, "Failed to find %s variable", variableName.c_str());
return Error;
}
varOffset = variables[0]->getOffset();
DYSECTLOG(true, "found %s at offset 0x%lx", variableName.c_str(), varOffset);
libraryName = basename(libraryPath.c_str());
LibraryPool &libs = process->libraries();
for (libsIter = libs.begin(); libsIter != libs.end(); libsIter++)
{
Library::ptr libraryPtr = *libsIter;
if (libraryPtr->getName().find(libraryName) == string::npos)
continue;
loadAddress = (*libsIter)->getLoadAddress();
found = true;
DYSECTLOG(true, "found library %s at 0x%lx", libraryName.c_str(), loadAddress);
break;
}
if (found == false) {
DYSECTWARN(false, "Failed to find library %s", libraryName.c_str());
return Error;
}
process->writeMemory(loadAddress + varOffset, value, size);
return OK;
}
void ByteCodeBackend::visit(IR_ProgNode* node)
{
Symtab* top = node->symtab()->top();
for (auto it = top->begin(); it != top->end(); ++it)
{
if (it->which() == Symbol::Const)
{
if (!m_blob.addConstant(it->data().classid(), it->data().serialize()))
M_error(node, "internal error: unable to add constant entry to blob");
}
}
// Generate bytecode for the whole program
node->siblings()[0]->accept(this);
}
bool BinaryEdit::needsPIC()
{
Symtab *symtab = getMappedObject()->parse_img()->getObject();
assert(symtab);
if(getMappedObject()->fileName().find("lib") == 0)
{
if(getMappedObject()->fileName().find(".so") != std::string::npos)
{
return true;
}
}
//If there is a fixed load address, then we can calculate
// absolute addresses.
return (symtab->getLoadAddress() == 0);
}
void SymbolVendor::SectionFileAddressesChanged() {
ModuleSP module_sp(GetModule());
if (module_sp) {
ObjectFile *module_objfile = module_sp->GetObjectFile();
if (m_sym_file_ap.get()) {
ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile();
if (symfile_objfile != module_objfile)
symfile_objfile->SectionFileAddressesChanged();
}
Symtab *symtab = GetSymtab();
if (symtab) {
symtab->SectionFileAddressesChanged();
}
}
}
const Symbol *
Module::FindFirstSymbolWithNameAndType (const ConstString &name, SymbolType symbol_type)
{
Timer scoped_timer(__PRETTY_FUNCTION__,
"Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
name.AsCString(),
symbol_type);
ObjectFile *objfile = GetObjectFile();
if (objfile)
{
Symtab *symtab = objfile->GetSymtab();
if (symtab)
return symtab->FindFirstSymbolWithNameAndType (name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny);
}
return NULL;
}
size_t
SBModule::GetNumSymbols ()
{
ModuleSP module_sp (GetSP ());
if (module_sp)
{
ObjectFile *obj_file = module_sp->GetObjectFile();
if (obj_file)
{
Symtab *symtab = obj_file->GetSymtab();
if (symtab)
return symtab->GetNumSymbols();
}
}
return 0;
}
bool BinaryEdit::isMultiThreadCapable()
{
Symtab *symtab = mobj->parse_img()->getObject();
std::vector<std::string> depends = symtab->getDependencies();
for (std::vector<std::string>::iterator curDep = depends.begin();
curDep != depends.end(); curDep++) {
if( (curDep->find("libpthread") != std::string::npos)
|| (curDep->find("libthread") != std::string::npos)
|| (curDep->find("libthr") != std::string::npos) )
{
return true;
}
}
return archSpecificMultithreadCapable();
}
SBSymbol
SBModule::GetSymbolAtIndex (size_t idx)
{
SBSymbol sb_symbol;
ModuleSP module_sp (GetSP ());
if (module_sp)
{
ObjectFile *obj_file = module_sp->GetObjectFile();
if (obj_file)
{
Symtab *symtab = obj_file->GetSymtab();
if (symtab)
sb_symbol.SetSymbol(symtab->SymbolAtIndex (idx));
}
}
return sb_symbol;
}
uint32_t
Module::FindFunctions (const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
uint32_t name_type_mask,
bool include_symbols,
bool include_inlines,
bool append,
SymbolContextList& sc_list)
{
if (!append)
sc_list.Clear();
const uint32_t start_size = sc_list.GetSize();
// Find all the functions (not symbols, but debug information functions...
SymbolVendor *symbols = GetSymbolVendor ();
if (symbols)
symbols->FindFunctions(name, namespace_decl, name_type_mask, include_inlines, append, sc_list);
// Now check our symbol table for symbols that are code symbols if requested
if (include_symbols)
{
ObjectFile *objfile = GetObjectFile();
if (objfile)
{
Symtab *symtab = objfile->GetSymtab();
if (symtab)
{
std::vector<uint32_t> symbol_indexes;
symtab->FindAllSymbolsWithNameAndType (name, eSymbolTypeCode, Symtab::eDebugAny, Symtab::eVisibilityAny, symbol_indexes);
const uint32_t num_matches = symbol_indexes.size();
if (num_matches)
{
const bool merge_symbol_into_function = true;
SymbolContext sc(this);
for (uint32_t i=0; i<num_matches; i++)
{
sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
sc_list.AppendIfUnique (sc, merge_symbol_into_function);
}
}
}
}
}
return sc_list.GetSize() - start_size;
}
//===----------------------------------------------------------------------===//
// Dump
//
// Dump the specifics of the runtime file container (such as any headers
// segments, sections, etc).
//----------------------------------------------------------------------
void
ObjectFileELF::Dump(Stream *s)
{
DumpELFHeader(s, m_header);
s->EOL();
DumpELFProgramHeaders(s);
s->EOL();
DumpELFSectionHeaders(s);
s->EOL();
SectionList *section_list = GetSectionList();
if (section_list)
section_list->Dump(s, NULL, true, UINT32_MAX);
Symtab *symtab = GetSymtab();
if (symtab)
symtab->Dump(s, NULL, eSortOrderNone);
s->EOL();
DumpDependentModules(s);
s->EOL();
}
vector<Symbol *> *AddressLookup::getSymsVector(LoadedLib *lib)
{
string str = lib->getName();
if (syms.find(str) != syms.end()) {
return &(syms[str]);
}
Symtab *tab = getSymtab(lib);
if (!tab) {
return NULL;
}
vector<Symbol *> &symbols = syms[str];
tab->getAllSymbolsByType(symbols, Symbol::ST_UNKNOWN);
std::sort(symbols.begin(), symbols.end(), sort_by_addr);
return &(syms[str]);
}
uint32_t
Module::FindFunctions (const RegularExpression& regex,
bool include_symbols,
bool include_inlines,
bool append,
SymbolContextList& sc_list)
{
if (!append)
sc_list.Clear();
const uint32_t start_size = sc_list.GetSize();
SymbolVendor *symbols = GetSymbolVendor ();
if (symbols)
symbols->FindFunctions(regex, include_inlines, append, sc_list);
// Now check our symbol table for symbols that are code symbols if requested
if (include_symbols)
{
ObjectFile *objfile = GetObjectFile();
if (objfile)
{
Symtab *symtab = objfile->GetSymtab();
if (symtab)
{
std::vector<uint32_t> symbol_indexes;
symtab->AppendSymbolIndexesMatchingRegExAndType (regex, eSymbolTypeCode, Symtab::eDebugAny, Symtab::eVisibilityAny, symbol_indexes);
const uint32_t num_matches = symbol_indexes.size();
if (num_matches)
{
const bool merge_symbol_into_function = true;
SymbolContext sc(this);
for (uint32_t i=0; i<num_matches; i++)
{
sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
sc_list.AppendIfUnique (sc, merge_symbol_into_function);
}
}
}
}
}
return sc_list.GetSize() - start_size;
}
lldb::SBSymbol
SBModule::FindSymbol (const char *name,
lldb::SymbolType symbol_type)
{
SBSymbol sb_symbol;
if (name && name[0])
{
ModuleSP module_sp (GetSP ());
if (module_sp)
{
ObjectFile *obj_file = module_sp->GetObjectFile();
if (obj_file)
{
Symtab *symtab = obj_file->GetSymtab();
if (symtab)
sb_symbol.SetSymbol(symtab->FindFirstSymbolWithNameAndType(ConstString(name), symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny));
}
}
}
return sb_symbol;
}
size_t
Module::FindSymbolsMatchingRegExAndType (const RegularExpression ®ex, SymbolType symbol_type, SymbolContextList &sc_list)
{
// No need to protect this call using m_mutex all other method calls are
// already thread safe.
Timer scoped_timer(__PRETTY_FUNCTION__,
"Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)",
regex.GetText(),
symbol_type);
const size_t initial_size = sc_list.GetSize();
ObjectFile *objfile = GetObjectFile ();
if (objfile)
{
Symtab *symtab = objfile->GetSymtab();
if (symtab)
{
std::vector<uint32_t> symbol_indexes;
symtab->FindAllSymbolsMatchingRexExAndType (regex, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny, symbol_indexes);
SymbolIndicesToSymbolContextList (symtab, symbol_indexes, sc_list);
}
}
return sc_list.GetSize() - initial_size;
}
void ResolveConsts::visit(ConstNode* node)
{
Symtab* top = node->symtab()->top();
bool found = false;
int index = 0;
for (auto it = top->begin(); it != top->end(); ++it)
{
if (it->which() == Symbol::Const)
{
if (it->data().classid() == node->value.classid() &&
it->data().serialize() == node->value.serialize())
{
found = true;
break;
}
++index;
}
}
if (!found)
{
index = m_alloc_index++;
Symbol sym(Symbol::Const, Symbol::Global, "", node->value);
top->add(sym);
}
ConstRefNode* new_node = new ConstRefNode(node->startToken());
new_node->index = index;
node->exchangeWith(new_node);
delete node;
M_follow(new_node);
}
AddressClass
ObjectFile::GetAddressClass (addr_t file_addr)
{
Symtab *symtab = GetSymtab(ObjectFile::eSymtabFromUnifiedSectionList);
if (symtab)
{
Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
if (symbol)
{
if (symbol->ValueIsAddress())
{
const SectionSP section_sp (symbol->GetAddress().GetSection());
if (section_sp)
{
const SectionType section_type = section_sp->GetType();
switch (section_type)
{
case eSectionTypeInvalid: return eAddressClassUnknown;
case eSectionTypeCode: return eAddressClassCode;
case eSectionTypeContainer: return eAddressClassUnknown;
case eSectionTypeData:
case eSectionTypeDataCString:
case eSectionTypeDataCStringPointers:
case eSectionTypeDataSymbolAddress:
case eSectionTypeData4:
case eSectionTypeData8:
case eSectionTypeData16:
case eSectionTypeDataPointers:
case eSectionTypeZeroFill:
case eSectionTypeDataObjCMessageRefs:
case eSectionTypeDataObjCCFStrings:
return eAddressClassData;
case eSectionTypeDebug:
case eSectionTypeDWARFDebugAbbrev:
case eSectionTypeDWARFDebugAranges:
case eSectionTypeDWARFDebugFrame:
case eSectionTypeDWARFDebugInfo:
case eSectionTypeDWARFDebugLine:
case eSectionTypeDWARFDebugLoc:
case eSectionTypeDWARFDebugMacInfo:
case eSectionTypeDWARFDebugPubNames:
case eSectionTypeDWARFDebugPubTypes:
case eSectionTypeDWARFDebugRanges:
case eSectionTypeDWARFDebugStr:
case eSectionTypeDWARFAppleNames:
case eSectionTypeDWARFAppleTypes:
case eSectionTypeDWARFAppleNamespaces:
case eSectionTypeDWARFAppleObjC:
return eAddressClassDebug;
case eSectionTypeEHFrame: return eAddressClassRuntime;
case eSectionTypeELFSymbolTable:
case eSectionTypeELFDynamicSymbols:
case eSectionTypeELFRelocationEntries:
case eSectionTypeELFDynamicLinkInfo:
case eSectionTypeOther: return eAddressClassUnknown;
}
}
}
const SymbolType symbol_type = symbol->GetType();
switch (symbol_type)
{
case eSymbolTypeAny: return eAddressClassUnknown;
case eSymbolTypeAbsolute: return eAddressClassUnknown;
case eSymbolTypeCode: return eAddressClassCode;
case eSymbolTypeTrampoline: return eAddressClassCode;
case eSymbolTypeResolver: return eAddressClassCode;
case eSymbolTypeData: return eAddressClassData;
case eSymbolTypeRuntime: return eAddressClassRuntime;
case eSymbolTypeException: return eAddressClassRuntime;
case eSymbolTypeSourceFile: return eAddressClassDebug;
case eSymbolTypeHeaderFile: return eAddressClassDebug;
case eSymbolTypeObjectFile: return eAddressClassDebug;
case eSymbolTypeCommonBlock: return eAddressClassDebug;
case eSymbolTypeBlock: return eAddressClassDebug;
case eSymbolTypeLocal: return eAddressClassData;
case eSymbolTypeParam: return eAddressClassData;
case eSymbolTypeVariable: return eAddressClassData;
case eSymbolTypeVariableType: return eAddressClassDebug;
case eSymbolTypeLineEntry: return eAddressClassDebug;
case eSymbolTypeLineHeader: return eAddressClassDebug;
case eSymbolTypeScopeBegin: return eAddressClassDebug;
case eSymbolTypeScopeEnd: return eAddressClassDebug;
case eSymbolTypeAdditional: return eAddressClassUnknown;
case eSymbolTypeCompiler: return eAddressClassDebug;
case eSymbolTypeInstrumentation:return eAddressClassDebug;
case eSymbolTypeUndefined: return eAddressClassUnknown;
case eSymbolTypeObjCClass: return eAddressClassRuntime;
case eSymbolTypeObjCMetaClass: return eAddressClassRuntime;
case eSymbolTypeObjCIVar: return eAddressClassRuntime;
}
}
}
return eAddressClassUnknown;
}
AddressClass ObjectFile::GetAddressClass(addr_t file_addr) {
Symtab *symtab = GetSymtab();
if (symtab) {
Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
if (symbol) {
if (symbol->ValueIsAddress()) {
const SectionSP section_sp(symbol->GetAddressRef().GetSection());
if (section_sp) {
const SectionType section_type = section_sp->GetType();
switch (section_type) {
case eSectionTypeInvalid:
return eAddressClassUnknown;
case eSectionTypeCode:
return eAddressClassCode;
case eSectionTypeContainer:
return eAddressClassUnknown;
case eSectionTypeData:
case eSectionTypeDataCString:
case eSectionTypeDataCStringPointers:
case eSectionTypeDataSymbolAddress:
case eSectionTypeData4:
case eSectionTypeData8:
case eSectionTypeData16:
case eSectionTypeDataPointers:
case eSectionTypeZeroFill:
case eSectionTypeDataObjCMessageRefs:
case eSectionTypeDataObjCCFStrings:
case eSectionTypeGoSymtab:
return eAddressClassData;
case eSectionTypeDebug:
case eSectionTypeDWARFDebugAbbrev:
case eSectionTypeDWARFDebugAddr:
case eSectionTypeDWARFDebugAranges:
case eSectionTypeDWARFDebugFrame:
case eSectionTypeDWARFDebugInfo:
case eSectionTypeDWARFDebugLine:
case eSectionTypeDWARFDebugLoc:
case eSectionTypeDWARFDebugMacInfo:
case eSectionTypeDWARFDebugMacro:
case eSectionTypeDWARFDebugPubNames:
case eSectionTypeDWARFDebugPubTypes:
case eSectionTypeDWARFDebugRanges:
case eSectionTypeDWARFDebugStr:
case eSectionTypeDWARFDebugStrOffsets:
case eSectionTypeDWARFAppleNames:
case eSectionTypeDWARFAppleTypes:
case eSectionTypeDWARFAppleNamespaces:
case eSectionTypeDWARFAppleObjC:
return eAddressClassDebug;
case eSectionTypeEHFrame:
case eSectionTypeARMexidx:
case eSectionTypeARMextab:
case eSectionTypeCompactUnwind:
return eAddressClassRuntime;
case eSectionTypeELFSymbolTable:
case eSectionTypeELFDynamicSymbols:
case eSectionTypeELFRelocationEntries:
case eSectionTypeELFDynamicLinkInfo:
case eSectionTypeOther:
return eAddressClassUnknown;
case eSectionTypeAbsoluteAddress:
// In case of absolute sections decide the address class based on
// the symbol
// type because the section type isn't specify if it is a code or a
// data
// section.
break;
}
}
}
const SymbolType symbol_type = symbol->GetType();
switch (symbol_type) {
case eSymbolTypeAny:
return eAddressClassUnknown;
case eSymbolTypeAbsolute:
return eAddressClassUnknown;
case eSymbolTypeCode:
return eAddressClassCode;
case eSymbolTypeTrampoline:
return eAddressClassCode;
case eSymbolTypeResolver:
return eAddressClassCode;
case eSymbolTypeData:
return eAddressClassData;
case eSymbolTypeRuntime:
return eAddressClassRuntime;
case eSymbolTypeException:
return eAddressClassRuntime;
case eSymbolTypeSourceFile:
return eAddressClassDebug;
case eSymbolTypeHeaderFile:
return eAddressClassDebug;
case eSymbolTypeObjectFile:
return eAddressClassDebug;
case eSymbolTypeCommonBlock:
return eAddressClassDebug;
case eSymbolTypeBlock:
return eAddressClassDebug;
case eSymbolTypeLocal:
return eAddressClassData;
case eSymbolTypeParam:
return eAddressClassData;
case eSymbolTypeVariable:
return eAddressClassData;
case eSymbolTypeVariableType:
return eAddressClassDebug;
case eSymbolTypeLineEntry:
return eAddressClassDebug;
case eSymbolTypeLineHeader:
return eAddressClassDebug;
case eSymbolTypeScopeBegin:
return eAddressClassDebug;
case eSymbolTypeScopeEnd:
return eAddressClassDebug;
case eSymbolTypeAdditional:
return eAddressClassUnknown;
case eSymbolTypeCompiler:
return eAddressClassDebug;
case eSymbolTypeInstrumentation:
return eAddressClassDebug;
case eSymbolTypeUndefined:
return eAddressClassUnknown;
case eSymbolTypeObjCClass:
return eAddressClassRuntime;
case eSymbolTypeObjCMetaClass:
return eAddressClassRuntime;
case eSymbolTypeObjCIVar:
return eAddressClassRuntime;
case eSymbolTypeReExported:
return eAddressClassRuntime;
}
}
}
return eAddressClassUnknown;
}
