/** Attaches a previously unattached PE Section to the PE Section Table. This method complements * SgAsmPESection::init_from_section_table. This method initializes the section table from the section while * init_from_section_table() initializes the section from the section table. */ void SgAsmPESectionTable::add_section(SgAsmPESection *section) { ROSE_ASSERT(section!=NULL); ROSE_ASSERT(section->get_file()==get_file()); ROSE_ASSERT(section->get_header()==get_header()); ROSE_ASSERT(section->get_section_entry()==NULL); /* must not be in the section table yet */ SgAsmPEFileHeader *fhdr = dynamic_cast<SgAsmPEFileHeader*>(get_header()); ROSE_ASSERT(fhdr!=NULL); /* Assign an ID if there isn't one yet. */ if (section->get_id()<0) { SgAsmGenericSectionList *seclist = fhdr->get_sections();; int max_id=0; /*assume zero is used so we start at one*/ for (size_t i=0; i<seclist->get_sections().size(); i++) { SgAsmGenericSection *s = seclist->get_sections()[i]; max_id = std::max(max_id, s->get_id()); } section->set_id(max_id+1); } /* Create a new section table entry. */ SgAsmPESectionTableEntry *entry = new SgAsmPESectionTableEntry; entry->update_from_section(section); section->set_section_entry(entry); }
/* Creates the storage item for the string at the specified offset. If "shared" is true then attempt to re-use a previous storage * object, otherwise create a new one. Each storage object is considered to be a separate string, therefore when two strings * share the same storage object, changing one string changes the other. */ SgAsmStringStorage * SgAsmCoffStrtab::create_storage(rose_addr_t offset, bool shared) { ROSE_ASSERT(offset!=SgAsmGenericString::unallocated); SgAsmGenericSection *container = get_container(); /* Has the string already been created? */ if (shared) { for (referenced_t::iterator i=p_storage_list.begin(); i!=p_storage_list.end(); ++i) { if ((*i)->get_offset()==offset && (*i)!=p_dont_free) return *i; } } /* Read string length byte */ unsigned char byte; container->read_content_local(offset, &byte, 1); unsigned len = byte; /* Make sure new storage isn't inside some other string. (We don't support nested strings in COFF where the length byte of * the nested string is one of the characters of the outer string.) */ for (referenced_t::iterator i=p_storage_list.begin(); i!=p_storage_list.end(); ++i) { ROSE_ASSERT((*i)->get_offset()==SgAsmGenericString::unallocated || offset + 1 + len <= (*i)->get_offset() || offset >= 1 + (*i)->get_string().size()); } /* Create storage object */ char *buf = new char[len]; container->read_content_local(offset+1, buf, len); SgAsmStringStorage *storage = new SgAsmStringStorage(this, std::string(buf, len), offset); delete[] buf; /* It's a bad idea to free (e.g., modify) strings before we've identified all the strings in the table. Consider * the case where two strings have the same value and point to the same offset (i.e., they share storage). If we modify one * before we know about the other then (at best) we modify the other one also. * * The only time we can guarantee this is OK is when the new storage points to the same file location as "dont_free" * since the latter is guaranteed to never be freed or shared. This exception is used when creating a new, unallocated * string (see SgAsmStoredString(SgAsmGenericStrtab,const std::string&)). */ if (p_num_freed>0 && (!p_dont_free || offset!=p_dont_free->get_offset())) { fprintf(stderr, "SgAsmCoffStrtab::create_storage(%"PRIu64"): %zu other string%s (of %zu created) in [%d] \"%s\"" " %s been modified and/or reallocated!\n", offset, p_num_freed, 1==p_num_freed?"":"s", p_storage_list.size(), container->get_id(), container->get_name()->get_string(true).c_str(), 1==p_num_freed?"has":"have"); ROSE_ASSERT(0==p_num_freed); } set_isModified(true); p_storage_list.push_back(storage); return storage; }
/** Class method that prints info about offsets into known sections */ void SgAsmGenericSection::dump_containing_sections(FILE *f, const std::string &prefix, rose_rva_t rva, const SgAsmGenericSectionPtrList &slist) { for (size_t i=0; i<slist.size(); i++) { SgAsmGenericSection *s = slist[i]; if (s->is_mapped() && rva>=s->get_mapped_preferred_rva() && rva<s->get_mapped_preferred_rva()+s->get_mapped_size()) { rose_addr_t offset = rva - s->get_mapped_preferred_rva(); fprintf(f, "%-*s is 0x%08"PRIx64" (%"PRIu64") bytes into section [%d] \"%s\"\n", DUMP_FIELD_WIDTH, prefix.c_str(), offset, offset, s->get_id(), s->get_name()->get_string(true).c_str()); } } }
void SgAsmGenericFile::shift_extend(SgAsmGenericSection *s, rose_addr_t sa, rose_addr_t sn, AddressSpace space, Elasticity elasticity) { ROSE_ASSERT(s!=NULL); ROSE_ASSERT(s->get_file()==this); ROSE_ASSERT((space & (ADDRSP_FILE|ADDRSP_MEMORY)) != 0); const bool debug = false; static size_t ncalls=0; char p[256]; if (debug) { const char *space_s="unknown"; if (space & ADDRSP_FILE) { space_s = "file"; } else if (space & ADDRSP_MEMORY) { space_s = "memory"; } sprintf(p, "SgAsmGenericFile::shift_extend[%" PRIuPTR "]: ", ncalls++); fprintf(stderr, "%s -- START --\n", p); fprintf(stderr, "%s S = [%d] \"%s\"\n", p, s->get_id(), s->get_name()->get_string(true).c_str()); fprintf(stderr, "%s %s Sa=0x%08" PRIx64 " (%" PRIu64 "), Sn=0x%08" PRIx64 " (%" PRIu64 ")\n", p, space_s, sa, sa, sn, sn); fprintf(stderr, "%s elasticity = %s\n", p, (ELASTIC_NONE==elasticity ? "none" : ELASTIC_UNREF==elasticity ? "unref" : ELASTIC_HOLE==elasticity ? "unref+holes" : "unknown")); } /* No-op case */ if (0==sa && 0==sn) { if (debug) { fprintf(stderr, "%s No change necessary.\n", p); fprintf(stderr, "%s -- END --\n", p); } return; } bool filespace = (space & ADDRSP_FILE)!=0; bool memspace = (space & ADDRSP_MEMORY)!=0; rose_addr_t align=1, aligned_sa, aligned_sasn; SgAsmGenericSectionPtrList neighbors, villagers; ExtentMap amap; /* address mappings for all extents */ Extent sp; /* Get a list of all sections that may need to be adjusted. */ SgAsmGenericSectionPtrList all; switch (elasticity) { case ELASTIC_NONE: case ELASTIC_UNREF: all = filespace ? get_sections() : get_mapped_sections(); break; case ELASTIC_HOLE: all = filespace ? get_sections(false) : get_mapped_sections(); break; } if (debug) { fprintf(stderr, "%s Following sections are in 'all' set:\n", p); for (size_t i=0; i<all.size(); i++) { Extent ep; if (filespace) { ep = all[i]->get_file_extent(); } else { ROSE_ASSERT(all[i]->is_mapped()); ep = all[i]->get_mapped_preferred_extent(); } fprintf(stderr, "%s 0x%08" PRIx64 " 0x%08" PRIx64 " 0x%08" PRIx64 " [%d] \"%s\"\n", p, ep.relaxed_first(), ep.size(), ep.relaxed_first()+ep.size(), all[i]->get_id(), all[i]->get_name()->get_string(true).c_str()); } } for (size_t pass=0; pass<2; pass++) { if (debug) { fprintf(stderr, "%s -- %s --\n", p, 0==pass?"FIRST PASS":"******"); } /* S offset and size in file or memory address space */ if (filespace) { sp = s->get_file_extent(); } else if (!memspace || !s->is_mapped()) { return; /*nothing to do*/ } else { sp = s->get_mapped_preferred_extent(); } /* Build address map */ for (size_t i=0; i<all.size(); i++) { if (filespace) { amap.insert(all[i]->get_file_extent()); } else { ROSE_ASSERT(all[i]->is_mapped()); amap.insert(all[i]->get_mapped_preferred_extent()); } } if (debug) { fprintf(stderr, "%s Address map:\n", p); amap.dump_extents(stderr, (std::string(p)+" ").c_str(), "amap"); fprintf(stderr, "%s Extent of S:\n", p); fprintf(stderr, "%s start=0x%08" PRIx64 " size=0x%08" PRIx64 " end=0x%08" PRIx64 "\n", p, sp.relaxed_first(), sp.size(), sp.relaxed_first()+sp.size()); } /* Neighborhood (nhs) of S is a single extent. However, if S is zero size then nhs might be empty. The neighborhood of * S is S plus all sections that overlap with S and all sections that are right-contiguous with S. */ ExtentMap nhs_map; for (ExtentMap::iterator amapi=amap.begin(); amapi!=amap.end(); ++amapi) { if (amapi->first.relaxed_first() <= sp.relaxed_first()+sp.size() && amapi->first.relaxed_first()+amapi->first.size() > sp.relaxed_first()) nhs_map.insert(amapi->first, amapi->second); } if (debug) { fprintf(stderr, "%s Neighborhood of S:\n", p); nhs_map.dump_extents(stderr, (std::string(p)+" ").c_str(), "nhs_map"); } Extent nhs; if (nhs_map.size()>0) { assert(nhs_map.nranges()==1); nhs = nhs_map.begin()->first; } else { nhs = sp; } /* What sections are in the neighborhood (including S), and right of the neighborhood? */ neighbors.clear(); /*sections in neighborhood*/ neighbors.push_back(s); villagers.clear(); /*sections right of neighborhood*/ if (debug) fprintf(stderr, "%s Ignoring left (L) sections:\n", p); for (size_t i=0; i<all.size(); i++) { SgAsmGenericSection *a = all[i]; if (a==s) continue; /*already pushed onto neighbors*/ Extent ap; if (filespace) { ap = a->get_file_extent(); } else if (!a->is_mapped()) { continue; } else { ap = a->get_mapped_preferred_extent(); } switch (ExtentMap::category(ap, nhs)) { case 'L': if (debug) fprintf(stderr, "%s L 0x%08" PRIx64 " 0x%08" PRIx64 " 0x%08" PRIx64 " [%d] \"%s\"\n", p, ap.relaxed_first(), ap.size(), ap.relaxed_first()+ap.size(), a->get_id(), a->get_name()->get_string(true).c_str()); break; case 'R': if (ap.relaxed_first()==nhs.relaxed_first()+nhs.size() && 0==ap.size()) { /* Empty sections immediately right of the neighborhood of S should actually be considered part of the * neighborhood rather than right of it. */ neighbors.push_back(a); } else if (elasticity!=ELASTIC_NONE) { /* If holes are elastic then treat things right of the hole as being part of the right village; otherwise * add those sections to the neighborhood of S even though they fall outside 'nhs' (it's OK because this * partitioning of sections is the only thing we use 'nhs' for anyway. */ villagers.push_back(a); } else if ('L'==ExtentMap::category(ap, sp)) { /*ignore sections left of S*/ } else { neighbors.push_back(a); } break; default: if ('L'!=ExtentMap::category(ap, sp)) /*ignore sections left of S*/ neighbors.push_back(a); break; } } if (debug) { fprintf(stderr, "%s Neighbors:\n", p); for (size_t i=0; i<neighbors.size(); i++) { SgAsmGenericSection *a = neighbors[i]; Extent ap = filespace ? a->get_file_extent() : a->get_mapped_preferred_extent(); rose_addr_t align = filespace ? a->get_file_alignment() : a->get_mapped_alignment(); char cat = ExtentMap::category(ap, sp); fprintf(stderr, "%s %c %c0x%08" PRIx64 " 0x%08" PRIx64 " 0x%08" PRIx64, p, cat, 0==ap.relaxed_first() % (align?align:1) ? ' ' : '!', ap.relaxed_first(), ap.size(), ap.relaxed_first()+ap.size()); if (strchr("RICE", cat)) { fprintf(stderr, " align=0x%08" PRIx64, align); } else { fputs(" ", stderr); } fprintf(stderr, " [%2d] \"%s\"\n", a->get_id(), a->get_name()->get_string(true).c_str()); } if (villagers.size()>0) fprintf(stderr, "%s Villagers:\n", p); for (size_t i=0; i<villagers.size(); i++) { SgAsmGenericSection *a = villagers[i]; Extent ap = filespace ? a->get_file_extent() : a->get_mapped_preferred_extent(); rose_addr_t align = filespace ? a->get_file_alignment() : a->get_mapped_alignment(); fprintf(stderr, "%s %c %c0x%08" PRIx64 " 0x%08" PRIx64 " 0x%08" PRIx64, p, ExtentMap::category(ap, sp), /*cat should always be R*/ 0==ap.relaxed_first() % (align?align:1) ? ' ' : '!', ap.relaxed_first(), ap.size(), ap.relaxed_first()+ap.size()); fputs(" ", stderr); fprintf(stderr, " [%2d] \"%s\"\n", a->get_id(), a->get_name()->get_string(true).c_str()); } } /* Adjust Sa to satisfy all alignment constraints in neighborhood(S) for sections that will move (cats R, I, C, and E). */ align = 1; for (size_t i=0; i<neighbors.size(); i++) { SgAsmGenericSection *a = neighbors[i]; Extent ap = filespace ? a->get_file_extent() : a->get_mapped_preferred_extent(); if (strchr("RICE", ExtentMap::category(ap, sp))) { rose_addr_t x = filespace ? a->get_file_alignment() : a->get_mapped_alignment(); #if BOOST_VERSION < 106900 align = boost::math::lcm(align, x?x:1); // deprecated in boost-1.69.0 #else align = boost::integer::lcm(align, x?x:1); // not present before boost-1.60.0 #endif } } aligned_sa = (sa/align + (sa%align?1:0))*align; aligned_sasn = ((sa+sn)/align + ((sa+sn)%align?1:0))*align; if (debug) { fprintf(stderr, "%s Alignment LCM = 0x%08" PRIx64 " (%" PRIu64 ")\n", p, align, align); fprintf(stderr, "%s Aligned Sa = 0x%08" PRIx64 " (%" PRIu64 ")\n", p, aligned_sa, aligned_sa); fprintf(stderr, "%s Aligned Sa+Sn = 0x%08" PRIx64 " (%" PRIu64 ")\n", p, aligned_sasn, aligned_sasn); } /* Are there any sections to the right of neighborhood(S)? If so, find the one with the lowest start address and use * that to define the size of the hole right of neighborhood(S). */ if (0==villagers.size()) break; SgAsmGenericSection *after_hole = NULL; Extent hp(0, 0); for (size_t i=0; i<villagers.size(); i++) { SgAsmGenericSection *a = villagers[i]; Extent ap = filespace ? a->get_file_extent() : a->get_mapped_preferred_extent(); if (!after_hole || ap.relaxed_first()<hp.relaxed_first()) { after_hole = a; hp = ap; } } ROSE_ASSERT(after_hole); ROSE_ASSERT(hp.relaxed_first() > nhs.relaxed_first()+nhs.size()); rose_addr_t hole_size = hp.relaxed_first() - (nhs.relaxed_first()+nhs.size()); if (debug) { fprintf(stderr, "%s hole size = 0x%08" PRIx64 " (%" PRIu64 "); need 0x%08" PRIx64 " (%" PRIu64 "); %s\n", p, hole_size, hole_size, aligned_sasn, aligned_sasn, hole_size>=aligned_sasn ? "large enough" : "not large enough"); } if (hole_size >= aligned_sasn) break; rose_addr_t need_more = aligned_sasn - hole_size; /* Hole is not large enough. We need to recursively move things that are right of our neighborhood, then recompute the * all-sections address map and neighborhood(S). */ ROSE_ASSERT(0==pass); /*logic problem since the recursive call should have enlarged the hole enough*/ if (debug) { fprintf(stderr, "%s Calling recursively to increase hole size by 0x%08" PRIx64 " (%" PRIu64 ") bytes\n", p, need_more, need_more); } shift_extend(after_hole, need_more, 0, space, elasticity); if (debug) fprintf(stderr, "%s Returned from recursive call\n", p); } /* Consider sections that are in the same neighborhood as S */ if (debug) fprintf(stderr, "%s -- ADJUSTING --\n", p); bool resized_mem = false; for (size_t i=0; i<neighbors.size(); i++) { SgAsmGenericSection *a = neighbors[i]; Extent ap = filespace ? a->get_file_extent() : a->get_mapped_preferred_extent(); switch (ExtentMap::category(ap, sp)) { case 'L': break; case 'R': if (filespace) { a->set_offset(a->get_offset()+aligned_sasn); } else { a->set_mapped_preferred_rva(a->get_mapped_preferred_rva()+aligned_sasn); } break; case 'C': /*including S itself*/ case 'E': if (filespace) { a->set_offset(a->get_offset()+aligned_sa); a->set_size(a->get_size()+sn); if (memspace && !resized_mem && a->is_mapped()) { shift_extend(a, 0, sn, ADDRSP_MEMORY, elasticity); resized_mem = true; } } else { a->set_mapped_preferred_rva(a->get_mapped_preferred_rva()+aligned_sa); a->set_mapped_size(a->get_mapped_size()+sn); } break; case 'O': if (ap.relaxed_first()==sp.relaxed_first()) { if (filespace) { a->set_offset(a->get_offset()+aligned_sa); a->set_size(a->get_size()+sn); } else { a->set_mapped_preferred_rva(a->get_mapped_preferred_rva()+aligned_sa); a->set_mapped_size(a->get_mapped_size()+sn); } } else { if (filespace) { a->set_size(a->get_size()+aligned_sasn); if (memspace && !resized_mem && a->is_mapped()) { shift_extend(a, 0, aligned_sasn, ADDRSP_MEMORY, elasticity); resized_mem = true; } } else { a->set_mapped_size(a->get_mapped_size()+aligned_sasn); } } break; case 'I': if (filespace) { a->set_offset(a->get_offset()+aligned_sa); } else { a->set_mapped_preferred_rva(a->get_mapped_preferred_rva()+aligned_sa); } break; case 'B': if (filespace) { a->set_size(a->get_size()+sn); if (memspace && !resized_mem && a->is_mapped()) { shift_extend(a, 0, sn, ADDRSP_MEMORY, elasticity); resized_mem = true; } } else { a->set_mapped_size(a->get_size()+sn); } break; default: ROSE_ASSERT(!"invalid extent category"); break; } if (debug) { const char *space_name = filespace ? "file" : "mem"; rose_addr_t x = filespace ? a->get_file_alignment() : a->get_mapped_alignment(); fprintf(stderr, "%s %4s-%c %c0x%08" PRIx64 " 0x%08" PRIx64 " 0x%08" PRIx64, p, space_name, ExtentMap::category(ap, sp), 0==ap.relaxed_first()%(x?x:1)?' ':'!', ap.relaxed_first(), ap.size(), ap.relaxed_first()+ap.size()); Extent newap = filespace ? a->get_file_extent() : a->get_mapped_preferred_extent(); fprintf(stderr, " -> %c0x%08" PRIx64 " 0x%08" PRIx64 " 0x%08" PRIx64, 0==newap.relaxed_first()%(x?x:1)?' ':'!', newap.relaxed_first(), newap.size(), newap.relaxed_first()+newap.size()); fprintf(stderr, " [%2d] \"%s\"\n", a->get_id(), a->get_name()->get_string(true).c_str()); } } if (debug) fprintf(stderr, "%s -- END --\n", p); }
SgAsmGenericSection * SgAsmGenericFile::get_best_possible_section_by_va(rose_addr_t va) { // This function is implemented for use in: // "DisassemblerCommon::AsmFileWithData::getSectionOfAddress(uint64_t addr)" // It supports a more restrictive selection of valid sections to associate with // a given address so that we can avoid disassembly of sections that are not code. const std::vector<SgAsmGenericSection*> &possible = get_sections_by_va(va); if (0 == possible.size()) { return NULL; } else { if (1 == possible.size()) { // printf ("Only one alternative: va = %p possible[0] id = %d name = %s (return %s) \n", // (void*)va,possible[0]->get_id(),possible[0]->get_name().c_str(),(possible[0]->get_id() < 0) ? "NULL" : "it"); // return possible[0]; if (possible[0]->get_id() < 0) return NULL; else return possible[0]; } } #if 0 printf ("Select from %" PRIuPTR " alternatives \n",possible.size()); for (size_t i = 0; i < possible.size(); i++) { printf (" va = %p possible[%" PRIuPTR "] id = %d name = %s \n",(void*)va,i,possible[i]->get_id(),possible[i]->get_name().c_str()); } #endif /* Choose the "best" section to return. */ SgAsmGenericSection *best = possible[0]; rose_addr_t fo0 = possible[0]->get_va_offset(va); for (size_t i = 1; i < possible.size(); i++) { if (fo0 != possible[i]->get_va_offset(va)) return NULL; /* all possible sections must map the VA to the same file offset */ if (best->get_id() < 0 && possible[i]->get_id() > 0) { best = possible[i]; /*prefer sections defined in a section or object table*/ } else if (best->get_mapped_size() > possible[i]->get_mapped_size()) { best = possible[i]; /*prefer sections with a smaller mapped size*/ } else if (best->get_name()->get_string().size()==0 && possible[i]->get_name()->get_string().size()>0) { best = possible[i]; /*prefer sections having a name*/ } else { /* prefer section defined earlier*/ } } ROSE_ASSERT(best != NULL); // Add a few things that we just don't want to disassemble if (best->get_name()->get_string() == "ELF Segment Table") return NULL; // printf (" best: va = %p id = %d name = %s \n",(void*)va,best->get_id(),best->get_name().c_str()); return best; }
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; } }
/* Print some debugging info */ void SgAsmGenericHeader::dump(FILE *f, const char *prefix, ssize_t idx) const { char p[4096]; if (idx>=0) { sprintf(p, "%sHeader[%zd].", prefix, idx); } else { sprintf(p, "%sHeader.", prefix); } const int w = std::max(1, DUMP_FIELD_WIDTH-(int)strlen(p)); SgAsmGenericSection::dump(f, p, -1); ROSE_ASSERT(p_exec_format != NULL); p_exec_format->dump(f, p, -1); fprintf(f, "%s%-*s = 0x%x (%s)\n", p, w, "ins_arch", p_isa, stringifySgAsmExecutableFileFormatInsSetArchitecture(p_isa).c_str()); fprintf(f, "%s%-*s = \"", p, w, "magic"); for (size_t i = 0; i < p_magic.size(); i++) { switch (p_magic[i]) { case '\\': fputs("\\\\", f); break; case '\n': fputs("\\n", f); break; case '\r': fputs("\\r", f); break; case '\t': fputs("\\t", f); break; default: if (isprint(p_magic[i])) { fputc(p_magic[i], f); } else { fprintf(f, "\\%03o", (unsigned)p_magic[i]); } break; } } fputs("\"\n", f); /* Base virtual address and entry addresses */ fprintf(f, "%s%-*s = 0x%08" PRIx64" (%" PRIu64")\n", p, w, "base_va", get_base_va(), get_base_va()); fprintf(f, "%s%-*s = %" PRIuPTR " entry points\n", p, w, "entry_rva.size", p_entry_rvas.size()); for (size_t i = 0; i < p_entry_rvas.size(); i++) { char label[64]; sprintf(label, "entry_rva[%" PRIuPTR "]", i); rose_addr_t entry_rva = p_entry_rvas[i].get_rva(); fprintf(f, "%s%-*s = 0x%08" PRIx64 " (%" PRIu64 ")\n", p, w, label, entry_rva, entry_rva); SgAsmGenericSectionPtrList sections = get_file()->get_sections(); dump_containing_sections(f, std::string(p)+label, entry_rva, sections); } fprintf(f, "%s%-*s = %" PRIuPTR " sections\n", p, w, "section", p_sections->get_sections().size()); for (size_t i=0; i<p_sections->get_sections().size(); i++) { SgAsmGenericSection *section = p_sections->get_sections()[i]; char label[1024]; sprintf(label, "section[%" PRIuPTR "]", i); fprintf(f, "%s%-*s = [%d] \"%s\"\n", p, w, label, section->get_id(), section->get_name()->get_string(true).c_str()); } fprintf(f, "%s%-*s = %" PRIuPTR " entries\n", p, w, "DLL.size", p_dlls->get_dlls().size()); for (size_t i = 0; i < p_dlls->get_dlls().size(); i++) p_dlls->get_dlls()[i]->dump(f, p, i); }