bool PCLibraryState::cacheLibraryRanges(Library::ptr lib)
{
std::string filename = lib->getName();
Address base = lib->getLoadAddress();
SymbolReaderFactory *fact = getDefaultSymbolReader();
SymReader *reader = fact->openSymbolReader(filename);
if (!reader) {
sw_printf("[%s:%u] - Error could not open expected file %s\n",
FILE__, __LINE__, filename.c_str());
return false;
}
int num_segments = reader->numSegments();
for (int i=0; i<num_segments; i++) {
SymSegment segment;
reader->getSegment(i, segment);
if (segment.type != 1) continue;
Address segment_start = segment.mem_addr + base;
Address segment_end = segment_start + segment.mem_size;
loadedLibs.insert(segment_start, segment_end,
makeCache(LibAddrPair(lib->getName(),
lib->getLoadAddress()),
lib));
}
return true;
}
void PCLibraryState::checkForNewLib(Library::ptr lib)
{
if (lib->getData())
return;
sw_printf("[%s:%u] - Detected new library %s at %lx, notifying\n",
FILE__, __LINE__, lib->getName().c_str(), lib->getLoadAddress());
lib->setData((void *) 0x1);
StepperGroup *group = pdebug->getWalker()->getStepperGroup();
LibAddrPair la(lib->getName(), lib->getLoadAddress());
group->newLibraryNotification(&la, library_load);
}
bool PCLibraryState::getAOut(LibAddrPair &ao)
{
Process::ptr proc = pdebug->getProc();
CHECK_PROC_LIVE;
Library::ptr lib = proc->libraries().getExecutable();
if (!lib) {
sw_printf("[%s:%u] - Could not get executable\n", FILE__, __LINE__);
return false;
}
ao = LibAddrPair(lib->getName(), lib->getLoadAddress());
return true;
}
bool PCLibraryState::memoryScan(Process::ptr proc, Address addr, LibAddrPair &lib) {
LibraryPool::iterator i;
Library::ptr nearest_predecessor = Library::ptr();
signed int pred_distance = 0;
Library::ptr nearest_successor = Library::ptr();
signed int succ_distance = 0;
/**
* Search the entire library list for the dynamic sections that come
* directly before and after our target address (nearest_predecessor
* and nearest_successor).
*
* They dynamic linker (and who-knows-what on future systems) can have a
* dynamic address of zero. Remember any library with a zero dynamic
* address with zero_dynamic_libs, and manually check those if the
* nearest_successor and nearest_predecessor.
**/
std::vector<Library::ptr> zero_dynamic_libs;
for (i = proc->libraries().begin(); i != proc->libraries().end(); i++)
{
Library::ptr slib = *i;
checkForNewLib(slib);
Address dyn_addr = slib->getDynamicAddress();
if (!dyn_addr) {
zero_dynamic_libs.push_back(slib);
continue;
}
signed int distance = addr - dyn_addr;
if (distance == 0) {
lib.first = slib->getName();
lib.second = slib->getLoadAddress();
sw_printf("[%s:%u] - Found library %s contains address %lx\n",
FILE__, __LINE__, lib.first.c_str(), addr);
return true;
}
else if (distance < 0) {
if (!pred_distance || pred_distance < distance) {
nearest_predecessor = slib;
pred_distance = distance;
}
}
else if (distance > 0) {
if (!succ_distance || succ_distance > distance) {
nearest_successor = slib;
succ_distance = distance;
}
}
}
/**
* Likely a static binary, set nearest_predecessor so that
* the following check will test it.
**/
if (!nearest_predecessor && !nearest_successor) {
nearest_predecessor = proc->libraries().getExecutable();
}
/**
* Check if predessor contains our address first--this should be the typical case
**/
if (nearest_predecessor && checkLibraryContains(addr, nearest_predecessor)) {
lib.first = nearest_predecessor->getName();
lib.second = nearest_predecessor->getLoadAddress();
sw_printf("[%s:%u] - Found library %s contains address %lx\n",
FILE__, __LINE__, lib.first.c_str(), addr);
return true;
}
/**
* Check successor
**/
if (nearest_successor && checkLibraryContains(addr, nearest_successor)) {
lib.first = nearest_successor->getName();
lib.second = nearest_successor->getLoadAddress();
sw_printf("[%s:%u] - Found library %s contains address %lx\n",
FILE__, __LINE__, lib.first.c_str(), addr);
return true;
}
/**
* The address wasn't located by the dynamic section tests. Check
* any libraries without dynamic pointers, plus the executable.
**/
std::vector<Library::ptr>::iterator k = zero_dynamic_libs.begin();
for (; k != zero_dynamic_libs.end(); k++) {
if (checkLibraryContains(addr, *k)) {
lib.first = (*k)->getName();
lib.second = (*k)->getLoadAddress();
return true;
}
}
if(checkLibraryContains(addr, proc->libraries().getExecutable()))
{
lib.first = proc->libraries().getExecutable()->getName();
lib.second = proc->libraries().getExecutable()->getLoadAddress();
sw_printf("[%s:%u] - Found executable %s contains address %lx\n", FILE__,
__LINE__, lib.first.c_str(), addr);
return true;
}
sw_printf("[%s:%u] - Could not find library for addr %lx\n",
FILE__, __LINE__, addr);
return false;
}