return this->offset_;
}
+ // Reset the address and file offset. This essentially disables the
+ // sanity testing about duplicate and unknown settings.
+ void
+ reset_address_and_file_offset()
+ {
+ this->is_address_valid_ = false;
+ this->is_offset_valid_ = false;
+ this->is_data_size_valid_ = false;
+ this->do_reset_address_and_file_offset();
+ }
+
// Return the required alignment.
uint64_t
addralign() const
{ return this->do_addralign(); }
+ // Return whether this has a load address.
+ bool
+ has_load_address() const
+ { return this->do_has_load_address(); }
+
+ // Return the load address.
+ uint64_t
+ load_address() const
+ { return this->do_load_address(); }
+
// Return whether this is an Output_section.
bool
is_section() const
virtual uint64_t
do_addralign() const = 0;
+ // Return whether this has a load address.
+ virtual bool
+ do_has_load_address() const
+ { return false; }
+
+ // Return the load address.
+ virtual uint64_t
+ do_load_address() const
+ { gold_unreachable(); }
+
// Return whether this is an Output_section.
virtual bool
do_is_section() const
set_final_data_size()
{ gold_unreachable(); }
+ // A hook for resetting the address and file offset.
+ virtual void
+ do_reset_address_and_file_offset()
+ { }
+
// Set the TLS offset. Called only for SHT_TLS sections.
virtual void
do_set_tls_offset(uint64_t)
// Add a new input section SHNDX, named NAME, with header SHDR, from
// object OBJECT. RELOC_SHNDX is the index of a relocation section
// which applies to this section, or 0 if none, or -1U if more than
- // one. Return the offset within the output section.
+ // one. HAVE_SECTIONS_SCRIPT is true if we have a SECTIONS clause
+ // in a linker script; in that case we need to keep track of input
+ // sections associated with an output section. Return the offset
+ // within the output section.
template<int size, bool big_endian>
off_t
add_input_section(Sized_relobj<size, big_endian>* object, unsigned int shndx,
const char *name,
const elfcpp::Shdr<size, big_endian>& shdr,
- unsigned int reloc_shndx);
+ unsigned int reloc_shndx, bool have_sections_script);
// Add generated data POSD to this output section.
void
void
set_entsize(uint64_t v);
+ // Set the load address.
+ void
+ set_load_address(uint64_t load_address)
+ {
+ this->load_address_ = load_address;
+ this->has_load_address_ = true;
+ }
+
// Set the link field to the output section index of a section.
void
set_link_section(const Output_data* od)
uint64_t
starting_output_address(const Relobj* object, unsigned int shndx) const;
+ // Record that this output section was found in the SECTIONS clause
+ // of a linker script.
+ void
+ set_found_in_sections_clause()
+ { this->found_in_sections_clause_ = true; }
+
+ // Return whether this output section was found in the SECTIONS
+ // clause of a linker script.
+ bool
+ found_in_sections_clause() const
+ { return this->found_in_sections_clause_; }
+
// Write the section header into *OPHDR.
template<int size, bool big_endian>
void
write_header(const Layout*, const Stringpool*,
elfcpp::Shdr_write<size, big_endian>*) const;
+ // The next few calls are for linker script support.
+
+ // Store the list of input sections for this Output_section into the
+ // list passed in. This removes the input sections, leaving only
+ // any Output_section_data elements. This returns the size of those
+ // Output_section_data elements. ADDRESS is the address of this
+ // output section. FILL is the fill value to use, in case there are
+ // any spaces between the remaining Output_section_data elements.
+ uint64_t
+ get_input_sections(uint64_t address, const std::string& fill,
+ std::list<std::pair<Relobj*, unsigned int > >*);
+
+ // Add an input section from a script.
+ void
+ add_input_section_for_script(Relobj* object, unsigned int shndx,
+ off_t data_size, uint64_t addralign);
+
+ // Set the current size of the output section.
+ void
+ set_current_data_size(off_t size)
+ { this->set_current_data_size_for_child(size); }
+
+ // Get the current size of the output section.
+ off_t
+ current_data_size() const
+ { return this->current_data_size_for_child(); }
+
+ // End of linker script support.
+
// Print merge statistics to stderr.
void
print_merge_stats();
void
do_set_out_shndx(unsigned int shndx)
{
- gold_assert(this->out_shndx_ == -1U);
+ gold_assert(this->out_shndx_ == -1U || this->out_shndx_ == shndx);
this->out_shndx_ = shndx;
}
virtual void
set_final_data_size();
+ // Reset the address and file offset.
+ void
+ do_reset_address_and_file_offset();
+
// Write the data to the file. For a typical Output_section, this
// does nothing: the data is written out by calling Object::Relocate
// on each input object. But if there are any Output_section_data
do_addralign() const
{ return this->addralign_; }
+ // Return whether there is a load address.
+ bool
+ do_has_load_address() const
+ { return this->has_load_address_; }
+
+ // Return the load address.
+ uint64_t
+ do_load_address() const
+ {
+ gold_assert(this->has_load_address_);
+ return this->load_address_;
+ }
+
// Return whether this is an Output_section.
bool
do_is_section() const
off_t
data_size() const;
+ // Whether this is an input section.
+ bool
+ is_input_section() const
+ {
+ return (this->shndx_ != OUTPUT_SECTION_CODE
+ && this->shndx_ != MERGE_DATA_SECTION_CODE
+ && this->shndx_ != MERGE_STRING_SECTION_CODE);
+ }
+
// Return whether this is a merge section which matches the
// parameters.
bool
&& this->addralign() == addralign);
}
+ // Return the object for an input section.
+ Relobj*
+ relobj() const
+ {
+ gold_assert(this->is_input_section());
+ return this->u2_.object;
+ }
+
+ // Return the input section index for an input section.
+ unsigned int
+ shndx() const
+ {
+ gold_assert(this->is_input_section());
+ return this->shndx_;
+ }
+
// Set the output section.
void
set_output_section(Output_section* os)
set_address_and_file_offset(uint64_t address, off_t file_offset,
off_t section_file_offset);
+ // Reset the address and file offset.
+ void
+ reset_address_and_file_offset();
+
// Finalize the data size.
void
finalize_data_size();
MERGE_STRING_SECTION_CODE = -3U
};
- // Whether this is an input section.
- bool
- is_input_section() const
- {
- 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
// OUTPUT_SECTION_CODE or MERGE_DATA_SECTION_CODE or
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.
+ // It is also used for data statements (BYTE, WORD, etc.) in linker
+ // scripts. 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.
class Fill
{
public:
Fill(off_t section_offset, off_t length)
- : section_offset_(section_offset), length_(length)
+ : section_offset_(section_offset),
+ length_(convert_to_section_size_type(length))
{ }
// Return section offset.
{ return this->section_offset_; }
// Return fill length.
- off_t
+ section_size_type
length() const
{ return this->length_; }
// The offset within the output section.
off_t section_offset_;
// The length of the space to fill.
- off_t length_;
+ section_size_type length_;
};
typedef std::vector<Fill> Fill_list;
uint64_t addralign_;
// The section entry size.
uint64_t entsize_;
+ // The load address. This is only used when using a linker script
+ // with a SECTIONS clause. The has_load_address_ field indicates
+ // whether this field is valid.
+ uint64_t load_address_;
// The file offset is in the parent class.
// Set the section link field to the index of this section.
const Output_data* link_section_;
// The section type.
const elfcpp::Elf_Word type_;
// The section flags.
- const elfcpp::Elf_Xword flags_;
+ elfcpp::Elf_Xword flags_;
// The section index.
unsigned int out_shndx_;
// If there is a STT_SECTION for this output section in the normal
// Whether this section requires post processing after all
// relocations have been applied.
bool requires_postprocessing_ : 1;
+ // Whether an input section was mapped to this output section
+ // because of a SECTIONS clause in a linker script.
+ bool found_in_sections_clause_ : 1;
+ // Whether this section has an explicitly specified load address.
+ bool has_load_address_ : 1;
// For SHT_TLS sections, the offset of this section relative to the base
// of the TLS segment.
uint64_t tls_offset_;
// Return the maximum alignment of the Output_data.
uint64_t
- addralign();
+ maximum_alignment();
// Add an Output_section to this segment.
void
unsigned int
dynamic_reloc_count() const;
+ // Return the address of the first section.
+ uint64_t
+ first_section_load_address() const;
+
+ // Return whether the addresses have been set already.
+ bool
+ are_addresses_set() const
+ { return this->are_addresses_set_; }
+
+ // Set the addresses.
+ void
+ set_addresses(uint64_t vaddr, uint64_t paddr)
+ {
+ this->vaddr_ = vaddr;
+ this->paddr_ = paddr;
+ this->are_addresses_set_ = true;
+ }
+
// Set the address of the segment to ADDR and the offset to *POFF
- // (aligned if necessary), and set the addresses and offsets of all
- // contained output sections accordingly. Set the section indexes
- // of all contained output sections starting with *PSHNDX. Return
- // the address of the immediately following segment. Update *POFF
- // and *PSHNDX. This should only be called for a PT_LOAD segment.
+ // and set the addresses and offsets of all contained output
+ // sections accordingly. Set the section indexes of all contained
+ // output sections starting with *PSHNDX. If RESET is true, first
+ // reset the addresses of the contained sections. Return the
+ // address of the immediately following segment. Update *POFF and
+ // *PSHNDX. This should only be called for a PT_LOAD segment.
uint64_t
- set_section_addresses(uint64_t addr, off_t* poff, unsigned int* pshndx);
+ set_section_addresses(bool reset, 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_minimum_p_align(uint64_t align)
+ { this->min_p_align_ = align; }
// Set the offset of this segment based on the section. This should
// only be called for a non-PT_LOAD segment.
// Find the maximum alignment in an Output_data_list.
static uint64_t
- maximum_alignment(const Output_data_list*);
+ maximum_alignment_list(const Output_data_list*);
// Set the section addresses in an Output_data_list.
uint64_t
- set_section_list_addresses(Output_data_list*, uint64_t addr, off_t* poff,
- unsigned int* pshndx);
+ set_section_list_addresses(bool reset, Output_data_list*, uint64_t addr,
+ off_t* poff, unsigned int* pshndx);
// Return the number of Output_sections in an Output_data_list.
unsigned int
uint64_t paddr_;
// The size of the segment in memory.
uint64_t memsz_;
- // 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 maximum section alignment. The is_max_align_known_ field
+ // indicates whether this has been finalized.
+ uint64_t max_align_;
+ // The required minimum value for the p_align field. This is used
+ // for PT_LOAD segments. Note that this does not mean that
+ // addresses should be aligned to this value; it means the p_paddr
+ // and p_vaddr fields must be congruent modulo this value. For
+ // non-PT_LOAD segments, the dynamic linker works more efficiently
+ // if the p_align field has the more conventional value, although it
+ // can align as needed.
+ uint64_t min_p_align_;
// The offset of the segment data within the file.
off_t offset_;
// The size of the segment data in the file.
elfcpp::Elf_Word type_;
// The segment flags.
elfcpp::Elf_Word flags_;
- // Whether we have finalized align_.
- bool is_align_known_;
+ // Whether we have finalized max_align_.
+ bool is_max_align_known_ : 1;
+ // Whether vaddr and paddr were set by a linker script.
+ bool are_addresses_set_ : 1;
};
// This class represents the output file.
projects / deliverable / binutils-gdb.git / blobdiff