// output.h -- manage the output file for gold -*- C++ -*-
+// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Written by Ian Lance Taylor <iant@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
#ifndef GOLD_OUTPUT_H
#define GOLD_OUTPUT_H
#include "elfcpp.h"
#include "layout.h"
#include "reloc-types.h"
+#include "parameters.h"
namespace gold
{
class Output_section_headers : public Output_data
{
public:
- Output_section_headers(int size,
- bool big_endian,
- const Layout::Segment_list&,
- const Layout::Section_list&,
+ Output_section_headers(const Layout*,
+ const Layout::Segment_list*,
+ const Layout::Section_list*,
const Stringpool*);
// Write the data to the file.
// Return the required alignment.
uint64_t
do_addralign() const
- { return Output_data::default_alignment(this->size_); }
+ { return Output_data::default_alignment(parameters->get_size()); }
private:
// Write the data to the file with the right size and endianness.
void
do_sized_write(Output_file*);
- int size_;
- bool big_endian_;
- const Layout::Segment_list& segment_list_;
- const Layout::Section_list& unattached_section_list_;
+ const Layout* layout_;
+ const Layout::Segment_list* segment_list_;
+ const Layout::Section_list* unattached_section_list_;
const Stringpool* secnamepool_;
};
class Output_segment_headers : public Output_data
{
public:
- Output_segment_headers(int size, bool big_endian,
- const Layout::Segment_list& segment_list);
+ Output_segment_headers(const Layout::Segment_list& segment_list);
// Write the data to the file.
void
// Return the required alignment.
uint64_t
do_addralign() const
- { return Output_data::default_alignment(this->size_); }
+ { return Output_data::default_alignment(parameters->get_size()); }
private:
// Write the data to the file with the right size and endianness.
void
do_sized_write(Output_file*);
- int size_;
- bool big_endian_;
const Layout::Segment_list& segment_list_;
};
class Output_file_header : public Output_data
{
public:
- Output_file_header(int size,
- bool big_endian,
- const General_options&,
- const Target*,
+ Output_file_header(const Target*,
const Symbol_table*,
const Output_segment_headers*);
// Return the required alignment.
uint64_t
do_addralign() const
- { return Output_data::default_alignment(this->size_); }
+ { return Output_data::default_alignment(parameters->get_size()); }
// Set the address and offset--we only implement this for error
// checking.
void
do_sized_write(Output_file*);
- int size_;
- bool big_endian_;
- const General_options& options_;
const Target* target_;
const Symbol_table* symtab_;
const Output_segment_headers* segment_header_;
: Output_data(0), output_section_(NULL), addralign_(addralign)
{ }
+ // Return the output section.
+ const Output_section*
+ output_section() const
+ { return this->output_section_; }
+
// Record the output section.
void
- set_output_section(Output_section* os)
+ set_output_section(Output_section* os);
+
+ // Add an input section, for SHF_MERGE sections. This returns true
+ // if the section was handled.
+ bool
+ add_input_section(Relobj* object, unsigned int shndx)
+ { return this->do_add_input_section(object, shndx); }
+
+ // Given an input OBJECT, an input section index SHNDX within that
+ // object, and an OFFSET relative to the start of that input
+ // section, return whether or not the output address is known.
+ // OUTPUT_SECTION_ADDRESS is the address of the output section which
+ // this is a part of. If this function returns true, it sets
+ // *POUTPUT to the output address.
+ virtual bool
+ output_address(const Relobj* object, unsigned int shndx, off_t offset,
+ uint64_t output_section_address, uint64_t *poutput) const
{
- gold_assert(this->output_section_ == NULL);
- this->output_section_ = os;
+ return this->do_output_address(object, shndx, offset,
+ output_section_address, poutput);
}
protected:
// The child class must implement do_write.
+ // The child class may implement specific adjustments to the output
+ // section.
+ virtual void
+ do_adjust_output_section(Output_section*)
+ { }
+
+ // May be implemented by child class. Return true if the section
+ // was handled.
+ virtual bool
+ do_add_input_section(Relobj*, unsigned int)
+ { gold_unreachable(); }
+
+ // The child class may implement output_address.
+ virtual bool
+ do_output_address(const Relobj*, unsigned int, off_t, uint64_t,
+ uint64_t*) const
+ { return false; }
+
// Return the required alignment.
uint64_t
do_addralign() const
do_write(Output_file*);
protected:
+ // Set the entry size and the link.
+ void
+ do_adjust_output_section(Output_section *os);
+
// Add a relocation entry.
void
add(const Output_reloc_type& reloc)
public:
typedef typename elfcpp::Elf_types<size>::Elf_Addr Valtype;
- Output_data_got(const General_options* options)
- : Output_section_data(Output_data::default_alignment(size)),
- options_(options), entries_()
+ Output_data_got()
+ : Output_section_data(Output_data::default_alignment(size)), entries_()
{ }
// Add an entry for a global symbol to the GOT. Return true if this
// Write the GOT entry to an output view.
void
- write(const General_options*, unsigned char* pov) const;
+ write(unsigned char* pov) const;
private:
enum
set_got_size()
{ this->set_data_size(this->got_offset(this->entries_.size())); }
- // Options.
- const General_options* options_;
// The list of GOT entries.
Got_entries entries_;
};
class Output_data_dynamic : public Output_section_data
{
public:
- Output_data_dynamic(const Target* target, Stringpool* pool)
- : Output_section_data(Output_data::default_alignment(target->get_size())),
- target_(target), entries_(), pool_(pool)
+ Output_data_dynamic(Stringpool* pool)
+ : Output_section_data(Output_data::default_alignment(
+ parameters->get_size())),
+ entries_(), pool_(pool)
{ }
// Add a new dynamic entry with a fixed numeric value.
add_constant(elfcpp::DT tag, unsigned int val)
{ this->add_entry(Dynamic_entry(tag, val)); }
- // Add a new dynamic entry with the address of a section.
+ // Add a new dynamic entry with the address of output data.
void
- add_section_address(elfcpp::DT tag, Output_section* os)
- { this->add_entry(Dynamic_entry(tag, os, false)); }
+ add_section_address(elfcpp::DT tag, const Output_data* od)
+ { this->add_entry(Dynamic_entry(tag, od, false)); }
- // Add a new dynamic entry with the size of a section.
+ // Add a new dynamic entry with the size of output data.
void
- add_section_size(elfcpp::DT tag, Output_section* os)
- { this->add_entry(Dynamic_entry(tag, os, true)); }
+ add_section_size(elfcpp::DT tag, const Output_data* od)
+ { this->add_entry(Dynamic_entry(tag, od, true)); }
// Add a new dynamic entry with the address of a symbol.
void
- add_symbol(elfcpp::DT tag, Symbol* sym)
+ add_symbol(elfcpp::DT tag, const Symbol* sym)
{ this->add_entry(Dynamic_entry(tag, sym)); }
// Add a new dynamic entry with a string.
add_string(elfcpp::DT tag, const char* str)
{ this->add_entry(Dynamic_entry(tag, this->pool_->add(str, NULL))); }
+ void
+ add_string(elfcpp::DT tag, const std::string& str)
+ { this->add_string(tag, str.c_str()); }
+
// Set the final data size.
void
do_set_address(uint64_t, off_t);
void
do_write(Output_file*);
+ protected:
+ // Adjust the output section to set the entry size.
+ void
+ do_adjust_output_section(Output_section*);
+
private:
// This POD class holds a single dynamic entry.
class Dynamic_entry
{ this->u_.val = val; }
// Create an entry with the size or address of a section.
- Dynamic_entry(elfcpp::DT tag, Output_section* os, bool section_size)
+ Dynamic_entry(elfcpp::DT tag, const Output_data* od, bool section_size)
: tag_(tag),
classification_(section_size
? DYNAMIC_SECTION_SIZE
: DYNAMIC_SECTION_ADDRESS)
- { this->u_.os = os; }
+ { this->u_.od = od; }
// Create an entry with the address of a symbol.
- Dynamic_entry(elfcpp::DT tag, Symbol* sym)
+ Dynamic_entry(elfcpp::DT tag, const Symbol* sym)
: tag_(tag), classification_(DYNAMIC_SYMBOL)
{ this->u_.sym = sym; }
// Write the dynamic entry to an output view.
template<int size, bool big_endian>
void
- write(unsigned char* pov, const Stringpool*) const;
+ write(unsigned char* pov, const Stringpool* ACCEPT_SIZE_ENDIAN) const;
private:
enum Classification
// For DYNAMIC_NUMBER.
unsigned int val;
// For DYNAMIC_SECTION_ADDRESS and DYNAMIC_SECTION_SIZE.
- Output_section* os;
+ const Output_data* od;
// For DYNAMIC_SYMBOL.
- Symbol* sym;
+ const Symbol* sym;
// For DYNAMIC_STRING.
const char* str;
} u_;
// The type of the list of entries.
typedef std::vector<Dynamic_entry> Dynamic_entries;
- // The target.
- const Target* target_;
// The entries.
Dynamic_entries entries_;
// The pool used for strings.
{
public:
// Create an output section, giving the name, type, and flags.
- Output_section(const char* name, elfcpp::Elf_Word, elfcpp::Elf_Xword,
- bool may_add_data);
+ Output_section(const char* name, elfcpp::Elf_Word, elfcpp::Elf_Xword);
virtual ~Output_section();
// Add a new input section SHNDX, named NAME, with header SHDR, from
add_input_section(Relobj* object, unsigned int shndx, const char *name,
const elfcpp::Shdr<size, big_endian>& shdr);
- // Add generated data ODATA to this output section.
+ // Add generated data POSD to this output section.
void
add_output_section_data(Output_section_data* posd);
// Set the entsize field.
void
- set_entsize(uint64_t v)
- { this->entsize_ = v; }
+ set_entsize(uint64_t v);
- // Set the link field.
+ // Set the link field to the output section index of a section.
+ void
+ set_link_section(const Output_data* od)
+ {
+ gold_assert(this->link_ == 0
+ && !this->should_link_to_symtab_
+ && !this->should_link_to_dynsym_);
+ this->link_section_ = od;
+ }
+
+ // Set the link field to a constant.
void
set_link(unsigned int v)
- { this->link_ = v; }
+ {
+ gold_assert(this->link_section_ == NULL
+ && !this->should_link_to_symtab_
+ && !this->should_link_to_dynsym_);
+ this->link_ = v;
+ }
- // Set the info field.
+ // Record that this section should link to the normal symbol table.
+ void
+ set_should_link_to_symtab()
+ {
+ gold_assert(this->link_section_ == NULL
+ && this->link_ == 0
+ && !this->should_link_to_dynsym_);
+ this->should_link_to_symtab_ = true;
+ }
+
+ // Record that this section should link to the dynamic symbol table.
+ void
+ set_should_link_to_dynsym()
+ {
+ gold_assert(this->link_section_ == NULL
+ && this->link_ == 0
+ && !this->should_link_to_symtab_);
+ this->should_link_to_dynsym_ = true;
+ }
+
+ // Return the info field.
+ unsigned int
+ info() const
+ {
+ gold_assert(this->info_section_ == NULL);
+ return this->info_;
+ }
+
+ // Set the info field to the output section index of a section.
+ void
+ set_info_section(const Output_data* od)
+ {
+ gold_assert(this->info_ == 0);
+ this->info_section_ = od;
+ }
+
+ // Set the info field to a constant.
void
set_info(unsigned int v)
- { this->info_ = v; }
+ {
+ gold_assert(this->info_section_ == NULL);
+ this->info_ = v;
+ }
// Set the addralign field.
void
this->dynsym_index_ = index;
}
+ // Return the output virtual address of OFFSET relative to the start
+ // of input section SHNDX in object OBJECT.
+ uint64_t
+ output_address(const Relobj* object, unsigned int shndx,
+ off_t offset) const;
+
// Set the address of the Output_section. For a typical
// Output_section, there is nothing to do, but if there are any
// Output_section_data objects we need to set the final addresses
// Write the section header into *OPHDR.
template<int size, bool big_endian>
void
- write_header(const Stringpool*, elfcpp::Shdr_write<size, big_endian>*) const;
+ write_header(const Layout*, const Stringpool*,
+ elfcpp::Shdr_write<size, big_endian>*) const;
private:
// In some cases we need to keep a list of the input sections
{
public:
Input_section()
- : shndx_(0), p2align_(0), data_size_(0)
- { this->u_.object = NULL; }
+ : shndx_(0), p2align_(0)
+ {
+ this->u1_.data_size = 0;
+ this->u2_.object = NULL;
+ }
+ // For an ordinary input section.
Input_section(Relobj* object, unsigned int shndx, off_t data_size,
uint64_t addralign)
: shndx_(shndx),
- p2align_(ffsll(static_cast<long long>(addralign))),
- data_size_(data_size)
+ p2align_(ffsll(static_cast<long long>(addralign)))
{
- gold_assert(shndx != -1U);
- this->u_.object = object;
+ gold_assert(shndx != OUTPUT_SECTION_CODE
+ && shndx != MERGE_DATA_SECTION_CODE
+ && shndx != MERGE_STRING_SECTION_CODE);
+ this->u1_.data_size = data_size;
+ this->u2_.object = object;
}
+ // For a non-merge output section.
Input_section(Output_section_data* posd)
- : shndx_(-1U),
- p2align_(ffsll(static_cast<long long>(posd->addralign()))),
- data_size_(0)
- { this->u_.posd = posd; }
+ : shndx_(OUTPUT_SECTION_CODE),
+ p2align_(ffsll(static_cast<long long>(posd->addralign())))
+ {
+ this->u1_.data_size = 0;
+ this->u2_.posd = posd;
+ }
+
+ // For a merge section.
+ Input_section(Output_section_data* posd, bool is_string, uint64_t entsize)
+ : shndx_(is_string
+ ? MERGE_STRING_SECTION_CODE
+ : MERGE_DATA_SECTION_CODE),
+ p2align_(ffsll(static_cast<long long>(posd->addralign())))
+ {
+ this->u1_.entsize = entsize;
+ this->u2_.posd = posd;
+ }
// The required alignment.
uint64_t
off_t
data_size() const;
+ // Return whether this is a merge section which matches the
+ // parameters.
+ bool
+ is_merge_section(bool is_string, uint64_t entsize) const
+ {
+ return (this->shndx_ == (is_string
+ ? MERGE_STRING_SECTION_CODE
+ : MERGE_DATA_SECTION_CODE)
+ && this->u1_.entsize == entsize);
+ }
+
+ // Set the output section.
+ void
+ set_output_section(Output_section* os)
+ {
+ gold_assert(!this->is_input_section());
+ this->u2_.posd->set_output_section(os);
+ }
+
// Set the address and file offset. This is called during
// Layout::finalize. SECOFF is the file offset of the enclosing
// section.
void
set_address(uint64_t addr, off_t off, off_t secoff);
+ // Add an input section, for SHF_MERGE sections.
+ bool
+ add_input_section(Relobj* object, unsigned int shndx)
+ {
+ gold_assert(this->shndx_ == MERGE_DATA_SECTION_CODE
+ || this->shndx_ == MERGE_STRING_SECTION_CODE);
+ return this->u2_.posd->add_input_section(object, shndx);
+ }
+
+ // Given an input OBJECT, an input section index SHNDX within that
+ // object, and an OFFSET relative to the start of that input
+ // section, return whether or not the output address is known.
+ // OUTPUT_SECTION_ADDRESS is the address of the output section
+ // which this is a part of. If this function returns true, it
+ // sets *POUTPUT to the output address.
+ bool
+ output_address(const Relobj* object, unsigned int shndx, off_t offset,
+ uint64_t output_section_address, uint64_t *poutput) const;
+
// Write out the data. This does nothing for an input section.
void
write(Output_file*);
private:
+ // Code values which appear in shndx_. If the value is not one of
+ // these codes, it is the input section index in the object file.
+ enum
+ {
+ // An Output_section_data.
+ OUTPUT_SECTION_CODE = -1U,
+ // An Output_section_data for an SHF_MERGE section with
+ // SHF_STRINGS not set.
+ MERGE_DATA_SECTION_CODE = -2U,
+ // An Output_section_data for an SHF_MERGE section with
+ // SHF_STRINGS set.
+ MERGE_STRING_SECTION_CODE = -3U
+ };
+
// Whether this is an input section.
bool
is_input_section() const
- { return this->shndx_ != -1U; }
+ {
+ return (this->shndx_ != OUTPUT_SECTION_CODE
+ && this->shndx_ != MERGE_DATA_SECTION_CODE
+ && this->shndx_ != MERGE_STRING_SECTION_CODE);
+ }
- // For an ordinary input section, this is the section index in
- // the input file. For an Output_section_data, this is -1U.
+ // For an ordinary input section, this is the section index in the
+ // input file. For an Output_section_data, this is
+ // OUTPUT_SECTION_CODE or MERGE_DATA_SECTION_CODE or
+ // MERGE_STRING_SECTION_CODE.
unsigned int shndx_;
// The required alignment, stored as a power of 2.
unsigned int p2align_;
- // For an ordinary input section, the section size.
- off_t data_size_;
union
{
- // If shndx_ != -1U, this points to the object which holds the
+ // For an ordinary input section, the section size.
+ off_t data_size;
+ // For OUTPUT_SECTION_CODE, this is not used. For
+ // MERGE_DATA_SECTION_CODE or MERGE_STRING_SECTION_CODE, the
+ // entity size.
+ uint64_t entsize;
+ } u1_;
+ union
+ {
+ // For an ordinary input section, the object which holds the
// input section.
Relobj* object;
- // If shndx_ == -1U, this is the data to write out.
+ // For OUTPUT_SECTION_CODE or MERGE_DATA_SECTION_CODE or
+ // MERGE_STRING_SECTION_CODE, the data.
Output_section_data* posd;
- } u_;
+ } u2_;
};
typedef std::vector<Input_section> Input_section_list;
+ // Fill data. This is used to fill in data between input sections.
+ // When we have to keep track of the input sections, we can use an
+ // Output_data_const, but we don't want to have to keep track of
+ // input sections just to implement fills. For a fill we record the
+ // offset, and the actual data to be written out.
+ class Fill
+ {
+ public:
+ Fill(off_t section_offset, off_t length)
+ : section_offset_(section_offset), length_(length)
+ { }
+
+ // Return section offset.
+ off_t
+ section_offset() const
+ { return this->section_offset_; }
+
+ // Return fill length.
+ off_t
+ length() const
+ { return this->length_; }
+
+ private:
+ // The offset within the output section.
+ off_t section_offset_;
+ // The length of the space to fill.
+ off_t length_;
+ };
+
+ typedef std::vector<Fill> Fill_list;
+
+ // Add a new output section by Input_section.
+ void
+ add_output_section_data(Input_section*);
+
+ // Add an SHF_MERGE input section. Returns true if the section was
+ // handled.
+ bool
+ add_merge_input_section(Relobj* object, unsigned int shndx, uint64_t flags,
+ uint64_t entsize, uint64_t addralign);
+
+ // Add an output SHF_MERGE section POSD to this output section.
+ // IS_STRING indicates whether it is a SHF_STRINGS section, and
+ // ENTSIZE is the entity size. This returns the entry added to
+ // input_sections_.
+ void
+ add_output_merge_section(Output_section_data* posd, bool is_string,
+ uint64_t entsize);
+
// Most of these fields are only valid after layout.
// The name of the section. This will point into a Stringpool.
// The section entry size.
uint64_t entsize_;
// The file offset is in the parent class.
- // The section link field.
+ // Set the section link field to the index of this section.
+ const Output_data* link_section_;
+ // If link_section_ is NULL, this is the link field.
unsigned int link_;
- // The section info field.
+ // Set the section info field to the index of this section.
+ const Output_data* info_section_;
+ // If info_section_ is NULL, this is the section info field.
unsigned int info_;
// The section type.
elfcpp::Elf_Word type_;
Input_section_list input_sections_;
// The offset of the first entry in input_sections_.
off_t first_input_offset_;
- // Whether we permit adding data.
- bool may_add_data_ : 1;
+ // The fill data. This is separate from input_sections_ because we
+ // often will need fill sections without needing to keep track of
+ // input sections.
+ Fill_list fills_;
// Whether this output section needs a STT_SECTION symbol in the
// normal symbol table. This will be true if there is a relocation
// which needs it.
// dynamic symbol table. This will be true if there is a dynamic
// relocation which needs it.
bool needs_dynsym_index_ : 1;
+ // Whether the link field of this output section should point to the
+ // normal symbol table.
+ bool should_link_to_symtab_ : 1;
+ // Whether the link field of this output section should point to the
+ // dynamic symbol table.
+ bool should_link_to_dynsym_ : 1;
};
// An output segment. PT_LOAD segments are built from collections of
uint64_t
set_section_addresses(uint64_t addr, off_t* poff, unsigned int* pshndx);
+ // Set the minimum alignment of this segment. This may be adjusted
+ // upward based on the section alignments.
+ void
+ set_minimum_addralign(uint64_t align)
+ {
+ gold_assert(!this->is_align_known_);
+ this->align_ = align;
+ }
+
// Set the offset of this segment based on the section. This should
// only be called for a non-PT_LOAD segment.
void
// Write the section headers of associated sections into V.
template<int size, bool big_endian>
unsigned char*
- write_section_headers(const Stringpool*,
- unsigned char* v,
+ write_section_headers(const Layout*, const Stringpool*, unsigned char* v,
unsigned int* pshndx ACCEPT_SIZE_ENDIAN) const;
private:
// Write the section headers in the list into V.
template<int size, bool big_endian>
unsigned char*
- write_section_headers_list(const Stringpool*, const Output_data_list*,
- unsigned char* v,
+ write_section_headers_list(const Layout*, const Stringpool*,
+ const Output_data_list*, unsigned char* v,
unsigned int* pshdx ACCEPT_SIZE_ENDIAN) const;
// The list of output data with contents attached to this segment.
uint64_t paddr_;
// The size of the segment in memory.
uint64_t memsz_;
- // The segment alignment.
+ // The segment alignment. The is_align_known_ field indicates
+ // whether this has been finalized. It can be set to a minimum
+ // value before it is finalized.
uint64_t align_;
// The offset of the segment data within the file.
off_t offset_;
elfcpp::Elf_Word type_;
// The segment flags.
elfcpp::Elf_Word flags_;
- // Whether we have set align_.
+ // Whether we have finalized align_.
bool is_align_known_;
};
class Output_file
{
public:
- Output_file(const General_options& options);
+ Output_file(const General_options& options, Target*);
+
+ // Get a pointer to the target.
+ Target*
+ target() const
+ { return this->target_; }
// Open the output file. FILE_SIZE is the final size of the file.
void
private:
// General options.
const General_options& options_;
+ // Target.
+ Target* target_;
// File name.
const char* name_;
// File descriptor.
projects / deliverable / binutils-gdb.git / blobdiff