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);
}
}
/* Maps the sections of a single header. */
void
BinaryLoader::remap(MemoryMap *map, SgAsmGenericHeader *header)
{
SgAsmGenericFile *file = header->get_file();
ASSERT_not_null(file);
Stream trace(mlog[TRACE]);
trace <<"remapping sections of " <<header->get_file()->get_name() <<"\n";
SgAsmGenericSectionPtrList sections = get_remap_sections(header);
rose_addr_t old_base_va = header->get_base_va();
rose_addr_t new_base_va = rebase(map, header, sections);
if (new_base_va != old_base_va) {
trace <<" temporarily rebasing header from " <<StringUtility::addrToString(old_base_va)
<<" to " <<StringUtility::addrToString(new_base_va) <<"\n";
header->set_base_va(new_base_va);
}
try {
for (SgAsmGenericSectionPtrList::iterator si=sections.begin(); si!=sections.end(); ++si) {
SgAsmGenericSection *section = *si;
section->set_mapped_actual_va(0); /*reset in case previously mapped*/
if (trace) {
trace <<" mapping section [" <<section->get_id() <<"] \"" <<section->get_name()->get_string(true) <<"\"";
if (section->get_base_va()!=0)
trace <<" with base va " <<StringUtility::addrToString(section->get_base_va());
trace <<"\n";
trace <<" Specified RVA: " <<StringUtility::addrToString(section->get_mapped_preferred_rva())
<<" + " <<StringUtility::addrToString(section->get_mapped_size()) <<" bytes"
<<" = " <<StringUtility::addrToString(section->get_mapped_preferred_rva()+section->get_mapped_size())
<<"\n";
if (section->get_base_va()!=0) {
trace <<" Specified VA: "
<<StringUtility::addrToString(section->get_base_va() + section->get_mapped_preferred_rva()) <<" + "
<<StringUtility::addrToString(section->get_mapped_size()) <<" bytes = "
<<StringUtility::addrToString(section->get_base_va() + section->get_mapped_preferred_rva() +
section->get_mapped_size()) <<"\n";
}
trace <<" Specified offset: "
<<StringUtility::addrToString(section->get_offset()) <<" + "
<<StringUtility::addrToString(section->get_size()) <<" bytes = "
<<StringUtility::addrToString(section->get_offset()+section->get_size()) <<"\n";
trace <<" Specified alignment: memory=[" <<section->get_mapped_alignment() <<","
<<section->get_mapped_alignment() <<"], file=["
<<section->get_file_alignment() <<"," <<section->get_file_alignment() <<"]\n";
}
/* Figure out alignment, etc. */
rose_addr_t malign_lo=1, malign_hi=1, va=0, mem_size=0, offset=0, file_size=0, va_offset=0;
bool anon_lo=true, anon_hi=true, map_private=false;
ConflictResolution resolve = RESOLVE_THROW;
MappingContribution contrib = align_values(section, map, /* inputs */
&malign_lo, &malign_hi, /* alignment outputs */
&va, &mem_size, /* memory location outputs */
&offset, &file_size, &map_private, /* file location outputs */
&va_offset, &anon_lo, &anon_hi, /* internal location outputs */
&resolve); /* conflict resolution output */
rose_addr_t falign_lo = std::max(section->get_file_alignment(), (rose_addr_t)1);
rose_addr_t falign_hi = falign_lo;
if (trace) {
if (CONTRIBUTE_NONE==contrib || 0==mem_size) {
trace <<" Does not contribute to map\n";
} else {
trace <<" Adjusted alignment: memory=["
<<malign_lo <<"," <<malign_hi <<"], file=[" <<falign_lo <<"," <<falign_hi <<"]\n";
trace <<" Aligned VA: "
<<StringUtility::addrToString(va) <<" + "
<<StringUtility::addrToString(mem_size) <<" bytes = "
<<StringUtility::addrToString(va+mem_size);
if (section->get_base_va()+section->get_mapped_preferred_rva()==va &&
section->get_mapped_size()==mem_size) {
trace <<" (no change)\n";
} else {
trace <<"\n";
}
if (va < new_base_va) {
trace <<" WARNING: aligned va " <<StringUtility::addrToString(va) <<" is less than "
<<(new_base_va==old_base_va?"":"temporary ") <<"base va "
<<StringUtility::addrToString(new_base_va) <<"\n";
}
if (CONTRIBUTE_ADD==contrib) {
trace <<" Aligned offset: " <<StringUtility::addrToString(offset) <<" + "
<<StringUtility::addrToString(file_size) <<" bytes = "
<<StringUtility::addrToString(offset+file_size)
<<(section->get_offset()==offset && section->get_size()==file_size ? " (no change)\n" : "\n");
trace <<" Permissions: "
<<(section->get_mapped_rperm()?'r':'-')
<<(section->get_mapped_wperm()?'w':'-')
<<(section->get_mapped_xperm()?'x':'-') <<"\n";
trace <<" Internal offset: " <<StringUtility::addrToString(va_offset)
<<" (va " <<StringUtility::addrToString(va+va_offset) <<")\n";
}
}
}
/* Sanity checks */
if (CONTRIBUTE_NONE==contrib || 0==mem_size)
continue;
ASSERT_require(va_offset<mem_size);
if (file_size>mem_size) file_size = mem_size;
ASSERT_require(va + va_offset >= header->get_base_va());
if (trace) {
trace <<" Current memory map (before we map this section)\n";
map->dump(trace, " ");
}
/* Erase part of the mapping? */
if (CONTRIBUTE_SUB==contrib) {
trace <<" Subtracting contribution\n";
map->erase(AddressInterval::baseSize(va, mem_size));
continue;
}
/* Resolve mapping conflicts. The new mapping may have multiple parts, so we test whether all those parts can be
* mapped by first mapping a region and then removing it. In this way we can perform the test atomically rather
* than trying to undo the parts that had been successful. Allocating a large region does not actually allocate any
* memory. */
try {
map->insert(AddressInterval::baseSize(va, mem_size), MemoryMap::Segment::nullInstance(mem_size));
map->erase(AddressInterval::baseSize(va, mem_size));
} catch (const MemoryMap::Exception&) {
switch (resolve) {
case RESOLVE_THROW:
throw;
case RESOLVE_OVERMAP:
trace <<" Conflict: resolved by making a hole\n";
map->erase(AddressInterval::baseSize(va, mem_size));
break;
case RESOLVE_REMAP:
case RESOLVE_REMAP_ABOVE: {
trace <<" Unable to map entire desired region.\n";
AddressInterval where = AddressInterval::hull(RESOLVE_REMAP_ABOVE==resolve ? va : 0,
AddressInterval::whole().greatest());
rose_addr_t new_va = 0;
if (!map->findFreeSpace(mem_size, malign_lo, where).assignTo(new_va)) {
throw MemoryMap::NoFreeSpace("unable to allocate space in specimen memory map",
map, mem_size);
}
ASSERT_require2(0 == (new_va+mem_size) % malign_hi, "FIXME: not handled yet [RPM 2010-09-03]");
va = new_va;
trace <<" Relocated to VA: " <<StringUtility::addrToString(va) <<" + "
<<StringUtility::addrToString(mem_size) <<" bytes = "
<<StringUtility::addrToString(va + mem_size) <<"\n";
break;
}
}
}
/* Save the virtual address where this section is (will be) mapped. When a section is mapped more than once
* (perfectly legal to do so) only the last mapping is saved. */
section->set_mapped_actual_va(va + va_offset);
/* Permissions */
unsigned mapperms=0;
if (section->get_mapped_rperm())
mapperms |= MemoryMap::READABLE;
if (section->get_mapped_wperm())
mapperms |= MemoryMap::WRITABLE;
if (section->get_mapped_xperm())
mapperms |= MemoryMap::EXECUTABLE;
/* Segment name for debugging. This is the file base name and section name concatenated. */
std::string::size_type file_basename_pos = file->get_name().find_last_of("/");
file_basename_pos = file_basename_pos==file->get_name().npos ? 0 : file_basename_pos+1;
std::string melmt_name = file->get_name().substr(file_basename_pos) + "(" + section->get_name()->get_string() + ")";
trace <<" Map element name: " <<escapeString(melmt_name) <<"\n";
/* Anonymously map the part of memory beyond the physical end of the file */
SgAsmGenericFile *file = section->get_file();
rose_addr_t total = file->get_data().size(); /*total size of file*/
if (offset+mem_size > total) {
rose_addr_t n, a;
if (offset >= total) {
/* starts beyond EOF */
n = mem_size;
a = va;
} else {
/* overlaps EOF */
n = (offset + mem_size) - total;
a = va + total - offset;
}
trace <<" Mapping part beyond EOF(" <<StringUtility::addrToString(total) <<"): "
<<"va=" <<StringUtility::addrToString(a) <<" + " <<StringUtility::addrToString(n) <<" = "
<<StringUtility::addrToString(a+n) <<"\n";
map->insert(AddressInterval::baseSize(a, n),
MemoryMap::Segment::anonymousInstance(n, mapperms|MemoryMap::PRIVATE, melmt_name));
mem_size -= n;
file_size = std::min(file_size, mem_size);
}
/* Anonymously map the part of memory beyond the part of file */
if (anon_hi && mem_size>file_size) {
rose_addr_t n = mem_size - file_size;
rose_addr_t a = va + file_size;
trace <<" Mapping part beyond end of section: va="
<<StringUtility::addrToString(a) <<" + " <<StringUtility::addrToString(n) <<" = "
<<StringUtility::addrToString(a+n) <<"\n";
map->insert(AddressInterval::baseSize(a, n),
MemoryMap::Segment::anonymousInstance(n, mapperms|MemoryMap::PRIVATE, melmt_name));
mem_size -= n;
}
/* Anonymously map the part of memory before the section */
if (anon_lo && va_offset>0 && mem_size>0) {
rose_addr_t n = va_offset - va;
rose_addr_t a = va;
trace <<" Mapping part before beginning of section: va="
<<StringUtility::addrToString(a) <<" + " <<StringUtility::addrToString(n) <<" = "
<<StringUtility::addrToString(a+n) <<"\n";
map->insert(AddressInterval::baseSize(a, n),
MemoryMap::Segment::anonymousInstance(n, mapperms|MemoryMap::PRIVATE, melmt_name));
mem_size -= n;
file_size -= n;
va += n;
offset += n;
}
/* Map the section. We use the file content as the underlying storage of the map because we might be mapping parts of
* the file left and right of the actual section. */
if (mem_size>0) {
trace <<" Mapping section: va="
<<StringUtility::addrToString(va) <<" + " <<StringUtility::addrToString(mem_size) <<" = "
<<StringUtility::addrToString(va+mem_size) <<" "
<<(map_private?"private":"shared") <<"\n";
if (map_private) {
map->insert(AddressInterval::baseSize(va, mem_size),
MemoryMap::Segment::anonymousInstance(mem_size, mapperms|MemoryMap::PRIVATE,
melmt_name));
map->at(va).limit(mem_size).write(&file->get_data()[offset]);
} else {
// Create the buffer, but the buffer should not take ownership of data from the file.
map->insert(AddressInterval::baseSize(va, mem_size),
MemoryMap::Segment(MemoryMap::StaticBuffer::instance(&file->get_data()[0],
file->get_data().size()),
offset, mapperms, melmt_name));
}
}
if (trace) {
trace <<" After mapping this section:\n";
map->dump(trace, " ");
}
}
header->set_base_va(old_base_va);
} catch(...) {
header->set_base_va(old_base_va);
throw;
}
}
