/** Parses an ELF Segment (Program Header) Table and constructs and parses all segments reachable from the table. The section * is extended as necessary based on the number of entries and teh size of each entry. */ SgAsmElfSegmentTable * SgAsmElfSegmentTable::parse() { SgAsmGenericSection::parse(); SgAsmElfFileHeader *fhdr = dynamic_cast<SgAsmElfFileHeader*>(get_header()); ROSE_ASSERT(fhdr!=NULL); ByteOrder sex = fhdr->get_sex(); size_t ent_size, struct_size, opt_size, nentries; calculate_sizes(&ent_size, &struct_size, &opt_size, &nentries); ROSE_ASSERT(opt_size==fhdr->get_phextrasz() && nentries==fhdr->get_e_phnum()); /* If the current size is very small (0 or 1 byte) then we're coming straight from the constructor and the parsing should * also extend this section to hold all the entries. Otherwise the caller must have assigned a specific size for a good * reason and we should leave that alone, reading zeros if the entries extend beyond the defined size. */ if (get_size()<=1 && get_size()<nentries*ent_size) extend(nentries*ent_size - get_size()); rose_addr_t offset=0; /* w.r.t. the beginning of this section */ for (size_t i=0; i<nentries; i++, offset+=ent_size) { /* Read/decode the segment header */ SgAsmElfSegmentTableEntry *shdr = NULL; if (4==fhdr->get_word_size()) { SgAsmElfSegmentTableEntry::Elf32SegmentTableEntry_disk disk; read_content_local(offset, &disk, struct_size); shdr = new SgAsmElfSegmentTableEntry(sex, &disk); } else { SgAsmElfSegmentTableEntry::Elf64SegmentTableEntry_disk disk; read_content_local(offset, &disk, struct_size); shdr = new SgAsmElfSegmentTableEntry(sex, &disk); } shdr->set_index(i); if (opt_size>0) shdr->get_extra() = read_content_local_ucl(offset+struct_size, opt_size); /* Null segments are just unused slots in the table; no real section to create */ if (SgAsmElfSegmentTableEntry::PT_NULL == shdr->get_type()) continue; /* Create SgAsmElfSection objects for each ELF Segment. However, if the ELF Segment Table describes a segment * that's the same offset and size as a section from the Elf Section Table (and the memory mappings are * consistent) then use the preexisting section instead of creating a new one. */ SgAsmElfSection *s = NULL; SgAsmGenericSectionPtrList possible = fhdr->get_file()->get_sections_by_offset(shdr->get_offset(), shdr->get_filesz()); for (size_t j=0; !s && j<possible.size(); j++) { if (possible[j]->get_offset()!=shdr->get_offset() || possible[j]->get_size()!=shdr->get_filesz()) continue; /*different file extent*/ if (possible[j]->is_mapped()) { if (possible[j]->get_mapped_preferred_rva()!=shdr->get_vaddr() || possible[j]->get_mapped_size()!=shdr->get_memsz()) continue; /*different mapped address or size*/ unsigned section_perms = (possible[j]->get_mapped_rperm() ? 0x01 : 0x00) | (possible[j]->get_mapped_wperm() ? 0x02 : 0x00) | (possible[j]->get_mapped_xperm() ? 0x04 : 0x00); unsigned segment_perms = (shdr->get_flags() & SgAsmElfSegmentTableEntry::PF_RPERM ? 0x01 : 0x00) | (shdr->get_flags() & SgAsmElfSegmentTableEntry::PF_WPERM ? 0x02 : 0x00) | (shdr->get_flags() & SgAsmElfSegmentTableEntry::PF_XPERM ? 0x04 : 0x00); if (section_perms != segment_perms) continue; /*different mapped permissions*/ } /* Found a match. Set memory mapping params only. */ s = dynamic_cast<SgAsmElfSection*>(possible[j]); if (!s) continue; /*potential match was not from the ELF Section or Segment table*/ if (s->get_segment_entry()) continue; /*potential match is assigned to some other segment table entry*/ s->init_from_segment_table(shdr, true); /*true=>set memory mapping params only*/ } /* Create a new segment if no matching section was found. */ if (!s) { if (SgAsmElfSegmentTableEntry::PT_NOTE == shdr->get_type()) { s = new SgAsmElfNoteSection(fhdr); } else { s = new SgAsmElfSection(fhdr); } s->init_from_segment_table(shdr); s->parse(); } } return this; }
/** Parses an ELF Section Table and constructs and parses all sections reachable from the table. The section is extended as * necessary based on the number of entries and the size of each entry. */ SgAsmElfSectionTable * SgAsmElfSectionTable::parse() { SgAsmGenericSection::parse(); SgAsmElfFileHeader *fhdr = dynamic_cast<SgAsmElfFileHeader*>(get_header()); ROSE_ASSERT(fhdr!=NULL); ByteOrder::Endianness sex = fhdr->get_sex(); size_t ent_size, struct_size, opt_size, nentries; calculate_sizes(&ent_size, &struct_size, &opt_size, &nentries); ROSE_ASSERT(opt_size==fhdr->get_shextrasz() && nentries==fhdr->get_e_shnum()); /* If the current size is very small (0 or 1 byte) then we're coming straight from the constructor and the parsing should * also extend this section to hold all the entries. Otherwise the caller must have assigned a specific size for a good * reason and we should leave that alone, reading zeros if the entries extend beyond the defined size. */ if (get_size()<=1 && get_size()<nentries*ent_size) extend(nentries*ent_size - get_size()); // Read all the section headers. Section headers are not essential to the Unix loader, which uses only segments. Therefore // we should be prepared to handle bad entries. std::vector<SgAsmElfSectionTableEntry*> entries; rose_addr_t offset = 0; try { for (size_t i=0; i<nentries; i++, offset+=ent_size) { SgAsmElfSectionTableEntry *shdr = NULL; if (4 == fhdr->get_word_size()) { SgAsmElfSectionTableEntry::Elf32SectionTableEntry_disk disk; read_content_local(offset, &disk, struct_size); shdr = new SgAsmElfSectionTableEntry(sex, &disk); } else { SgAsmElfSectionTableEntry::Elf64SectionTableEntry_disk disk; read_content_local(offset, &disk, struct_size); shdr = new SgAsmElfSectionTableEntry(sex, &disk); } if (opt_size>0) shdr->get_extra() = read_content_local_ucl(offset+struct_size, opt_size); entries.push_back(shdr); } } catch (const ShortRead &error) { mlog[ERROR] <<"short read for elf section header #" <<entries.size() <<" at file offset " <<StringUtility::addrToString(error.offset) <<" when reading " <<StringUtility::plural(error.size, "bytes") <<"\n"; mlog[ERROR] <<"expected " <<StringUtility::plural(nentries, "sections") <<", but bailing out early\n"; nentries = entries.size(); } /* This vector keeps track of which sections have already been parsed. We could get the same information by calling * fhdr->get_section_by_id() and passing the entry number since entry numbers and IDs are one and the same in ELF. However, * this is a bit easier. */ std::vector<SgAsmElfSection*> is_parsed; is_parsed.resize(entries.size(), NULL); /* All sections implicitly depend on the section string table for their names. */ SgAsmElfStringSection *section_name_strings=NULL; if (fhdr->get_e_shstrndx() > 0 && fhdr->get_e_shstrndx() < entries.size()) { SgAsmElfSectionTableEntry *entry = entries[fhdr->get_e_shstrndx()]; ASSERT_not_null(entry); section_name_strings = new SgAsmElfStringSection(fhdr); section_name_strings->init_from_section_table(entry, section_name_strings, fhdr->get_e_shstrndx()); section_name_strings->parse(); is_parsed[fhdr->get_e_shstrndx()] = section_name_strings; } /* Read all the sections. Some sections depend on other sections, so we read them in such an order that all dependencies * are satisfied first. */ while (1) { bool try_again=false; for (size_t i=0; i<entries.size(); i++) { SgAsmElfSectionTableEntry *entry = entries[i]; ROSE_ASSERT(entry->get_sh_link()<entries.size()); /* Some sections might reference another section through the sh_link member. */ bool need_linked = entry->get_sh_link() > 0; ROSE_ASSERT(!need_linked || entry->get_sh_link()<entries.size()); SgAsmElfSection *linked = need_linked ? is_parsed[entry->get_sh_link()] : NULL; /* Relocation sections might have a second linked section stored in sh_info. */ bool need_info_linked = (entry->get_sh_type() == SgAsmElfSectionTableEntry::SHT_REL || entry->get_sh_type() == SgAsmElfSectionTableEntry::SHT_RELA) && entry->get_sh_info() > 0; ROSE_ASSERT(!need_info_linked || entry->get_sh_info()<entries.size()); SgAsmElfSection *info_linked = need_info_linked ? is_parsed[entry->get_sh_info()] : NULL; if (is_parsed[i]) { /* This section has already been parsed. */ } else if ((need_linked && !linked) || (need_info_linked && !info_linked)) { /* Don't parse this section yet because it depends on something that's not parsed yet. */ try_again = true; } else { switch (entry->get_sh_type()) { case SgAsmElfSectionTableEntry::SHT_NULL: /* Null entry. We still create the section just to hold the section header. */ is_parsed[i] = new SgAsmElfSection(fhdr); break; case SgAsmElfSectionTableEntry::SHT_NOBITS: /* These types of sections don't occupy any file space (e.g., BSS) */ is_parsed[i] = new SgAsmElfSection(fhdr); break; case SgAsmElfSectionTableEntry::SHT_DYNAMIC: { SgAsmElfStringSection *strsec = dynamic_cast<SgAsmElfStringSection*>(linked); ROSE_ASSERT(strsec); is_parsed[i] = new SgAsmElfDynamicSection(fhdr, strsec); break; } case SgAsmElfSectionTableEntry::SHT_DYNSYM: { SgAsmElfStringSection *strsec = dynamic_cast<SgAsmElfStringSection*>(linked); ROSE_ASSERT(strsec); SgAsmElfSymbolSection *symsec = new SgAsmElfSymbolSection(fhdr, strsec); symsec->set_is_dynamic(true); is_parsed[i] = symsec; break; } case SgAsmElfSectionTableEntry::SHT_SYMTAB: { SgAsmElfStringSection *strsec = dynamic_cast<SgAsmElfStringSection*>(linked); ROSE_ASSERT(strsec); SgAsmElfSymbolSection *symsec = new SgAsmElfSymbolSection(fhdr, strsec); symsec->set_is_dynamic(false); is_parsed[i] = symsec; break; } case SgAsmElfSectionTableEntry::SHT_STRTAB: is_parsed[i] = new SgAsmElfStringSection(fhdr); break; case SgAsmElfSectionTableEntry::SHT_REL: { SgAsmElfSymbolSection *symbols = dynamic_cast<SgAsmElfSymbolSection*>(linked); SgAsmElfRelocSection *relocsec = new SgAsmElfRelocSection(fhdr, symbols, info_linked); relocsec->set_uses_addend(false); is_parsed[i] = relocsec; break; } case SgAsmElfSectionTableEntry::SHT_RELA: { SgAsmElfSymbolSection *symbols = dynamic_cast<SgAsmElfSymbolSection*>(linked); SgAsmElfRelocSection *relocsec = new SgAsmElfRelocSection(fhdr, symbols, info_linked); relocsec->set_uses_addend(true); is_parsed[i] = relocsec; break; } case SgAsmElfSectionTableEntry::SHT_PROGBITS: { if (!section_name_strings) { fprintf(stderr, "SgAsmElfSectionTable::parse(): no string table for section table\n"); is_parsed[i] = new SgAsmElfSection(fhdr); } else { std::string section_name = section_name_strings->read_content_local_str(entry->get_sh_name()); if (section_name == ".eh_frame") { is_parsed[i] = new SgAsmElfEHFrameSection(fhdr); } else { is_parsed[i] = new SgAsmElfSection(fhdr); } } break; } case SgAsmElfSectionTableEntry::SHT_GNU_versym: { is_parsed[i] = new SgAsmElfSymverSection(fhdr); break; } case SgAsmElfSectionTableEntry::SHT_GNU_verdef: { SgAsmElfStringSection *strsec = dynamic_cast<SgAsmElfStringSection*>(linked); ROSE_ASSERT(strsec); is_parsed[i] = new SgAsmElfSymverDefinedSection(fhdr,strsec); break; } case SgAsmElfSectionTableEntry::SHT_GNU_verneed: { SgAsmElfStringSection *strsec = dynamic_cast<SgAsmElfStringSection*>(linked); ROSE_ASSERT(strsec); is_parsed[i] = new SgAsmElfSymverNeededSection(fhdr,strsec); break; } default: is_parsed[i] = new SgAsmElfSection(fhdr); break; } is_parsed[i]->init_from_section_table(entry, section_name_strings, i); is_parsed[i]->parse(); } } if (!try_again) break; } /* Initialize links between sections */ for (size_t i = 0; i < entries.size(); i++) { SgAsmElfSectionTableEntry *shdr = entries[i]; if (shdr->get_sh_link() > 0) { SgAsmElfSection *source = isSgAsmElfSection(fhdr->get_file()->get_section_by_id(i)); SgAsmElfSection *target = isSgAsmElfSection(fhdr->get_file()->get_section_by_id(shdr->get_sh_link())); assert(source); /* because we created it above */ source->set_linked_section(target); } } /* Finish parsing sections now that we have basic info for all the sections. */ for (size_t i=0; i<is_parsed.size(); i++) is_parsed[i]->finish_parsing(); return this; }