| #include "common/linux/synth_elf.h" |
| |
| #include <assert.h> |
| #include <elf.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include "common/linux/elf_gnu_compat.h" |
| #include "common/using_std_string.h" |
| |
| namespace google_breakpad { |
| namespace synth_elf { |
| |
| ELF::ELF(uint16_t machine, |
| uint8_t file_class, |
| Endianness endianness) |
| : Section(endianness), |
| addr_size_(file_class == ELFCLASS64 ? 8 : 4), |
| program_count_(0), |
| program_header_table_(endianness), |
| section_count_(0), |
| section_header_table_(endianness), |
| section_header_strings_(endianness) { |
| // Could add support for more machine types here if needed. |
| assert(machine == EM_386 || |
| machine == EM_X86_64 || |
| machine == EM_ARM); |
| assert(file_class == ELFCLASS32 || file_class == ELFCLASS64); |
| |
| start() = 0; |
| // Add ELF header |
| // e_ident |
| // EI_MAG0...EI_MAG3 |
| D8(ELFMAG0); |
| D8(ELFMAG1); |
| D8(ELFMAG2); |
| D8(ELFMAG3); |
| // EI_CLASS |
| D8(file_class); |
| // EI_DATA |
| D8(endianness == kLittleEndian ? ELFDATA2LSB : ELFDATA2MSB); |
| // EI_VERSION |
| D8(EV_CURRENT); |
| // EI_OSABI |
| D8(ELFOSABI_SYSV); |
| // EI_ABIVERSION |
| D8(0); |
| // EI_PAD |
| Append(7, 0); |
| assert(Size() == EI_NIDENT); |
| |
| // e_type |
| D16(ET_EXEC); //TODO: allow passing ET_DYN? |
| // e_machine |
| D16(machine); |
| // e_version |
| D32(EV_CURRENT); |
| // e_entry |
| Append(endianness, addr_size_, 0); |
| // e_phoff |
| Append(endianness, addr_size_, program_header_label_); |
| // e_shoff |
| Append(endianness, addr_size_, section_header_label_); |
| // e_flags |
| D32(0); |
| // e_ehsize |
| D16(addr_size_ == 8 ? sizeof(Elf64_Ehdr) : sizeof(Elf32_Ehdr)); |
| // e_phentsize |
| D16(addr_size_ == 8 ? sizeof(Elf64_Phdr) : sizeof(Elf32_Phdr)); |
| // e_phnum |
| D16(program_count_label_); |
| // e_shentsize |
| D16(addr_size_ == 8 ? sizeof(Elf64_Shdr) : sizeof(Elf32_Shdr)); |
| // e_shnum |
| D16(section_count_label_); |
| // e_shstrndx |
| D16(section_header_string_index_); |
| |
| // Add an empty section for SHN_UNDEF. |
| Section shn_undef; |
| AddSection("", shn_undef, SHT_NULL); |
| } |
| |
| int ELF::AddSection(const string& name, const Section& section, |
| uint32_t type, uint32_t flags, uint64_t addr, |
| uint32_t link, uint64_t entsize, uint64_t offset) { |
| Label offset_label; |
| Label string_label(section_header_strings_.Add(name)); |
| size_t size = section.Size(); |
| |
| int index = section_count_; |
| ++section_count_; |
| |
| section_header_table_ |
| // sh_name |
| .D32(string_label) |
| // sh_type |
| .D32(type) |
| // sh_flags |
| .Append(endianness(), addr_size_, flags) |
| // sh_addr |
| .Append(endianness(), addr_size_, addr) |
| // sh_offset |
| .Append(endianness(), addr_size_, offset_label) |
| // sh_size |
| .Append(endianness(), addr_size_, size) |
| // sh_link |
| .D32(link) |
| // sh_info |
| .D32(0) |
| // sh_addralign |
| .Append(endianness(), addr_size_, 0) |
| // sh_entsize |
| .Append(endianness(), addr_size_, entsize); |
| |
| sections_.push_back(ElfSection(section, type, addr, offset, offset_label, |
| size)); |
| return index; |
| } |
| |
| void ELF::AppendSection(ElfSection& section) { |
| // NULL and NOBITS sections have no content, so they |
| // don't need to be written to the file. |
| if (section.type_ == SHT_NULL) { |
| section.offset_label_ = 0; |
| } else if (section.type_ == SHT_NOBITS) { |
| section.offset_label_ = section.offset_; |
| } else { |
| Mark(§ion.offset_label_); |
| Append(section); |
| Align(4); |
| } |
| } |
| |
| void ELF::AddSegment(int start, int end, uint32_t type, uint32_t flags) { |
| assert(start > 0); |
| assert(size_t(start) < sections_.size()); |
| assert(end > 0); |
| assert(size_t(end) < sections_.size()); |
| ++program_count_; |
| |
| // p_type |
| program_header_table_.D32(type); |
| |
| if (addr_size_ == 8) { |
| // p_flags |
| program_header_table_.D32(flags); |
| } |
| |
| size_t filesz = 0; |
| size_t memsz = 0; |
| bool prev_was_nobits = false; |
| for (int i = start; i <= end; ++i) { |
| size_t size = sections_[i].size_; |
| if (sections_[i].type_ != SHT_NOBITS) { |
| assert(!prev_was_nobits); |
| // non SHT_NOBITS sections are 4-byte aligned (see AddSection) |
| size = (size + 3) & ~3; |
| filesz += size; |
| } else { |
| prev_was_nobits = true; |
| } |
| memsz += size; |
| } |
| |
| program_header_table_ |
| // p_offset |
| .Append(endianness(), addr_size_, sections_[start].offset_label_) |
| // p_vaddr |
| .Append(endianness(), addr_size_, sections_[start].addr_) |
| // p_paddr |
| .Append(endianness(), addr_size_, sections_[start].addr_) |
| // p_filesz |
| .Append(endianness(), addr_size_, filesz) |
| // p_memsz |
| .Append(endianness(), addr_size_, memsz); |
| |
| if (addr_size_ == 4) { |
| // p_flags |
| program_header_table_.D32(flags); |
| } |
| |
| // p_align |
| program_header_table_.Append(endianness(), addr_size_, 0); |
| } |
| |
| void ELF::Finish() { |
| // Add the section header string table at the end. |
| section_header_string_index_ = section_count_; |
| //printf(".shstrtab size: %ld\n", section_header_strings_.Size()); |
| AddSection(".shstrtab", section_header_strings_, SHT_STRTAB); |
| //printf("section_count_: %ld, sections_.size(): %ld\n", |
| // section_count_, sections_.size()); |
| if (program_count_) { |
| Mark(&program_header_label_); |
| Append(program_header_table_); |
| } else { |
| program_header_label_ = 0; |
| } |
| |
| for (vector<ElfSection>::iterator it = sections_.begin(); |
| it < sections_.end(); ++it) { |
| AppendSection(*it); |
| } |
| section_count_label_ = section_count_; |
| program_count_label_ = program_count_; |
| |
| // Section header table starts here. |
| Mark(§ion_header_label_); |
| Append(section_header_table_); |
| } |
| |
| SymbolTable::SymbolTable(Endianness endianness, |
| size_t addr_size, |
| StringTable& table) : Section(endianness), |
| table_(table) { |
| #ifndef NDEBUG |
| addr_size_ = addr_size; |
| #endif |
| assert(addr_size_ == 4 || addr_size_ == 8); |
| } |
| |
| void SymbolTable::AddSymbol(const string& name, uint32_t value, |
| uint32_t size, unsigned info, uint16_t shndx) { |
| assert(addr_size_ == 4); |
| D32(table_.Add(name)); |
| D32(value); |
| D32(size); |
| D8(info); |
| D8(0); // other |
| D16(shndx); |
| } |
| |
| void SymbolTable::AddSymbol(const string& name, uint64_t value, |
| uint64_t size, unsigned info, uint16_t shndx) { |
| assert(addr_size_ == 8); |
| D32(table_.Add(name)); |
| D8(info); |
| D8(0); // other |
| D16(shndx); |
| D64(value); |
| D64(size); |
| } |
| |
| void Notes::AddNote(int type, const string& name, const uint8_t* desc_bytes, |
| size_t desc_size) { |
| // Elf32_Nhdr and Elf64_Nhdr are exactly the same. |
| Elf32_Nhdr note_header; |
| memset(¬e_header, 0, sizeof(note_header)); |
| note_header.n_namesz = name.length() + 1; |
| note_header.n_descsz = desc_size; |
| note_header.n_type = type; |
| |
| Append(reinterpret_cast<const uint8_t*>(¬e_header), |
| sizeof(note_header)); |
| AppendCString(name); |
| Align(4); |
| Append(desc_bytes, desc_size); |
| Align(4); |
| } |
| |
| } // namespace synth_elf |
| } // namespace google_breakpad |