// 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*,
+ Output_section_headers(const Layout*,
const Layout::Segment_list*,
const Layout::Section_list*,
const Stringpool*);
// 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* layout_;
const Layout::Segment_list* segment_list_;
const Layout::Section_list* unattached_section_list_;
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_;
void
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
+ {
+ return this->do_output_address(object, shndx, offset,
+ output_section_address, poutput);
+ }
+
protected:
// The child class must implement do_write.
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
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_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);
// 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 link field to the output section index of a section.
void
- set_link_section(Output_data* od)
+ set_link_section(const Output_data* od)
{
gold_assert(this->link_ == 0
&& !this->should_link_to_symtab_
// Set the info field to the output section index of a section.
void
- set_info_section(Output_data* od)
+ set_info_section(const Output_data* od)
{
gold_assert(this->info_ == 0);
this->info_section_ = od;
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
{
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.
uint64_t entsize_;
// The file offset is in the parent class.
// Set the section link field to the index of this section.
- Output_data* link_section_;
+ const Output_data* link_section_;
// If link_section_ is NULL, this is the link field.
unsigned int link_;
// Set the section info field to the index of this section.
- Output_data* info_section_;
+ const Output_data* info_section_;
// If info_section_ is NULL, this is the section info field.
unsigned int info_;
// The section 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.
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
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.