AddressIntervalSet
SgAsmGenericSection::get_unreferenced_extents() const
{
AddressIntervalSet set = get_referenced_extents();
set.invert(AddressInterval::baseSize(0, get_size()));
return set;
}
/** Returns a list of parts of a single section that have been referenced. The offsets are relative to the start of the
* section. */
AddressIntervalSet
SgAsmGenericSection::get_referenced_extents() const
{
if (0==get_size())
return AddressIntervalSet();
AddressIntervalSet retval;
AddressInterval segment = AddressInterval::baseSize(get_offset(), get_size());
const AddressIntervalSet &fileExtents = get_file()->get_referenced_extents();
BOOST_FOREACH (const AddressInterval &interval, fileExtents.intervals()) {
if (segment.isContaining(interval)) {
retval.insert(AddressInterval::baseSize(interval.least()-get_offset(), interval.size()));
} else if (interval.isLeftOf(segment) || interval.isRightOf(segment)) {
// no overlap
} else if (interval.isContaining(segment)) {
retval.insert(AddressInterval::baseSize(0, get_size()));
break; // no point in continuing since we've referenced whole segment now
} else if (interval.least() < segment.least()) {
retval.insert(AddressInterval::baseSize(0, interval.least()+interval.size()-get_offset()));
} else if (interval.greatest() > segment.greatest()) {
retval.insert(AddressInterval::baseSize(interval.least()-get_offset(), get_offset()+get_size()-interval.least()));
} else {
ASSERT_not_reachable("invalid extent overlap category");
}
}
return retval;
}
static void
showStats(const std::string &label1, const FunctionByAddress &code1, const FunctionByAddress &data1,
const std::string &label2, const FunctionByAddress &code2, const FunctionByAddress &data2) {
AddressIntervalSet code1set(code1), code2set(code2);
std::ostream &out = std::cout;
std::pair<size_t, size_t> widths(std::max(size_t(20), label1.size()), std::max(size_t(20), label2.size()));
show(out, widths, "", label1, label2);
show(out, widths, "bytes disassembled", code1set.size(), code2set.size());
show(out, widths, "intervals disassembled", code1set.nIntervals(), code2set.nIntervals());
AddressIntervalSet bytesInCommon = code1set & code2set;
show(out, widths, "bytes in common", bytesInCommon.size(), bytesInCommon.size());
show(out, widths, "bytes in only one", (code1set-code2set).size(), (code2set-code1set).size());
AddressIntervalSet functions1, functions2; // could use std::set, but we want set-theoretic operators
BOOST_FOREACH (const FunctionByAddress::Value &va, code1.values())
functions1.insert(va);
BOOST_FOREACH (const FunctionByAddress::Value &va, code2.values())
functions2.insert(va);
show(out, widths, "number of functions", functions1.size(), functions2.size());
AddressIntervalSet functionsInCommon = functions1 & functions2;
show(out, widths, "functions in common", functionsInCommon.size(), functionsInCommon.size());
show(out, widths, "functions in only one", (functions1-functions2).size(), (functions2-functions1).size());
}
void
MemoryMap::eraseZeros(size_t minsize)
{
if (isEmpty())
return;
unsigned permissions = READABLE | EXECUTABLE; // access permissions that must be present
AddressIntervalSet toRemove; // to save up intervals until we're done iterating
AddressInterval zeroInterval;
uint8_t buf[8192];
rose_addr_t va = hull().least();
while (AddressInterval accessed = atOrAfter(va).require(permissions).limit(sizeof buf).read(buf)) {
for (size_t offset=0; offset<accessed.size(); ++offset) {
if (0 == buf[offset]) {
if (zeroInterval.isEmpty()) {
zeroInterval = AddressInterval(accessed.least()+offset);
} else if (zeroInterval.greatest()+1 < offset) {
if (zeroInterval.size() >= minsize)
toRemove.insert(zeroInterval);
zeroInterval = AddressInterval(accessed.least()+offset);
} else {
zeroInterval = AddressInterval::hull(zeroInterval.least(), zeroInterval.greatest()+1);
}
} else if (!zeroInterval.isEmpty()) {
if (zeroInterval.size() >= minsize)
toRemove.insert(zeroInterval);
zeroInterval = AddressInterval();
}
}
if (accessed.greatest() == hull().greatest())
break; // prevent overflow in next statement
va += accessed.size();
}
if (zeroInterval.size() >= minsize)
toRemove.insert(zeroInterval);
BOOST_FOREACH (const AddressInterval &interval, toRemove.intervals())
erase(interval);
}
/** Obtains the virtual address of the Hint/Name Table. The Hint/Name Table is an implicit table--the PE file format
* specification talks about such a table, but it is not actually defined anywhere in the PE file. Instead, various Import
* Lookup Table and Import Address Table entries might point to individual Hint/Name pairs, which collectively form an
* implicit Hint/Name Table. There is no requirement that the Hint/Name pairs are contiguous in the address space, and indeed
* they often are not. Therefore, the only way to describe the location of the Hint/Name Table is by a list of addresses.
*
* This function will scan this Import Directory's import items, observe which items make references to Hint/Name pairs that
* have known addresses, and add those areas of virtual memory to the specified extent map. This function returns the number
* of ILT entries that reference a Hint/Name pair. */
size_t
SgAsmPEImportDirectory::hintname_table_extent(AddressIntervalSet &extent/*in,out*/) const
{
size_t retval = 0;
const SgAsmPEImportItemPtrList &imports = get_imports()->get_vector();
for (SgAsmPEImportItemPtrList::const_iterator ii=imports.begin(); ii!=imports.end(); ++ii) {
SgAsmPEImportItem *import = *ii;
if (!import->get_by_ordinal() && import->get_hintname_rva().get_rva()!=0 && import->get_hintname_nalloc()>0) {
size_t nbytes = std::min(import->get_hintname_nalloc(), import->hintname_required_size());
extent.insert(AddressInterval::baseSize(import->get_hintname_rva().get_va(), nbytes));
++retval;
}
}
return retval;
}
void
SgAsmGenericFile::dump(FILE *f) const
{
fprintf(f, "Encoding: %s\n", get_data_converter() ? escapeString(get_data_converter()->name()).c_str() : "none");
SgAsmGenericSectionPtrList sections = get_sections();
if (sections.size()==0) {
fprintf(f, "No sections defined for file.\n");
return;
}
/* Sort sections by offset (lowest to highest), then size (largest to smallest but zero-sized entries first) */
for (size_t i = 1; i < sections.size(); i++) {
for (size_t j=0; j<i; j++) {
if (sections[j]->get_offset() == sections[i]->get_offset()) {
rose_addr_t size_i = sections[i]->get_size();
if (0==size_i) size_i = ~(rose_addr_t)0;
rose_addr_t size_j = sections[j]->get_size();
if (0==size_j) size_j = ~(rose_addr_t)0;
if (size_j < size_i) {
SgAsmGenericSection *x = sections[j];
sections[j] = sections[i];
sections[i] = x;
}
} else if (sections[j]->get_offset() > sections[i]->get_offset()) {
SgAsmGenericSection *x = sections[j];
sections[j] = sections[i];
sections[i] = x;
}
}
}
/* Print results */
fprintf(f, "File sections:\n");
fprintf(f, " Flg File-Addr File-Size File-End Base-VA Start-RVA Virt-Size End-RVA Perm ID Name\n");
fprintf(f, " --- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---- --- -----------------\n");
rose_addr_t high_water = 0;
for (size_t i=0; i<sections.size(); i++) {
SgAsmGenericSection *section = sections[i];
/* Does section overlap with any other (before or after)? */
char overlap[4] = " "; /* status characters: overlap prior, overlap subsequent, hole */
for (size_t j=0; overlap[0]==' ' && j<i; j++) {
if (sections[j]->get_offset()+sections[j]->get_size() > section->get_offset()) {
overlap[0] = '<';
}
}
for (size_t j=i+1; overlap[1]==' ' && j<sections.size(); j++) {
if (section->get_offset()+section->get_size() > sections[j]->get_offset()) {
overlap[1] = '>';
}
}
/* Is there a hole before section[i]? */
if (high_water < section->get_offset()) {
overlap[2] = 'H'; /* truly unaccounted region of the file */
} else if (i>0 && sections[i-1]->get_offset()+sections[i-1]->get_size() < section->get_offset()) {
overlap[2] = 'h'; /* unaccounted only if overlaps are not allowed */
}
high_water = std::max(high_water, section->get_offset() + section->get_size());
fprintf(f, " %3s", overlap);
/* File addresses */
fprintf(f, "%c0x%08" PRIx64 " 0x%08" PRIx64 " 0x%08" PRIx64,
section->get_file_alignment()==0 || section->get_offset()%section->get_file_alignment()==0?' ':'!',
section->get_offset(), section->get_size(), section->get_offset()+section->get_size());
/* Mapped addresses */
if (section->is_mapped()) {
fprintf(f, " %c0x%08" PRIx64 " 0x%08" PRIx64 " 0x%08" PRIx64 " 0x%08" PRIx64,
(section->get_mapped_alignment()==0 ||
section->get_mapped_preferred_rva()%section->get_mapped_alignment()==0?' ':'!'),
section->get_base_va(), section->get_mapped_preferred_rva(), section->get_mapped_size(),
section->get_mapped_preferred_rva()+section->get_mapped_size());
} else {
fprintf(f, " %*s", 4*11, "");
}
/* Permissions */
if (section->is_mapped()) {
fprintf(f, " %c%c%c ",
section->get_mapped_rperm()?'r':'-',
section->get_mapped_wperm()?'w':'-',
section->get_mapped_xperm()?'x':'-');
} else {
fputs(" ", f);
}
/* Section ID, name */
if (section->get_id()>=0) {
fprintf(f, " %3d", section->get_id());
} else {
fputs(" ", f);
}
fprintf(f, " %s\n", section->get_name()->get_string(true).c_str());
}
char overlap[4] = " ";
if (high_water < get_current_size()) {
overlap[2] = 'H';
} else if (sections.back()->get_offset() + sections.back()->get_size() < get_current_size()) {
overlap[2] = 'h';
}
fprintf(f, " %3s 0x%08" PRIx64 "%*s EOF", overlap, get_current_size(), 76, "");
if (get_current_size()!=p_data.size())
fprintf(f, " (original EOF was 0x%08zx)", p_data.size());
if (get_truncate_zeros())
fputs(" [ztrunc]", f);
fputc('\n', f);
fprintf(f, " --- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---- --- -----------------\n");
/* Show what part of the file has not been referenced */
AddressIntervalSet holes = get_unreferenced_extents();
if (holes.size()>0) {
fprintf(f, "These parts of the file have not been referenced during parsing:\n");
BOOST_FOREACH (const AddressInterval &interval, holes.intervals()) {
std::ostringstream ss;
using namespace StringUtility;
ss <<" " <<toHex(interval.least()) <<" + " <<toHex(interval.size()) <<" = " <<toHex(interval.greatest()+1) <<"\n";
fputs(ss.str().c_str(), f);
}
}
AddressIntervalSet toAddressIntervalSet(const ExtentMap &x) {
AddressIntervalSet retval;
for (ExtentMap::const_iterator iter=x.begin(); iter!=x.end(); ++iter)
retval.insert(toAddressInterval(iter->first));
return retval;
}
ExtentMap toExtentMap(const AddressIntervalSet &x) {
ExtentMap retval;
BOOST_FOREACH (const AddressInterval &interval, x.intervals())
retval.insert(toExtent(interval));
return retval;
}
