diff options
Diffstat (limited to 'gold/output.cc')
| -rw-r--r-- | gold/output.cc | 421 |
1 files changed, 392 insertions, 29 deletions
diff --git a/gold/output.cc b/gold/output.cc index 3940f82..ababd8c 100644 --- a/gold/output.cc +++ b/gold/output.cc @@ -3,6 +3,10 @@ #include "gold.h" #include <cstdlib> +#include <cerrno> +#include <fcntl.h> +#include <unistd.h> +#include <sys/mman.h> #include <algorithm> #include "object.h" @@ -55,14 +59,18 @@ Output_data_const::do_write(Output_file* output) Output_section_headers::Output_section_headers( int size, + bool big_endian, const Layout::Segment_list& segment_list, - const Layout::Section_list& section_list) + const Layout::Section_list& section_list, + const Stringpool* secnamepool) : size_(size), + big_endian_(big_endian), segment_list_(segment_list), - section_list_(section_list) + section_list_(section_list), + secnamepool_(secnamepool) { - // Count all the sections. - off_t count = 0; + // Count all the sections. Start with 1 for the null section. + off_t count = 1; for (Layout::Segment_list::const_iterator p = segment_list.begin(); p != segment_list.end(); ++p) @@ -80,37 +88,158 @@ Output_section_headers::Output_section_headers( this->set_data_size(count * shdr_size); } +// Write out the section headers. + void -Output_section_headers::do_write(Output_file*) +Output_section_headers::do_write(Output_file* of) { - // FIXME: Unimplemented. - abort(); + if (this->size_ == 32) + { + if (this->big_endian_) + this->do_sized_write<32, true>(of); + else + this->do_sized_write<32, false>(of); + } + else if (this->size_ == 64) + { + if (this->big_endian_) + this->do_sized_write<64, true>(of); + else + this->do_sized_write<64, false>(of); + } + else + abort(); +} + +template<int size, bool big_endian> +void +Output_section_headers::do_sized_write(Output_file* of) +{ + off_t all_shdrs_size = this->data_size(); + unsigned char* view = of->get_output_view(this->offset(), all_shdrs_size); + + const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; + unsigned char* v = view; + + { + typename elfcpp::Shdr_write<size, big_endian> oshdr(v); + oshdr.put_sh_name(0); + oshdr.put_sh_type(elfcpp::SHT_NULL); + oshdr.put_sh_flags(0); + oshdr.put_sh_addr(0); + oshdr.put_sh_offset(0); + oshdr.put_sh_size(0); + oshdr.put_sh_link(0); + oshdr.put_sh_info(0); + oshdr.put_sh_addralign(0); + oshdr.put_sh_entsize(0); + } + + v += shdr_size; + + for (Layout::Segment_list::const_iterator p = this->segment_list_.begin(); + p != this->segment_list_.end(); + ++p) + v = (*p)->write_section_headers<size, big_endian>(this->secnamepool_, v); + for (Layout::Section_list::const_iterator p = this->section_list_.begin(); + p != this->section_list_.end(); + ++p) + { + elfcpp::Shdr_write<size, big_endian> oshdr(v); + (*p)->write_header(this->secnamepool_, &oshdr); + v += shdr_size; + } + + of->write_output_view(this->offset(), all_shdrs_size, view); } // Output_segment_header methods. +Output_segment_headers::Output_segment_headers( + int size, + bool big_endian, + const Layout::Segment_list& segment_list) + : size_(size), big_endian_(big_endian), segment_list_(segment_list) +{ + int phdr_size; + if (size == 32) + phdr_size = elfcpp::Elf_sizes<32>::phdr_size; + else if (size == 64) + phdr_size = elfcpp::Elf_sizes<64>::phdr_size; + else + abort(); + + this->set_data_size(segment_list.size() * phdr_size); +} + void -Output_segment_headers::do_write(Output_file*) +Output_segment_headers::do_write(Output_file* of) { - // FIXME: Unimplemented. - abort(); + if (this->size_ == 32) + { + if (this->big_endian_) + this->do_sized_write<32, true>(of); + else + this->do_sized_write<32, false>(of); + } + else if (this->size_ == 64) + { + if (this->big_endian_) + this->do_sized_write<64, true>(of); + else + this->do_sized_write<64, false>(of); + } + else + abort(); +} + +template<int size, bool big_endian> +void +Output_segment_headers::do_sized_write(Output_file* of) +{ + const int phdr_size = elfcpp::Elf_sizes<size>::phdr_size; + off_t all_phdrs_size = this->segment_list_.size() * phdr_size; + unsigned char* view = of->get_output_view(this->offset(), + all_phdrs_size); + unsigned char* v = view; + for (Layout::Segment_list::const_iterator p = this->segment_list_.begin(); + p != this->segment_list_.end(); + ++p) + { + elfcpp::Phdr_write<size, big_endian> ophdr(v); + (*p)->write_header(&ophdr); + v += phdr_size; + } + + of->write_output_view(this->offset(), all_phdrs_size, view); } // Output_file_header methods. Output_file_header::Output_file_header(int size, + bool big_endian, const General_options& options, const Target* target, const Symbol_table* symtab, const Output_segment_headers* osh) : size_(size), + big_endian_(big_endian), options_(options), target_(target), symtab_(symtab), - program_header_(osh), + segment_header_(osh), section_header_(NULL), shstrtab_(NULL) { + int ehdr_size; + if (size == 32) + ehdr_size = elfcpp::Elf_sizes<32>::ehdr_size; + else if (size == 64) + ehdr_size = elfcpp::Elf_sizes<64>::ehdr_size; + else + abort(); + + this->set_data_size(ehdr_size); } // Set the section table information for a file header. @@ -126,10 +255,96 @@ Output_file_header::set_section_info(const Output_section_headers* shdrs, // Write out the file header. void -Output_file_header::do_write(Output_file*) +Output_file_header::do_write(Output_file* of) { - // FIXME: Unimplemented. - abort(); + if (this->size_ == 32) + { + if (this->big_endian_) + this->do_sized_write<32, true>(of); + else + this->do_sized_write<32, false>(of); + } + else if (this->size_ == 64) + { + if (this->big_endian_) + this->do_sized_write<64, true>(of); + else + this->do_sized_write<64, false>(of); + } + else + abort(); +} + +// Write out the file header with appropriate size and endianess. + +template<int size, bool big_endian> +void +Output_file_header::do_sized_write(Output_file* of) +{ + assert(this->offset() == 0); + + int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size; + unsigned char* view = of->get_output_view(0, ehdr_size); + elfcpp::Ehdr_write<size, big_endian> oehdr(view); + + unsigned char e_ident[elfcpp::EI_NIDENT]; + memset(e_ident, 0, elfcpp::EI_NIDENT); + e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0; + e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1; + e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2; + e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3; + if (size == 32) + e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32; + else if (size == 64) + e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64; + else + abort(); + e_ident[elfcpp::EI_DATA] = (big_endian + ? elfcpp::ELFDATA2MSB + : elfcpp::ELFDATA2LSB); + e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT; + // FIXME: Some targets may need to set EI_OSABI and EI_ABIVERSION. + oehdr.put_e_ident(e_ident); + + elfcpp::ET e_type; + // FIXME: ET_DYN. + if (this->options_.is_relocatable()) + e_type = elfcpp::ET_REL; + else + e_type = elfcpp::ET_EXEC; + oehdr.put_e_type(e_type); + + oehdr.put_e_machine(this->target_->machine_code()); + oehdr.put_e_version(elfcpp::EV_CURRENT); + + Symbol* sym = this->symtab_->lookup("_start"); + typename Sized_symbol<size>::Value_type v; + if (sym == NULL) + v = 0; + else + { + Sized_symbol<size>* ssym; + ssym = this->symtab_->get_sized_symbol<size>(sym); + v = ssym->value(); + } + oehdr.put_e_entry(v); + + oehdr.put_e_phoff(this->segment_header_->offset()); + oehdr.put_e_shoff(this->section_header_->offset()); + + // FIXME: The target needs to set the flags. + oehdr.put_e_flags(0); + + oehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size); + oehdr.put_e_phentsize(elfcpp::Elf_sizes<size>::phdr_size); + oehdr.put_e_phnum(this->segment_header_->data_size() + / elfcpp::Elf_sizes<size>::phdr_size); + oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size); + oehdr.put_e_shnum(this->section_header_->data_size() + / elfcpp::Elf_sizes<size>::shdr_size); + oehdr.put_e_shstrndx(this->shstrtab_->shndx()); + + of->write_output_view(0, ehdr_size, view); } // Output_section methods. @@ -137,14 +352,15 @@ Output_file_header::do_write(Output_file*) // Construct an Output_section. NAME will point into a Stringpool. Output_section::Output_section(const char* name, elfcpp::Elf_Word type, - elfcpp::Elf_Xword flags) + elfcpp::Elf_Xword flags, unsigned int shndx) : name_(name), addralign_(0), entsize_(0), link_(0), info_(0), type_(type), - flags_(flags) + flags_(flags), + shndx_(shndx) { } @@ -184,13 +400,33 @@ Output_section::add_input_section(Object* object, const char* secname, || this->type_ != elfcpp::SHT_NOBITS) this->set_data_size(ssize + shdr.get_sh_size()); - return size; + return ssize; +} + +// Write the section header to *OSHDR. + +template<int size, bool big_endian> +void +Output_section::write_header(const Stringpool* secnamepool, + elfcpp::Shdr_write<size, big_endian>* oshdr) const +{ + oshdr->put_sh_name(secnamepool->get_offset(this->name_)); + oshdr->put_sh_type(this->type_); + oshdr->put_sh_flags(this->flags_); + oshdr->put_sh_addr(this->address()); + oshdr->put_sh_offset(this->offset()); + oshdr->put_sh_size(this->data_size()); + oshdr->put_sh_link(this->link_); + oshdr->put_sh_info(this->info_); + oshdr->put_sh_addralign(this->addralign_); + oshdr->put_sh_entsize(this->entsize_); } // Output_section_symtab methods. -Output_section_symtab::Output_section_symtab(const char* name, off_t size) - : Output_section(name, elfcpp::SHT_SYMTAB, 0) +Output_section_symtab::Output_section_symtab(const char* name, off_t size, + unsigned int shndx) + : Output_section(name, elfcpp::SHT_SYMTAB, 0, shndx) { this->set_data_size(size); } @@ -198,17 +434,18 @@ Output_section_symtab::Output_section_symtab(const char* name, off_t size) // Output_section_strtab methods. Output_section_strtab::Output_section_strtab(const char* name, - Stringpool* contents) - : Output_section(name, elfcpp::SHT_STRTAB, 0), + Stringpool* contents, + unsigned int shndx) + : Output_section(name, elfcpp::SHT_STRTAB, 0, shndx), contents_(contents) { + this->set_data_size(contents->get_strtab_size()); } void -Output_section_strtab::do_write(Output_file*) +Output_section_strtab::do_write(Output_file* of) { - // FIXME: Unimplemented. - abort(); + this->contents_->write(of, this->offset()); } // Output segment methods. @@ -260,7 +497,7 @@ Output_segment::add_output_section(Output_section* os, // section, there are normally only a few output sections in an // output segment. This loop is expected to be fast. - if (os->type() == elfcpp::SHT_NOTE) + if (os->type() == elfcpp::SHT_NOTE && !pdl->empty()) { Layout::Data_list::iterator p = pdl->end(); do @@ -281,7 +518,7 @@ Output_segment::add_output_section(Output_section* os, // case: we group the SHF_TLS/SHT_NOBITS sections right after the // SHF_TLS/SHT_PROGBITS sections. This lets us set up PT_TLS // correctly. - if ((os->flags() & elfcpp::SHF_TLS) != 0) + if ((os->flags() & elfcpp::SHF_TLS) != 0 && !this->output_data_.empty()) { pdl = &this->output_data_; bool nobits = os->type() == elfcpp::SHT_NOBITS; @@ -345,12 +582,15 @@ Output_segment::set_section_addresses(uint64_t addr, off_t* poff) off_t off = *poff; - return this->set_section_list_addresses(&this->output_bss_, addr, poff); + uint64_t ret = this->set_section_list_addresses(&this->output_bss_, addr, + poff); this->memsz_ = *poff - orig_off; // Ignore the file offset adjustments made by the BSS Output_data // objects. *poff = off; + + return ret; } // Set the addresses in a list of Output_data structures. @@ -454,12 +694,135 @@ Output_segment::output_section_count_list(const Output_data_list* pdl) const return count; } +// Write the segment data into *OPHDR. + +template<int size, bool big_endian> +void +Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr) const +{ + ophdr->put_p_type(this->type_); + ophdr->put_p_offset(this->offset_); + ophdr->put_p_vaddr(this->vaddr_); + ophdr->put_p_paddr(this->paddr_); + ophdr->put_p_filesz(this->filesz_); + ophdr->put_p_memsz(this->memsz_); + ophdr->put_p_flags(this->flags_); + ophdr->put_p_align(this->align_); +} + +// Write the section headers into V. + +template<int size, bool big_endian> +unsigned char* +Output_segment::write_section_headers(const Stringpool* secnamepool, + unsigned char* v) const +{ + v = this->write_section_headers_list<size, big_endian>(secnamepool, + &this->output_data_, + v); + v = this->write_section_headers_list<size, big_endian>(secnamepool, + &this->output_bss_, + v); + return v; +} + +template<int size, bool big_endian> +unsigned char* +Output_segment::write_section_headers_list(const Stringpool* secnamepool, + const Output_data_list* pdl, + unsigned char* v) const +{ + const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; + for (Output_data_list::const_iterator p = pdl->begin(); + p != pdl->end(); + ++p) + { + if ((*p)->is_section()) + { + Output_section* ps = static_cast<const Output_section*>(*p); + elfcpp::Shdr_write<size, big_endian> oshdr(v); + ps->write_header(secnamepool, &oshdr); + v += shdr_size; + } + } + return v; +} + // Output_file methods. +Output_file::Output_file(const General_options& options) + : options_(options), + name_(options.output_file_name()), + o_(-1), + file_size_(0), + base_(NULL) +{ +} + +// Open the output file. + void -Output_file::write(off_t, const void*, off_t) +Output_file::open(off_t file_size) { - abort(); + this->file_size_ = file_size; + + int mode = this->options_.is_relocatable() ? 0666 : 0777; + int o = ::open(this->name_, O_RDWR | O_CREAT | O_TRUNC, mode); + if (o < 0) + { + fprintf(stderr, _("%s: %s: open: %s\n"), + program_name, this->name_, strerror(errno)); + gold_exit(false); + } + this->o_ = o; + + // Write out one byte to make the file the right size. + if (::lseek(o, file_size - 1, SEEK_SET) < 0) + { + fprintf(stderr, _("%s: %s: lseek: %s\n"), + program_name, this->name_, strerror(errno)); + gold_exit(false); + } + char b = 0; + if (::write(o, &b, 1) != 1) + { + fprintf(stderr, _("%s: %s: write: %s\n"), + program_name, this->name_, strerror(errno)); + gold_exit(false); + } + + // Map the file into memory. + void* base = ::mmap(NULL, file_size, PROT_READ | PROT_WRITE, + MAP_SHARED, o, 0); + if (base == MAP_FAILED) + { + fprintf(stderr, _("%s: %s: mmap: %s\n"), + program_name, this->name_, strerror(errno)); + gold_exit(false); + } + this->base_ = static_cast<unsigned char*>(base); +} + +// Close the output file. + +void +Output_file::close() +{ + if (::munmap(this->base_, this->file_size_) < 0) + { + fprintf(stderr, _("%s: %s: munmap: %s\n"), + program_name, this->name_, strerror(errno)); + gold_exit(false); + } + this->base_ = NULL; + + if (::close(this->o_) < 0) + { + fprintf(stderr, _("%s: %s: close: %s\n"), + program_name, this->name_, strerror(errno)); + gold_exit(false); + } + this->o_ = -1; } // Instantiate the templates we need. We could use the configure |