2008-01-23 02:31:13 +01:00
|
|
|
// script-sections.cc -- linker script SECTIONS for gold
|
|
|
|
|
2017-01-02 04:36:43 +01:00
|
|
|
// Copyright (C) 2008-2017 Free Software Foundation, Inc.
|
2008-01-23 02:31:13 +01:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
#include "gold.h"
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
#include <cstring>
|
|
|
|
#include <algorithm>
|
|
|
|
#include <list>
|
2008-02-04 23:54:31 +01:00
|
|
|
#include <map>
|
2008-01-23 02:31:13 +01:00
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
2008-02-04 06:43:05 +01:00
|
|
|
#include <fnmatch.h>
|
2008-01-23 02:31:13 +01:00
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
#include "parameters.h"
|
|
|
|
#include "object.h"
|
|
|
|
#include "layout.h"
|
|
|
|
#include "output.h"
|
2008-01-23 02:31:13 +01:00
|
|
|
#include "script-c.h"
|
|
|
|
#include "script.h"
|
|
|
|
#include "script-sections.h"
|
|
|
|
|
|
|
|
// Support for the SECTIONS clause in linker scripts.
|
|
|
|
|
|
|
|
namespace gold
|
|
|
|
{
|
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
// A region of memory.
|
|
|
|
class Memory_region
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Memory_region(const char* name, size_t namelen, unsigned int attributes,
|
|
|
|
Expression* start, Expression* length)
|
|
|
|
: name_(name, namelen),
|
|
|
|
attributes_(attributes),
|
|
|
|
start_(start),
|
|
|
|
length_(length),
|
2010-10-06 10:58:59 +02:00
|
|
|
current_offset_(0),
|
2010-09-16 17:52:15 +02:00
|
|
|
vma_sections_(),
|
2010-10-06 10:58:59 +02:00
|
|
|
lma_sections_(),
|
|
|
|
last_section_(NULL)
|
2010-09-08 18:10:33 +02:00
|
|
|
{ }
|
|
|
|
|
|
|
|
// Return the name of this region.
|
|
|
|
const std::string&
|
|
|
|
name() const
|
|
|
|
{ return this->name_; }
|
|
|
|
|
|
|
|
// Return the start address of this region.
|
|
|
|
Expression*
|
|
|
|
start_address() const
|
|
|
|
{ return this->start_; }
|
|
|
|
|
|
|
|
// Return the length of this region.
|
|
|
|
Expression*
|
|
|
|
length() const
|
|
|
|
{ return this->length_; }
|
|
|
|
|
|
|
|
// Print the region (when debugging).
|
|
|
|
void
|
|
|
|
print(FILE*) const;
|
|
|
|
|
|
|
|
// Return true if <name,namelen> matches this region.
|
|
|
|
bool
|
|
|
|
name_match(const char* name, size_t namelen)
|
|
|
|
{
|
|
|
|
return (this->name_.length() == namelen
|
|
|
|
&& strncmp(this->name_.c_str(), name, namelen) == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
Expression*
|
2010-10-06 10:58:59 +02:00
|
|
|
get_current_address() const
|
2010-09-08 18:10:33 +02:00
|
|
|
{
|
|
|
|
return
|
|
|
|
script_exp_binary_add(this->start_,
|
2010-10-06 10:58:59 +02:00
|
|
|
script_exp_integer(this->current_offset_));
|
2010-09-08 18:10:33 +02:00
|
|
|
}
|
2015-08-26 09:03:04 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
set_address(uint64_t addr, const Symbol_table* symtab, const Layout* layout)
|
|
|
|
{
|
|
|
|
uint64_t start = this->start_->eval(symtab, layout, false);
|
|
|
|
uint64_t len = this->length_->eval(symtab, layout, false);
|
|
|
|
if (addr < start || addr >= start + len)
|
|
|
|
gold_error(_("address 0x%llx is not within region %s"),
|
|
|
|
static_cast<unsigned long long>(addr),
|
|
|
|
this->name_.c_str());
|
|
|
|
else if (addr < start + this->current_offset_)
|
|
|
|
gold_error(_("address 0x%llx moves dot backwards in region %s"),
|
|
|
|
static_cast<unsigned long long>(addr),
|
|
|
|
this->name_.c_str());
|
|
|
|
this->current_offset_ = addr - start;
|
|
|
|
}
|
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
void
|
2010-10-06 10:58:59 +02:00
|
|
|
increment_offset(std::string section_name, uint64_t amount,
|
|
|
|
const Symbol_table* symtab, const Layout* layout)
|
2010-09-08 18:10:33 +02:00
|
|
|
{
|
2010-10-06 10:58:59 +02:00
|
|
|
this->current_offset_ += amount;
|
2010-09-08 18:10:33 +02:00
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
if (this->current_offset_
|
2010-09-08 18:10:33 +02:00
|
|
|
> this->length_->eval(symtab, layout, false))
|
2010-10-06 10:58:59 +02:00
|
|
|
gold_error(_("section %s overflows end of region %s"),
|
|
|
|
section_name.c_str(), this->name_.c_str());
|
2010-09-08 18:10:33 +02:00
|
|
|
}
|
2015-08-26 09:03:04 +02:00
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
// Returns true iff there is room left in this region
|
|
|
|
// for AMOUNT more bytes of data.
|
|
|
|
bool
|
|
|
|
has_room_for(const Symbol_table* symtab, const Layout* layout,
|
|
|
|
uint64_t amount) const
|
2010-09-08 18:10:33 +02:00
|
|
|
{
|
2010-10-06 10:58:59 +02:00
|
|
|
return (this->current_offset_ + amount
|
|
|
|
< this->length_->eval(symtab, layout, false));
|
2010-09-08 18:10:33 +02:00
|
|
|
}
|
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
// Return true if the provided section flags
|
|
|
|
// are compatible with this region's attributes.
|
|
|
|
bool
|
|
|
|
attributes_compatible(elfcpp::Elf_Xword flags, elfcpp::Elf_Xword type) const;
|
2015-08-26 09:03:04 +02:00
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
void
|
|
|
|
add_section(Output_section_definition* sec, bool vma)
|
|
|
|
{
|
|
|
|
if (vma)
|
|
|
|
this->vma_sections_.push_back(sec);
|
|
|
|
else
|
|
|
|
this->lma_sections_.push_back(sec);
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef std::vector<Output_section_definition*> Section_list;
|
|
|
|
|
|
|
|
// Return the start of the list of sections
|
|
|
|
// whose VMAs are taken from this region.
|
|
|
|
Section_list::const_iterator
|
2010-10-06 10:58:59 +02:00
|
|
|
get_vma_section_list_start() const
|
2010-09-08 18:10:33 +02:00
|
|
|
{ return this->vma_sections_.begin(); }
|
|
|
|
|
|
|
|
// Return the start of the list of sections
|
|
|
|
// whose LMAs are taken from this region.
|
|
|
|
Section_list::const_iterator
|
2010-10-06 10:58:59 +02:00
|
|
|
get_lma_section_list_start() const
|
2010-09-08 18:10:33 +02:00
|
|
|
{ return this->lma_sections_.begin(); }
|
|
|
|
|
|
|
|
// Return the end of the list of sections
|
|
|
|
// whose VMAs are taken from this region.
|
|
|
|
Section_list::const_iterator
|
2010-10-06 10:58:59 +02:00
|
|
|
get_vma_section_list_end() const
|
2010-09-08 18:10:33 +02:00
|
|
|
{ return this->vma_sections_.end(); }
|
|
|
|
|
|
|
|
// Return the end of the list of sections
|
|
|
|
// whose LMAs are taken from this region.
|
|
|
|
Section_list::const_iterator
|
2010-10-06 10:58:59 +02:00
|
|
|
get_lma_section_list_end() const
|
2010-09-08 18:10:33 +02:00
|
|
|
{ return this->lma_sections_.end(); }
|
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
Output_section_definition*
|
|
|
|
get_last_section() const
|
|
|
|
{ return this->last_section_; }
|
|
|
|
|
|
|
|
void
|
|
|
|
set_last_section(Output_section_definition* sec)
|
|
|
|
{ this->last_section_ = sec; }
|
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
private:
|
|
|
|
|
|
|
|
std::string name_;
|
|
|
|
unsigned int attributes_;
|
|
|
|
Expression* start_;
|
|
|
|
Expression* length_;
|
2010-10-06 10:58:59 +02:00
|
|
|
// The offset to the next free byte in the region.
|
|
|
|
// Note - for compatibility with GNU LD we only maintain one offset
|
|
|
|
// regardless of whether the region is being used for VMA values,
|
|
|
|
// LMA values, or both.
|
|
|
|
uint64_t current_offset_;
|
2010-09-08 18:10:33 +02:00
|
|
|
// A list of sections whose VMAs are set inside this region.
|
|
|
|
Section_list vma_sections_;
|
|
|
|
// A list of sections whose LMAs are set inside this region.
|
|
|
|
Section_list lma_sections_;
|
2010-10-06 10:58:59 +02:00
|
|
|
// The latest section to make use of this region.
|
|
|
|
Output_section_definition* last_section_;
|
2010-09-08 18:10:33 +02:00
|
|
|
};
|
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
// Return true if the provided section flags
|
|
|
|
// are compatible with this region's attributes.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Memory_region::attributes_compatible(elfcpp::Elf_Xword flags,
|
|
|
|
elfcpp::Elf_Xword type) const
|
|
|
|
{
|
|
|
|
unsigned int attrs = this->attributes_;
|
|
|
|
|
|
|
|
// No attributes means that this region is not compatible with anything.
|
|
|
|
if (attrs == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
bool match = true;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
switch (attrs & - attrs)
|
|
|
|
{
|
|
|
|
case MEM_EXECUTABLE:
|
|
|
|
if ((flags & elfcpp::SHF_EXECINSTR) == 0)
|
|
|
|
match = false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MEM_WRITEABLE:
|
|
|
|
if ((flags & elfcpp::SHF_WRITE) == 0)
|
|
|
|
match = false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MEM_READABLE:
|
|
|
|
// All sections are presumed readable.
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MEM_ALLOCATABLE:
|
|
|
|
if ((flags & elfcpp::SHF_ALLOC) == 0)
|
|
|
|
match = false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MEM_INITIALIZED:
|
|
|
|
if ((type & elfcpp::SHT_NOBITS) != 0)
|
|
|
|
match = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
attrs &= ~ (attrs & - attrs);
|
|
|
|
}
|
|
|
|
while (attrs != 0);
|
2016-08-12 18:55:25 +02:00
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
return match;
|
|
|
|
}
|
2016-08-12 18:55:25 +02:00
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
// Print a memory region.
|
|
|
|
|
|
|
|
void
|
|
|
|
Memory_region::print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " %s", this->name_.c_str());
|
|
|
|
|
|
|
|
unsigned int attrs = this->attributes_;
|
|
|
|
if (attrs != 0)
|
|
|
|
{
|
|
|
|
fprintf(f, " (");
|
|
|
|
do
|
|
|
|
{
|
|
|
|
switch (attrs & - attrs)
|
|
|
|
{
|
|
|
|
case MEM_EXECUTABLE: fputc('x', f); break;
|
|
|
|
case MEM_WRITEABLE: fputc('w', f); break;
|
|
|
|
case MEM_READABLE: fputc('r', f); break;
|
|
|
|
case MEM_ALLOCATABLE: fputc('a', f); break;
|
|
|
|
case MEM_INITIALIZED: fputc('i', f); break;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
attrs &= ~ (attrs & - attrs);
|
|
|
|
}
|
|
|
|
while (attrs != 0);
|
|
|
|
fputc(')', f);
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(f, " : origin = ");
|
|
|
|
this->start_->print(f);
|
|
|
|
fprintf(f, ", length = ");
|
|
|
|
this->length_->print(f);
|
|
|
|
fprintf(f, "\n");
|
|
|
|
}
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
// Manage orphan sections. This is intended to be largely compatible
|
|
|
|
// with the GNU linker. The Linux kernel implicitly relies on
|
|
|
|
// something similar to the GNU linker's orphan placement. We
|
|
|
|
// originally used a simpler scheme here, but it caused the kernel
|
|
|
|
// build to fail, and was also rather inefficient.
|
|
|
|
|
|
|
|
class Orphan_section_placement
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
typedef Script_sections::Elements_iterator Elements_iterator;
|
|
|
|
|
|
|
|
public:
|
|
|
|
Orphan_section_placement();
|
|
|
|
|
|
|
|
// Handle an output section during initialization of this mapping.
|
|
|
|
void
|
|
|
|
output_section_init(const std::string& name, Output_section*,
|
|
|
|
Elements_iterator location);
|
|
|
|
|
|
|
|
// Initialize the last location.
|
|
|
|
void
|
|
|
|
last_init(Elements_iterator location);
|
|
|
|
|
|
|
|
// Set *PWHERE to the address of an iterator pointing to the
|
|
|
|
// location to use for an orphan section. Return true if the
|
|
|
|
// iterator has a value, false otherwise.
|
|
|
|
bool
|
|
|
|
find_place(Output_section*, Elements_iterator** pwhere);
|
|
|
|
|
2016-12-13 02:52:09 +01:00
|
|
|
// Update PLACE_LAST_ALLOC.
|
|
|
|
void
|
|
|
|
update_last_alloc(Elements_iterator where);
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
// Return the iterator being used for sections at the very end of
|
|
|
|
// the linker script.
|
|
|
|
Elements_iterator
|
|
|
|
last_place() const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
// The places that we specifically recognize. This list is copied
|
|
|
|
// from the GNU linker.
|
|
|
|
enum Place_index
|
|
|
|
{
|
|
|
|
PLACE_TEXT,
|
|
|
|
PLACE_RODATA,
|
|
|
|
PLACE_DATA,
|
2010-03-23 22:06:10 +01:00
|
|
|
PLACE_TLS,
|
|
|
|
PLACE_TLS_BSS,
|
2009-03-19 06:51:49 +01:00
|
|
|
PLACE_BSS,
|
Fix problems with bss handling in linker scripts.
PR 16711 noted that gold allocates file space for BSS sections when using
a linker script. I've fixed that by rewriting set_section_addresses and
set_section_list_addresses to track the file offset separate from the
current virtual address, so that BSS sections do not move the file offset.
Now, if a series of BSS sections come at the end of a segment, we do not
allocate file space; but if a script forces them into the middle of a
segment, we will still allocate file space (matching Gnu ld behavior).
I've also added a warning when that happens.
That exposed another problem where orphan .bss sections were sometimes
placed in the middle of a segment. For example, if the script mentions
the .got section, but both .data and .bss are orphans, gold would put
both .data and .bss in front of .got. I've fixed that by ensuring that
orphan BSS sections are always placed after all other allocated sections.
It also exposed a problem where the SUBALIGN property is not handled
properly. The ld manual clearly states that it should override input section
alignment, whether greater or less than the given alignment, but gold would
only increase an input section's alignment. Gold would also place the output
section based on its original alignment before the SUBALIGN property took
effect, leading to a misaligned output section (where the input section
was properly aligned in memory, but was not aligned relative to the start
of the section), in violation of the ELF/gABI spec. I've fixed that by
making sure that the SUBALIGN property overrides the internal alignment of
the input sections as well as the external alignment of the output section.
This affected the behavior of script_test_2, which was written to expect
a misaligned section.
The net effect is, I think, improved compatibility with the BFD linker.
There are still cases where orphan placement differs, but the differences
should be rarer and less important. ALIGN and SUBALIGN behavior is closer,
but still not an exact match -- I still found cases where ld would create
a misaligned output section, and where gold will properly align it.
gold/
PR gold/16711
* output.cc (Output_section::set_final_data_size): Calculate data size
based on relative offset rather than file offset.
(Output_segment::set_section_addresses): Track file offset separately
from address offset.
(Output_segment::set_section_list_addresses): Add pfoff parameter.
Track file offset separately. Don't move file offset for BSS
sections.
* output.h (Output_segment::set_section_list_addresses): Add pfoff
parameter.
* script-sections.cc (Orphan_section_placement): Add PLACE_LAST_ALLOC.
(Orphan_section_placement::Orphan_section_placement): Initialize it.
(Orphan_section_placement::output_section_init): Track last allocated
section.
(Orphan_section_placement::find_place): Place BSS after last allocated
section.
(Output_section_element_input::set_section_addresses): Always override
input section alignment when SUBALIGN is specified.
(Output_section_definition::set_section_addresses): Override alignment
of output section when SUBALIGN is specified.
* testsuite/Makefile.am (script_test_15a, script_test_15b)
(script_test_15c): New test cases.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_2.cc: Adjust expected layout.
* testsuite/script_test_15.c: New source file.
* testsuite/script_test_15a.sh: New shell script.
* testsuite/script_test_15a.t: New linker script.
* testsuite/script_test_15b.sh: New shell script.
* testsuite/script_test_15b.t: New linker script.
* testsuite/script_test_15c.sh: New shell script.
* testsuite/script_test_15c.t: New linker script.
2016-12-12 02:31:25 +01:00
|
|
|
PLACE_LAST_ALLOC,
|
2009-03-19 06:51:49 +01:00
|
|
|
PLACE_REL,
|
|
|
|
PLACE_INTERP,
|
|
|
|
PLACE_NONALLOC,
|
|
|
|
PLACE_LAST,
|
|
|
|
PLACE_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
// The information we keep for a specific place.
|
|
|
|
struct Place
|
|
|
|
{
|
|
|
|
// The name of sections for this place.
|
|
|
|
const char* name;
|
|
|
|
// Whether we have a location for this place.
|
|
|
|
bool have_location;
|
|
|
|
// The iterator for this place.
|
|
|
|
Elements_iterator location;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Initialize one place element.
|
|
|
|
void
|
|
|
|
initialize_place(Place_index, const char*);
|
|
|
|
|
|
|
|
// The places.
|
|
|
|
Place places_[PLACE_MAX];
|
|
|
|
// True if this is the first call to output_section_init.
|
|
|
|
bool first_init_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Initialize Orphan_section_placement.
|
|
|
|
|
|
|
|
Orphan_section_placement::Orphan_section_placement()
|
|
|
|
: first_init_(true)
|
|
|
|
{
|
|
|
|
this->initialize_place(PLACE_TEXT, ".text");
|
|
|
|
this->initialize_place(PLACE_RODATA, ".rodata");
|
|
|
|
this->initialize_place(PLACE_DATA, ".data");
|
2010-03-23 22:06:10 +01:00
|
|
|
this->initialize_place(PLACE_TLS, NULL);
|
|
|
|
this->initialize_place(PLACE_TLS_BSS, NULL);
|
2009-03-19 06:51:49 +01:00
|
|
|
this->initialize_place(PLACE_BSS, ".bss");
|
Fix problems with bss handling in linker scripts.
PR 16711 noted that gold allocates file space for BSS sections when using
a linker script. I've fixed that by rewriting set_section_addresses and
set_section_list_addresses to track the file offset separate from the
current virtual address, so that BSS sections do not move the file offset.
Now, if a series of BSS sections come at the end of a segment, we do not
allocate file space; but if a script forces them into the middle of a
segment, we will still allocate file space (matching Gnu ld behavior).
I've also added a warning when that happens.
That exposed another problem where orphan .bss sections were sometimes
placed in the middle of a segment. For example, if the script mentions
the .got section, but both .data and .bss are orphans, gold would put
both .data and .bss in front of .got. I've fixed that by ensuring that
orphan BSS sections are always placed after all other allocated sections.
It also exposed a problem where the SUBALIGN property is not handled
properly. The ld manual clearly states that it should override input section
alignment, whether greater or less than the given alignment, but gold would
only increase an input section's alignment. Gold would also place the output
section based on its original alignment before the SUBALIGN property took
effect, leading to a misaligned output section (where the input section
was properly aligned in memory, but was not aligned relative to the start
of the section), in violation of the ELF/gABI spec. I've fixed that by
making sure that the SUBALIGN property overrides the internal alignment of
the input sections as well as the external alignment of the output section.
This affected the behavior of script_test_2, which was written to expect
a misaligned section.
The net effect is, I think, improved compatibility with the BFD linker.
There are still cases where orphan placement differs, but the differences
should be rarer and less important. ALIGN and SUBALIGN behavior is closer,
but still not an exact match -- I still found cases where ld would create
a misaligned output section, and where gold will properly align it.
gold/
PR gold/16711
* output.cc (Output_section::set_final_data_size): Calculate data size
based on relative offset rather than file offset.
(Output_segment::set_section_addresses): Track file offset separately
from address offset.
(Output_segment::set_section_list_addresses): Add pfoff parameter.
Track file offset separately. Don't move file offset for BSS
sections.
* output.h (Output_segment::set_section_list_addresses): Add pfoff
parameter.
* script-sections.cc (Orphan_section_placement): Add PLACE_LAST_ALLOC.
(Orphan_section_placement::Orphan_section_placement): Initialize it.
(Orphan_section_placement::output_section_init): Track last allocated
section.
(Orphan_section_placement::find_place): Place BSS after last allocated
section.
(Output_section_element_input::set_section_addresses): Always override
input section alignment when SUBALIGN is specified.
(Output_section_definition::set_section_addresses): Override alignment
of output section when SUBALIGN is specified.
* testsuite/Makefile.am (script_test_15a, script_test_15b)
(script_test_15c): New test cases.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_2.cc: Adjust expected layout.
* testsuite/script_test_15.c: New source file.
* testsuite/script_test_15a.sh: New shell script.
* testsuite/script_test_15a.t: New linker script.
* testsuite/script_test_15b.sh: New shell script.
* testsuite/script_test_15b.t: New linker script.
* testsuite/script_test_15c.sh: New shell script.
* testsuite/script_test_15c.t: New linker script.
2016-12-12 02:31:25 +01:00
|
|
|
this->initialize_place(PLACE_LAST_ALLOC, NULL);
|
2009-03-19 06:51:49 +01:00
|
|
|
this->initialize_place(PLACE_REL, NULL);
|
|
|
|
this->initialize_place(PLACE_INTERP, ".interp");
|
|
|
|
this->initialize_place(PLACE_NONALLOC, NULL);
|
|
|
|
this->initialize_place(PLACE_LAST, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize one place element.
|
|
|
|
|
|
|
|
void
|
|
|
|
Orphan_section_placement::initialize_place(Place_index index, const char* name)
|
|
|
|
{
|
|
|
|
this->places_[index].name = name;
|
|
|
|
this->places_[index].have_location = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// While initializing the Orphan_section_placement information, this
|
|
|
|
// is called once for each output section named in the linker script.
|
|
|
|
// If we found an output section during the link, it will be passed in
|
|
|
|
// OS.
|
|
|
|
|
|
|
|
void
|
|
|
|
Orphan_section_placement::output_section_init(const std::string& name,
|
|
|
|
Output_section* os,
|
|
|
|
Elements_iterator location)
|
|
|
|
{
|
|
|
|
bool first_init = this->first_init_;
|
|
|
|
this->first_init_ = false;
|
|
|
|
|
Fix problems with bss handling in linker scripts.
PR 16711 noted that gold allocates file space for BSS sections when using
a linker script. I've fixed that by rewriting set_section_addresses and
set_section_list_addresses to track the file offset separate from the
current virtual address, so that BSS sections do not move the file offset.
Now, if a series of BSS sections come at the end of a segment, we do not
allocate file space; but if a script forces them into the middle of a
segment, we will still allocate file space (matching Gnu ld behavior).
I've also added a warning when that happens.
That exposed another problem where orphan .bss sections were sometimes
placed in the middle of a segment. For example, if the script mentions
the .got section, but both .data and .bss are orphans, gold would put
both .data and .bss in front of .got. I've fixed that by ensuring that
orphan BSS sections are always placed after all other allocated sections.
It also exposed a problem where the SUBALIGN property is not handled
properly. The ld manual clearly states that it should override input section
alignment, whether greater or less than the given alignment, but gold would
only increase an input section's alignment. Gold would also place the output
section based on its original alignment before the SUBALIGN property took
effect, leading to a misaligned output section (where the input section
was properly aligned in memory, but was not aligned relative to the start
of the section), in violation of the ELF/gABI spec. I've fixed that by
making sure that the SUBALIGN property overrides the internal alignment of
the input sections as well as the external alignment of the output section.
This affected the behavior of script_test_2, which was written to expect
a misaligned section.
The net effect is, I think, improved compatibility with the BFD linker.
There are still cases where orphan placement differs, but the differences
should be rarer and less important. ALIGN and SUBALIGN behavior is closer,
but still not an exact match -- I still found cases where ld would create
a misaligned output section, and where gold will properly align it.
gold/
PR gold/16711
* output.cc (Output_section::set_final_data_size): Calculate data size
based on relative offset rather than file offset.
(Output_segment::set_section_addresses): Track file offset separately
from address offset.
(Output_segment::set_section_list_addresses): Add pfoff parameter.
Track file offset separately. Don't move file offset for BSS
sections.
* output.h (Output_segment::set_section_list_addresses): Add pfoff
parameter.
* script-sections.cc (Orphan_section_placement): Add PLACE_LAST_ALLOC.
(Orphan_section_placement::Orphan_section_placement): Initialize it.
(Orphan_section_placement::output_section_init): Track last allocated
section.
(Orphan_section_placement::find_place): Place BSS after last allocated
section.
(Output_section_element_input::set_section_addresses): Always override
input section alignment when SUBALIGN is specified.
(Output_section_definition::set_section_addresses): Override alignment
of output section when SUBALIGN is specified.
* testsuite/Makefile.am (script_test_15a, script_test_15b)
(script_test_15c): New test cases.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_2.cc: Adjust expected layout.
* testsuite/script_test_15.c: New source file.
* testsuite/script_test_15a.sh: New shell script.
* testsuite/script_test_15a.t: New linker script.
* testsuite/script_test_15b.sh: New shell script.
* testsuite/script_test_15b.t: New linker script.
* testsuite/script_test_15c.sh: New shell script.
* testsuite/script_test_15c.t: New linker script.
2016-12-12 02:31:25 +01:00
|
|
|
// Remember the last allocated section. Any orphan bss sections
|
|
|
|
// will be placed after it.
|
|
|
|
if (os != NULL
|
|
|
|
&& (os->flags() & elfcpp::SHF_ALLOC) != 0)
|
|
|
|
{
|
|
|
|
this->places_[PLACE_LAST_ALLOC].location = location;
|
|
|
|
this->places_[PLACE_LAST_ALLOC].have_location = true;
|
|
|
|
}
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
for (int i = 0; i < PLACE_MAX; ++i)
|
|
|
|
{
|
|
|
|
if (this->places_[i].name != NULL && this->places_[i].name == name)
|
|
|
|
{
|
|
|
|
if (this->places_[i].have_location)
|
|
|
|
{
|
|
|
|
// We have already seen a section with this name.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
this->places_[i].location = location;
|
|
|
|
this->places_[i].have_location = true;
|
|
|
|
|
|
|
|
// If we just found the .bss section, restart the search for
|
|
|
|
// an unallocated section. This follows the GNU linker's
|
|
|
|
// behaviour.
|
|
|
|
if (i == PLACE_BSS)
|
|
|
|
this->places_[PLACE_NONALLOC].have_location = false;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Relocation sections.
|
|
|
|
if (!this->places_[PLACE_REL].have_location
|
|
|
|
&& os != NULL
|
|
|
|
&& (os->type() == elfcpp::SHT_REL || os->type() == elfcpp::SHT_RELA)
|
|
|
|
&& (os->flags() & elfcpp::SHF_ALLOC) != 0)
|
|
|
|
{
|
|
|
|
this->places_[PLACE_REL].location = location;
|
|
|
|
this->places_[PLACE_REL].have_location = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We find the location for unallocated sections by finding the
|
|
|
|
// first debugging or comment section after the BSS section (if
|
|
|
|
// there is one).
|
|
|
|
if (!this->places_[PLACE_NONALLOC].have_location
|
|
|
|
&& (name == ".comment" || Layout::is_debug_info_section(name.c_str())))
|
|
|
|
{
|
|
|
|
// We add orphan sections after the location in PLACES_. We
|
|
|
|
// want to store unallocated sections before LOCATION. If this
|
|
|
|
// is the very first section, we can't use it.
|
|
|
|
if (!first_init)
|
|
|
|
{
|
|
|
|
--location;
|
|
|
|
this->places_[PLACE_NONALLOC].location = location;
|
|
|
|
this->places_[PLACE_NONALLOC].have_location = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the last location.
|
|
|
|
|
|
|
|
void
|
|
|
|
Orphan_section_placement::last_init(Elements_iterator location)
|
|
|
|
{
|
|
|
|
this->places_[PLACE_LAST].location = location;
|
|
|
|
this->places_[PLACE_LAST].have_location = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set *PWHERE to the address of an iterator pointing to the location
|
|
|
|
// to use for an orphan section. Return true if the iterator has a
|
|
|
|
// value, false otherwise.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Orphan_section_placement::find_place(Output_section* os,
|
|
|
|
Elements_iterator** pwhere)
|
|
|
|
{
|
|
|
|
// Figure out where OS should go. This is based on the GNU linker
|
|
|
|
// code. FIXME: The GNU linker handles small data sections
|
|
|
|
// specially, but we don't.
|
|
|
|
elfcpp::Elf_Word type = os->type();
|
|
|
|
elfcpp::Elf_Xword flags = os->flags();
|
|
|
|
Place_index index;
|
|
|
|
if ((flags & elfcpp::SHF_ALLOC) == 0
|
|
|
|
&& !Layout::is_debug_info_section(os->name()))
|
|
|
|
index = PLACE_NONALLOC;
|
|
|
|
else if ((flags & elfcpp::SHF_ALLOC) == 0)
|
|
|
|
index = PLACE_LAST;
|
|
|
|
else if (type == elfcpp::SHT_NOTE)
|
|
|
|
index = PLACE_INTERP;
|
2010-03-23 22:06:10 +01:00
|
|
|
else if ((flags & elfcpp::SHF_TLS) != 0)
|
|
|
|
{
|
|
|
|
if (type == elfcpp::SHT_NOBITS)
|
|
|
|
index = PLACE_TLS_BSS;
|
|
|
|
else
|
|
|
|
index = PLACE_TLS;
|
|
|
|
}
|
2009-03-19 06:51:49 +01:00
|
|
|
else if (type == elfcpp::SHT_NOBITS)
|
|
|
|
index = PLACE_BSS;
|
|
|
|
else if ((flags & elfcpp::SHF_WRITE) != 0)
|
|
|
|
index = PLACE_DATA;
|
|
|
|
else if (type == elfcpp::SHT_REL || type == elfcpp::SHT_RELA)
|
|
|
|
index = PLACE_REL;
|
|
|
|
else if ((flags & elfcpp::SHF_EXECINSTR) == 0)
|
|
|
|
index = PLACE_RODATA;
|
|
|
|
else
|
|
|
|
index = PLACE_TEXT;
|
|
|
|
|
|
|
|
// If we don't have a location yet, try to find one based on a
|
|
|
|
// plausible ordering of sections.
|
|
|
|
if (!this->places_[index].have_location)
|
|
|
|
{
|
|
|
|
Place_index follow;
|
|
|
|
switch (index)
|
|
|
|
{
|
|
|
|
default:
|
|
|
|
follow = PLACE_MAX;
|
|
|
|
break;
|
|
|
|
case PLACE_RODATA:
|
|
|
|
follow = PLACE_TEXT;
|
|
|
|
break;
|
2016-12-13 02:52:09 +01:00
|
|
|
case PLACE_DATA:
|
|
|
|
follow = PLACE_RODATA;
|
|
|
|
if (!this->places_[PLACE_RODATA].have_location)
|
|
|
|
follow = PLACE_TEXT;
|
|
|
|
break;
|
2009-03-19 06:51:49 +01:00
|
|
|
case PLACE_BSS:
|
Fix problems with bss handling in linker scripts.
PR 16711 noted that gold allocates file space for BSS sections when using
a linker script. I've fixed that by rewriting set_section_addresses and
set_section_list_addresses to track the file offset separate from the
current virtual address, so that BSS sections do not move the file offset.
Now, if a series of BSS sections come at the end of a segment, we do not
allocate file space; but if a script forces them into the middle of a
segment, we will still allocate file space (matching Gnu ld behavior).
I've also added a warning when that happens.
That exposed another problem where orphan .bss sections were sometimes
placed in the middle of a segment. For example, if the script mentions
the .got section, but both .data and .bss are orphans, gold would put
both .data and .bss in front of .got. I've fixed that by ensuring that
orphan BSS sections are always placed after all other allocated sections.
It also exposed a problem where the SUBALIGN property is not handled
properly. The ld manual clearly states that it should override input section
alignment, whether greater or less than the given alignment, but gold would
only increase an input section's alignment. Gold would also place the output
section based on its original alignment before the SUBALIGN property took
effect, leading to a misaligned output section (where the input section
was properly aligned in memory, but was not aligned relative to the start
of the section), in violation of the ELF/gABI spec. I've fixed that by
making sure that the SUBALIGN property overrides the internal alignment of
the input sections as well as the external alignment of the output section.
This affected the behavior of script_test_2, which was written to expect
a misaligned section.
The net effect is, I think, improved compatibility with the BFD linker.
There are still cases where orphan placement differs, but the differences
should be rarer and less important. ALIGN and SUBALIGN behavior is closer,
but still not an exact match -- I still found cases where ld would create
a misaligned output section, and where gold will properly align it.
gold/
PR gold/16711
* output.cc (Output_section::set_final_data_size): Calculate data size
based on relative offset rather than file offset.
(Output_segment::set_section_addresses): Track file offset separately
from address offset.
(Output_segment::set_section_list_addresses): Add pfoff parameter.
Track file offset separately. Don't move file offset for BSS
sections.
* output.h (Output_segment::set_section_list_addresses): Add pfoff
parameter.
* script-sections.cc (Orphan_section_placement): Add PLACE_LAST_ALLOC.
(Orphan_section_placement::Orphan_section_placement): Initialize it.
(Orphan_section_placement::output_section_init): Track last allocated
section.
(Orphan_section_placement::find_place): Place BSS after last allocated
section.
(Output_section_element_input::set_section_addresses): Always override
input section alignment when SUBALIGN is specified.
(Output_section_definition::set_section_addresses): Override alignment
of output section when SUBALIGN is specified.
* testsuite/Makefile.am (script_test_15a, script_test_15b)
(script_test_15c): New test cases.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_2.cc: Adjust expected layout.
* testsuite/script_test_15.c: New source file.
* testsuite/script_test_15a.sh: New shell script.
* testsuite/script_test_15a.t: New linker script.
* testsuite/script_test_15b.sh: New shell script.
* testsuite/script_test_15b.t: New linker script.
* testsuite/script_test_15c.sh: New shell script.
* testsuite/script_test_15c.t: New linker script.
2016-12-12 02:31:25 +01:00
|
|
|
follow = PLACE_LAST_ALLOC;
|
2009-03-19 06:51:49 +01:00
|
|
|
break;
|
|
|
|
case PLACE_REL:
|
|
|
|
follow = PLACE_TEXT;
|
|
|
|
break;
|
|
|
|
case PLACE_INTERP:
|
|
|
|
follow = PLACE_TEXT;
|
|
|
|
break;
|
2010-03-23 22:06:10 +01:00
|
|
|
case PLACE_TLS:
|
|
|
|
follow = PLACE_DATA;
|
|
|
|
break;
|
|
|
|
case PLACE_TLS_BSS:
|
|
|
|
follow = PLACE_TLS;
|
|
|
|
if (!this->places_[PLACE_TLS].have_location)
|
|
|
|
follow = PLACE_DATA;
|
|
|
|
break;
|
2009-03-19 06:51:49 +01:00
|
|
|
}
|
|
|
|
if (follow != PLACE_MAX && this->places_[follow].have_location)
|
|
|
|
{
|
|
|
|
// Set the location of INDEX to the location of FOLLOW. The
|
|
|
|
// location of INDEX will then be incremented by the caller,
|
|
|
|
// so anything in INDEX will continue to be after anything
|
|
|
|
// in FOLLOW.
|
|
|
|
this->places_[index].location = this->places_[follow].location;
|
|
|
|
this->places_[index].have_location = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*pwhere = &this->places_[index].location;
|
|
|
|
bool ret = this->places_[index].have_location;
|
|
|
|
|
|
|
|
// The caller will set the location.
|
|
|
|
this->places_[index].have_location = true;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-12-13 02:52:09 +01:00
|
|
|
// Update PLACE_LAST_ALLOC.
|
|
|
|
void
|
|
|
|
Orphan_section_placement::update_last_alloc(Elements_iterator elem)
|
|
|
|
{
|
|
|
|
Elements_iterator prev = elem;
|
|
|
|
--prev;
|
|
|
|
if (this->places_[PLACE_LAST_ALLOC].have_location
|
|
|
|
&& this->places_[PLACE_LAST_ALLOC].location == prev)
|
|
|
|
{
|
|
|
|
this->places_[PLACE_LAST_ALLOC].have_location = true;
|
|
|
|
this->places_[PLACE_LAST_ALLOC].location = elem;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
// Return the iterator being used for sections at the very end of the
|
|
|
|
// linker script.
|
|
|
|
|
|
|
|
Orphan_section_placement::Elements_iterator
|
|
|
|
Orphan_section_placement::last_place() const
|
|
|
|
{
|
|
|
|
gold_assert(this->places_[PLACE_LAST].have_location);
|
|
|
|
return this->places_[PLACE_LAST].location;
|
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// An element in a SECTIONS clause.
|
|
|
|
|
|
|
|
class Sections_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Sections_element()
|
|
|
|
{ }
|
|
|
|
|
|
|
|
virtual ~Sections_element()
|
|
|
|
{ }
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
// Return whether an output section is relro.
|
|
|
|
virtual bool
|
|
|
|
is_relro() const
|
|
|
|
{ return false; }
|
|
|
|
|
2008-08-13 09:37:46 +02:00
|
|
|
// Record that an output section is relro.
|
|
|
|
virtual void
|
|
|
|
set_is_relro()
|
|
|
|
{ }
|
|
|
|
|
2008-02-28 05:45:47 +01:00
|
|
|
// Create any required output sections. The only real
|
|
|
|
// implementation is in Output_section_definition.
|
|
|
|
virtual void
|
|
|
|
create_sections(Layout*)
|
|
|
|
{ }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Add any symbol being defined to the symbol table.
|
|
|
|
virtual void
|
|
|
|
add_symbols_to_table(Symbol_table*)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
// Finalize symbols and check assertions.
|
|
|
|
virtual void
|
2008-02-09 02:22:17 +01:00
|
|
|
finalize_symbols(Symbol_table*, const Layout*, uint64_t*)
|
2008-02-04 06:43:05 +01:00
|
|
|
{ }
|
|
|
|
|
|
|
|
// Return the output section name to use for an input file name and
|
|
|
|
// section name. This only real implementation is in
|
|
|
|
// Output_section_definition.
|
|
|
|
virtual const char*
|
2010-04-09 19:32:58 +02:00
|
|
|
output_section_name(const char*, const char*, Output_section***,
|
2016-12-20 01:37:48 +01:00
|
|
|
Script_sections::Section_type*, bool*, bool)
|
2008-02-04 06:43:05 +01:00
|
|
|
{ return NULL; }
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
// Initialize OSP with an output section.
|
|
|
|
virtual void
|
|
|
|
orphan_section_init(Orphan_section_placement*,
|
|
|
|
Script_sections::Elements_iterator)
|
|
|
|
{ }
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Set section addresses. This includes applying assignments if the
|
2010-12-14 20:03:30 +01:00
|
|
|
// expression is an absolute value.
|
2008-02-04 06:43:05 +01:00
|
|
|
virtual void
|
2010-04-23 06:47:33 +02:00
|
|
|
set_section_addresses(Symbol_table*, Layout*, uint64_t*, uint64_t*,
|
|
|
|
uint64_t*)
|
2008-02-04 06:43:05 +01:00
|
|
|
{ }
|
|
|
|
|
2008-02-04 07:45:50 +01:00
|
|
|
// Check a constraint (ONLY_IF_RO, etc.) on an output section. If
|
|
|
|
// this section is constrained, and the input sections do not match,
|
|
|
|
// return the constraint, and set *POSD.
|
|
|
|
virtual Section_constraint
|
|
|
|
check_constraint(Output_section_definition**)
|
|
|
|
{ return CONSTRAINT_NONE; }
|
|
|
|
|
|
|
|
// See if this is the alternate output section for a constrained
|
|
|
|
// output section. If it is, transfer the Output_section and return
|
|
|
|
// true. Otherwise return false.
|
|
|
|
virtual bool
|
|
|
|
alternate_constraint(Output_section_definition*, Section_constraint)
|
|
|
|
{ return false; }
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// Get the list of segments to use for an allocated section when
|
|
|
|
// using a PHDRS clause. If this is an allocated section, return
|
2008-04-10 03:02:46 +02:00
|
|
|
// the Output_section, and set *PHDRS_LIST (the first parameter) to
|
|
|
|
// the list of PHDRS to which it should be attached. If the PHDRS
|
|
|
|
// were not specified, don't change *PHDRS_LIST. When not returning
|
|
|
|
// NULL, set *ORPHAN (the second parameter) according to whether
|
|
|
|
// this is an orphan section--one that is not mentioned in the
|
|
|
|
// linker script.
|
2008-02-04 23:54:31 +01:00
|
|
|
virtual Output_section*
|
2008-04-10 03:02:46 +02:00
|
|
|
allocate_to_segment(String_list**, bool*)
|
2008-02-04 23:54:31 +01:00
|
|
|
{ return NULL; }
|
|
|
|
|
2008-02-29 01:04:06 +01:00
|
|
|
// Look for an output section by name and return the address, the
|
|
|
|
// load address, the alignment, and the size. This is used when an
|
|
|
|
// expression refers to an output section which was not actually
|
|
|
|
// created. This returns true if the section was found, false
|
|
|
|
// otherwise. The only real definition is for
|
|
|
|
// Output_section_definition.
|
|
|
|
virtual bool
|
|
|
|
get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
|
|
|
|
uint64_t*) const
|
|
|
|
{ return false; }
|
|
|
|
|
2008-08-13 09:37:46 +02:00
|
|
|
// Return the associated Output_section if there is one.
|
|
|
|
virtual Output_section*
|
|
|
|
get_output_section() const
|
|
|
|
{ return NULL; }
|
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
// Set the section's memory regions.
|
|
|
|
virtual void
|
|
|
|
set_memory_region(Memory_region*, bool)
|
|
|
|
{ gold_error(_("Attempt to set a memory region for a non-output section")); }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Print the element for debugging purposes.
|
2008-01-23 02:31:13 +01:00
|
|
|
virtual void
|
|
|
|
print(FILE* f) const = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
// An assignment in a SECTIONS clause outside of an output section.
|
|
|
|
|
|
|
|
class Sections_element_assignment : public Sections_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Sections_element_assignment(const char* name, size_t namelen,
|
|
|
|
Expression* val, bool provide, bool hidden)
|
2009-12-29 01:31:48 +01:00
|
|
|
: assignment_(name, namelen, false, val, provide, hidden)
|
2008-01-23 02:31:13 +01:00
|
|
|
{ }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Add the symbol to the symbol table.
|
|
|
|
void
|
|
|
|
add_symbols_to_table(Symbol_table* symtab)
|
|
|
|
{ this->assignment_.add_to_table(symtab); }
|
|
|
|
|
|
|
|
// Finalize the symbol.
|
|
|
|
void
|
|
|
|
finalize_symbols(Symbol_table* symtab, const Layout* layout,
|
2008-02-09 02:22:17 +01:00
|
|
|
uint64_t* dot_value)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2008-02-09 02:22:17 +01:00
|
|
|
this->assignment_.finalize_with_dot(symtab, layout, *dot_value, NULL);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Set the section address. There is no section here, but if the
|
|
|
|
// value is absolute, we set the symbol. This permits us to use
|
|
|
|
// absolute symbols when setting dot.
|
|
|
|
void
|
|
|
|
set_section_addresses(Symbol_table* symtab, Layout* layout,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t* dot_value, uint64_t*, uint64_t*)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2011-10-31 23:51:03 +01:00
|
|
|
this->assignment_.set_if_absolute(symtab, layout, true, *dot_value, NULL);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Print for debugging.
|
2008-01-23 02:31:13 +01:00
|
|
|
void
|
|
|
|
print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " ");
|
|
|
|
this->assignment_.print(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Symbol_assignment assignment_;
|
|
|
|
};
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// An assignment to the dot symbol in a SECTIONS clause outside of an
|
|
|
|
// output section.
|
|
|
|
|
|
|
|
class Sections_element_dot_assignment : public Sections_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Sections_element_dot_assignment(Expression* val)
|
|
|
|
: val_(val)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
// Finalize the symbol.
|
|
|
|
void
|
|
|
|
finalize_symbols(Symbol_table* symtab, const Layout* layout,
|
2008-02-09 02:22:17 +01:00
|
|
|
uint64_t* dot_value)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2008-02-09 02:22:17 +01:00
|
|
|
// We ignore the section of the result because outside of an
|
|
|
|
// output section definition the dot symbol is always considered
|
|
|
|
// to be absolute.
|
2008-02-28 05:45:47 +01:00
|
|
|
*dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value,
|
2011-10-31 23:51:03 +01:00
|
|
|
NULL, NULL, NULL, false);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Update the dot symbol while setting section addresses.
|
|
|
|
void
|
|
|
|
set_section_addresses(Symbol_table* symtab, Layout* layout,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t* dot_value, uint64_t* dot_alignment,
|
|
|
|
uint64_t* load_address)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2008-02-28 05:45:47 +01:00
|
|
|
*dot_value = this->val_->eval_with_dot(symtab, layout, false, *dot_value,
|
2011-10-31 23:51:03 +01:00
|
|
|
NULL, NULL, dot_alignment, false);
|
2008-02-14 03:34:22 +01:00
|
|
|
*load_address = *dot_value;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Print for debugging.
|
|
|
|
void
|
|
|
|
print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " . = ");
|
|
|
|
this->val_->print(f);
|
|
|
|
fprintf(f, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Expression* val_;
|
|
|
|
};
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// An assertion in a SECTIONS clause outside of an output section.
|
|
|
|
|
|
|
|
class Sections_element_assertion : public Sections_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Sections_element_assertion(Expression* check, const char* message,
|
|
|
|
size_t messagelen)
|
|
|
|
: assertion_(check, message, messagelen)
|
|
|
|
{ }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Check the assertion.
|
|
|
|
void
|
2008-02-09 02:22:17 +01:00
|
|
|
finalize_symbols(Symbol_table* symtab, const Layout* layout, uint64_t*)
|
2008-02-04 06:43:05 +01:00
|
|
|
{ this->assertion_.check(symtab, layout); }
|
|
|
|
|
|
|
|
// Print for debugging.
|
2008-01-23 02:31:13 +01:00
|
|
|
void
|
|
|
|
print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " ");
|
|
|
|
this->assertion_.print(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Script_assertion assertion_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// An element in an output section in a SECTIONS clause.
|
|
|
|
|
|
|
|
class Output_section_element
|
|
|
|
{
|
|
|
|
public:
|
2008-02-04 06:43:05 +01:00
|
|
|
// A list of input sections.
|
2010-05-19 09:09:36 +02:00
|
|
|
typedef std::list<Output_section::Input_section> Input_section_list;
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
Output_section_element()
|
|
|
|
{ }
|
|
|
|
|
|
|
|
virtual ~Output_section_element()
|
|
|
|
{ }
|
|
|
|
|
2008-02-28 05:45:47 +01:00
|
|
|
// Return whether this element requires an output section to exist.
|
|
|
|
virtual bool
|
|
|
|
needs_output_section() const
|
|
|
|
{ return false; }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Add any symbol being defined to the symbol table.
|
|
|
|
virtual void
|
|
|
|
add_symbols_to_table(Symbol_table*)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
// Finalize symbols and check assertions.
|
|
|
|
virtual void
|
2008-02-09 02:22:17 +01:00
|
|
|
finalize_symbols(Symbol_table*, const Layout*, uint64_t*, Output_section**)
|
2008-02-04 06:43:05 +01:00
|
|
|
{ }
|
|
|
|
|
|
|
|
// Return whether this element matches FILE_NAME and SECTION_NAME.
|
|
|
|
// The only real implementation is in Output_section_element_input.
|
|
|
|
virtual bool
|
2012-08-14 10:31:57 +02:00
|
|
|
match_name(const char*, const char*, bool *) const
|
2008-02-04 06:43:05 +01:00
|
|
|
{ return false; }
|
|
|
|
|
|
|
|
// Set section addresses. This includes applying assignments if the
|
2010-12-14 20:03:30 +01:00
|
|
|
// expression is an absolute value.
|
2008-02-04 06:43:05 +01:00
|
|
|
virtual void
|
|
|
|
set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t*, uint64_t*, Output_section**, std::string*,
|
2008-02-09 02:22:17 +01:00
|
|
|
Input_section_list*)
|
2008-02-04 06:43:05 +01:00
|
|
|
{ }
|
|
|
|
|
|
|
|
// Print the element for debugging purposes.
|
2008-01-23 02:31:13 +01:00
|
|
|
virtual void
|
|
|
|
print(FILE* f) const = 0;
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
protected:
|
|
|
|
// Return a fill string that is LENGTH bytes long, filling it with
|
|
|
|
// FILL.
|
|
|
|
std::string
|
|
|
|
get_fill_string(const std::string* fill, section_size_type length) const;
|
2008-01-23 02:31:13 +01:00
|
|
|
};
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
std::string
|
|
|
|
Output_section_element::get_fill_string(const std::string* fill,
|
|
|
|
section_size_type length) const
|
|
|
|
{
|
|
|
|
std::string this_fill;
|
|
|
|
this_fill.reserve(length);
|
|
|
|
while (this_fill.length() + fill->length() <= length)
|
|
|
|
this_fill += *fill;
|
|
|
|
if (this_fill.length() < length)
|
|
|
|
this_fill.append(*fill, 0, length - this_fill.length());
|
|
|
|
return this_fill;
|
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// A symbol assignment in an output section.
|
|
|
|
|
|
|
|
class Output_section_element_assignment : public Output_section_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Output_section_element_assignment(const char* name, size_t namelen,
|
|
|
|
Expression* val, bool provide,
|
|
|
|
bool hidden)
|
2009-12-29 01:31:48 +01:00
|
|
|
: assignment_(name, namelen, false, val, provide, hidden)
|
2008-01-23 02:31:13 +01:00
|
|
|
{ }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Add the symbol to the symbol table.
|
|
|
|
void
|
|
|
|
add_symbols_to_table(Symbol_table* symtab)
|
|
|
|
{ this->assignment_.add_to_table(symtab); }
|
|
|
|
|
|
|
|
// Finalize the symbol.
|
|
|
|
void
|
|
|
|
finalize_symbols(Symbol_table* symtab, const Layout* layout,
|
2008-02-09 02:22:17 +01:00
|
|
|
uint64_t* dot_value, Output_section** dot_section)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2008-02-09 02:22:17 +01:00
|
|
|
this->assignment_.finalize_with_dot(symtab, layout, *dot_value,
|
|
|
|
*dot_section);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Set the section address. There is no section here, but if the
|
|
|
|
// value is absolute, we set the symbol. This permits us to use
|
|
|
|
// absolute symbols when setting dot.
|
|
|
|
void
|
|
|
|
set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t, uint64_t* dot_value, uint64_t*,
|
2011-10-31 23:51:03 +01:00
|
|
|
Output_section** dot_section, std::string*,
|
|
|
|
Input_section_list*)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2011-10-31 23:51:03 +01:00
|
|
|
this->assignment_.set_if_absolute(symtab, layout, true, *dot_value,
|
|
|
|
*dot_section);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Print for debugging.
|
2008-01-23 02:31:13 +01:00
|
|
|
void
|
|
|
|
print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " ");
|
|
|
|
this->assignment_.print(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Symbol_assignment assignment_;
|
|
|
|
};
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// An assignment to the dot symbol in an output section.
|
|
|
|
|
|
|
|
class Output_section_element_dot_assignment : public Output_section_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Output_section_element_dot_assignment(Expression* val)
|
|
|
|
: val_(val)
|
|
|
|
{ }
|
|
|
|
|
2011-10-19 17:51:00 +02:00
|
|
|
// An assignment to dot within an output section is enough to force
|
|
|
|
// the output section to exist.
|
|
|
|
bool
|
|
|
|
needs_output_section() const
|
|
|
|
{ return true; }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Finalize the symbol.
|
|
|
|
void
|
|
|
|
finalize_symbols(Symbol_table* symtab, const Layout* layout,
|
2008-02-09 02:22:17 +01:00
|
|
|
uint64_t* dot_value, Output_section** dot_section)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2008-02-28 05:45:47 +01:00
|
|
|
*dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value,
|
2011-10-31 23:51:03 +01:00
|
|
|
*dot_section, dot_section, NULL,
|
|
|
|
true);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Update the dot symbol while setting section addresses.
|
|
|
|
void
|
|
|
|
set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t, uint64_t* dot_value, uint64_t*,
|
2011-10-31 23:51:03 +01:00
|
|
|
Output_section** dot_section, std::string*,
|
|
|
|
Input_section_list*);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Print for debugging.
|
|
|
|
void
|
|
|
|
print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " . = ");
|
|
|
|
this->val_->print(f);
|
|
|
|
fprintf(f, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Expression* val_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Update the dot symbol while setting section addresses.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_element_dot_assignment::set_section_addresses(
|
|
|
|
Symbol_table* symtab,
|
|
|
|
Layout* layout,
|
|
|
|
Output_section* output_section,
|
|
|
|
uint64_t,
|
|
|
|
uint64_t* dot_value,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t* dot_alignment,
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section** dot_section,
|
2008-02-04 06:43:05 +01:00
|
|
|
std::string* fill,
|
|
|
|
Input_section_list*)
|
|
|
|
{
|
2008-02-28 05:45:47 +01:00
|
|
|
uint64_t next_dot = this->val_->eval_with_dot(symtab, layout, false,
|
|
|
|
*dot_value, *dot_section,
|
2011-10-31 23:51:03 +01:00
|
|
|
dot_section, dot_alignment,
|
|
|
|
true);
|
2008-02-04 06:43:05 +01:00
|
|
|
if (next_dot < *dot_value)
|
|
|
|
gold_error(_("dot may not move backward"));
|
|
|
|
if (next_dot > *dot_value && output_section != NULL)
|
|
|
|
{
|
|
|
|
section_size_type length = convert_to_section_size_type(next_dot
|
|
|
|
- *dot_value);
|
|
|
|
Output_section_data* posd;
|
|
|
|
if (fill->empty())
|
2008-05-21 23:37:44 +02:00
|
|
|
posd = new Output_data_zero_fill(length, 0);
|
2008-02-04 06:43:05 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
std::string this_fill = this->get_fill_string(fill, length);
|
|
|
|
posd = new Output_data_const(this_fill, 0);
|
|
|
|
}
|
|
|
|
output_section->add_output_section_data(posd);
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
layout->new_output_section_data_from_script(posd);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
*dot_value = next_dot;
|
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// An assertion in an output section.
|
|
|
|
|
|
|
|
class Output_section_element_assertion : public Output_section_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Output_section_element_assertion(Expression* check, const char* message,
|
|
|
|
size_t messagelen)
|
|
|
|
: assertion_(check, message, messagelen)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
void
|
|
|
|
print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " ");
|
|
|
|
this->assertion_.print(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Script_assertion assertion_;
|
|
|
|
};
|
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
// We use a special instance of Output_section_data to handle BYTE,
|
|
|
|
// SHORT, etc. This permits forward references to symbols in the
|
|
|
|
// expressions.
|
2008-01-23 02:31:13 +01:00
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
class Output_data_expression : public Output_section_data
|
2008-01-23 02:31:13 +01:00
|
|
|
{
|
|
|
|
public:
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_data_expression(int size, bool is_signed, Expression* val,
|
|
|
|
const Symbol_table* symtab, const Layout* layout,
|
|
|
|
uint64_t dot_value, Output_section* dot_section)
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
: Output_section_data(size, 0, true),
|
2008-02-09 02:22:17 +01:00
|
|
|
is_signed_(is_signed), val_(val), symtab_(symtab),
|
|
|
|
layout_(layout), dot_value_(dot_value), dot_section_(dot_section)
|
2008-01-23 02:31:13 +01:00
|
|
|
{ }
|
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
protected:
|
|
|
|
// Write the data to the output file.
|
2008-02-04 06:43:05 +01:00
|
|
|
void
|
2008-02-09 02:22:17 +01:00
|
|
|
do_write(Output_file*);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
// Write the data to a buffer.
|
2008-01-23 02:31:13 +01:00
|
|
|
void
|
2008-02-09 02:22:17 +01:00
|
|
|
do_write_to_buffer(unsigned char*);
|
2008-01-23 02:31:13 +01:00
|
|
|
|
2008-05-21 23:37:44 +02:00
|
|
|
// Write to a map file.
|
|
|
|
void
|
|
|
|
do_print_to_mapfile(Mapfile* mapfile) const
|
|
|
|
{ mapfile->print_output_data(this, _("** expression")); }
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
private:
|
2008-02-04 06:43:05 +01:00
|
|
|
template<bool big_endian>
|
2008-02-09 02:22:17 +01:00
|
|
|
void
|
|
|
|
endian_write_to_buffer(uint64_t, unsigned char*);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
bool is_signed_;
|
|
|
|
Expression* val_;
|
2008-02-09 02:22:17 +01:00
|
|
|
const Symbol_table* symtab_;
|
|
|
|
const Layout* layout_;
|
|
|
|
uint64_t dot_value_;
|
|
|
|
Output_section* dot_section_;
|
2008-01-23 02:31:13 +01:00
|
|
|
};
|
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
// Write the data element to the output file.
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
void
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_data_expression::do_write(Output_file* of)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2008-02-09 02:22:17 +01:00
|
|
|
unsigned char* view = of->get_output_view(this->offset(), this->data_size());
|
|
|
|
this->write_to_buffer(view);
|
|
|
|
of->write_output_view(this->offset(), this->data_size(), view);
|
|
|
|
}
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
// Write the data element to a buffer.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_data_expression::do_write_to_buffer(unsigned char* buf)
|
|
|
|
{
|
|
|
|
uint64_t val = this->val_->eval_with_dot(this->symtab_, this->layout_,
|
2008-02-28 05:45:47 +01:00
|
|
|
true, this->dot_value_,
|
2011-10-31 23:51:03 +01:00
|
|
|
this->dot_section_, NULL, NULL,
|
|
|
|
false);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().is_big_endian())
|
2008-02-09 02:22:17 +01:00
|
|
|
this->endian_write_to_buffer<true>(val, buf);
|
2008-02-04 06:43:05 +01:00
|
|
|
else
|
2008-02-09 02:22:17 +01:00
|
|
|
this->endian_write_to_buffer<false>(val, buf);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
template<bool big_endian>
|
2008-02-09 02:22:17 +01:00
|
|
|
void
|
|
|
|
Output_data_expression::endian_write_to_buffer(uint64_t val,
|
|
|
|
unsigned char* buf)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2008-02-09 02:22:17 +01:00
|
|
|
switch (this->data_size())
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
elfcpp::Swap_unaligned<8, big_endian>::writeval(buf, val);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
elfcpp::Swap_unaligned<16, big_endian>::writeval(buf, val);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
elfcpp::Swap_unaligned<32, big_endian>::writeval(buf, val);
|
|
|
|
break;
|
|
|
|
case 8:
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().get_size() == 32)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
val &= 0xffffffff;
|
|
|
|
if (this->is_signed_ && (val & 0x80000000) != 0)
|
|
|
|
val |= 0xffffffff00000000LL;
|
|
|
|
}
|
|
|
|
elfcpp::Swap_unaligned<64, big_endian>::writeval(buf, val);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
2008-02-09 02:22:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// A data item in an output section.
|
|
|
|
|
|
|
|
class Output_section_element_data : public Output_section_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Output_section_element_data(int size, bool is_signed, Expression* val)
|
|
|
|
: size_(size), is_signed_(is_signed), val_(val)
|
|
|
|
{ }
|
|
|
|
|
2008-02-28 05:45:47 +01:00
|
|
|
// If there is a data item, then we must create an output section.
|
|
|
|
bool
|
|
|
|
needs_output_section() const
|
|
|
|
{ return true; }
|
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
// Finalize symbols--we just need to update dot.
|
|
|
|
void
|
|
|
|
finalize_symbols(Symbol_table*, const Layout*, uint64_t* dot_value,
|
|
|
|
Output_section**)
|
|
|
|
{ *dot_value += this->size_; }
|
|
|
|
|
|
|
|
// Store the value in the section.
|
|
|
|
void
|
|
|
|
set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t* dot_value, uint64_t*, Output_section**,
|
|
|
|
std::string*, Input_section_list*);
|
2008-02-09 02:22:17 +01:00
|
|
|
|
|
|
|
// Print for debugging.
|
|
|
|
void
|
|
|
|
print(FILE*) const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
// The size in bytes.
|
|
|
|
int size_;
|
|
|
|
// Whether the value is signed.
|
|
|
|
bool is_signed_;
|
|
|
|
// The value.
|
|
|
|
Expression* val_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Store the value in the section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_element_data::set_section_addresses(
|
|
|
|
Symbol_table* symtab,
|
|
|
|
Layout* layout,
|
|
|
|
Output_section* os,
|
|
|
|
uint64_t,
|
|
|
|
uint64_t* dot_value,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t*,
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section** dot_section,
|
|
|
|
std::string*,
|
|
|
|
Input_section_list*)
|
|
|
|
{
|
|
|
|
gold_assert(os != NULL);
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
Output_data_expression* expression =
|
|
|
|
new Output_data_expression(this->size_, this->is_signed_, this->val_,
|
|
|
|
symtab, layout, *dot_value, *dot_section);
|
|
|
|
os->add_output_section_data(expression);
|
|
|
|
layout->new_output_section_data_from_script(expression);
|
2008-02-09 02:22:17 +01:00
|
|
|
*dot_value += this->size_;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// Print for debugging.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_element_data::print(FILE* f) const
|
|
|
|
{
|
|
|
|
const char* s;
|
|
|
|
switch (this->size_)
|
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
s = "BYTE";
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
s = "SHORT";
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
s = "LONG";
|
|
|
|
break;
|
|
|
|
case 8:
|
|
|
|
if (this->is_signed_)
|
|
|
|
s = "SQUAD";
|
|
|
|
else
|
|
|
|
s = "QUAD";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
fprintf(f, " %s(", s);
|
|
|
|
this->val_->print(f);
|
|
|
|
fprintf(f, ")\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
// A fill value setting in an output section.
|
|
|
|
|
|
|
|
class Output_section_element_fill : public Output_section_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Output_section_element_fill(Expression* val)
|
|
|
|
: val_(val)
|
|
|
|
{ }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Update the fill value while setting section addresses.
|
|
|
|
void
|
|
|
|
set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t, uint64_t* dot_value, uint64_t*,
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section** dot_section,
|
|
|
|
std::string* fill, Input_section_list*)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section* fill_section;
|
2008-02-28 05:45:47 +01:00
|
|
|
uint64_t fill_val = this->val_->eval_with_dot(symtab, layout, false,
|
2008-02-09 02:22:17 +01:00
|
|
|
*dot_value, *dot_section,
|
2011-10-31 23:51:03 +01:00
|
|
|
&fill_section, NULL, false);
|
2008-02-09 02:22:17 +01:00
|
|
|
if (fill_section != NULL)
|
|
|
|
gold_warning(_("fill value is not absolute"));
|
2008-02-04 06:43:05 +01:00
|
|
|
// FIXME: The GNU linker supports fill values of arbitrary length.
|
|
|
|
unsigned char fill_buff[4];
|
|
|
|
elfcpp::Swap_unaligned<32, true>::writeval(fill_buff, fill_val);
|
|
|
|
fill->assign(reinterpret_cast<char*>(fill_buff), 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Print for debugging.
|
2008-01-23 02:31:13 +01:00
|
|
|
void
|
|
|
|
print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " FILL(");
|
|
|
|
this->val_->print(f);
|
|
|
|
fprintf(f, ")\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
// The new fill value.
|
|
|
|
Expression* val_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// An input section specification in an output section
|
|
|
|
|
|
|
|
class Output_section_element_input : public Output_section_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Output_section_element_input(const Input_section_spec* spec, bool keep);
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Finalize symbols--just update the value of the dot symbol.
|
|
|
|
void
|
2008-02-09 02:22:17 +01:00
|
|
|
finalize_symbols(Symbol_table*, const Layout*, uint64_t* dot_value,
|
|
|
|
Output_section** dot_section)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
*dot_value = this->final_dot_value_;
|
2008-02-09 02:22:17 +01:00
|
|
|
*dot_section = this->final_dot_section_;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2012-08-14 10:31:57 +02:00
|
|
|
// See whether we match FILE_NAME and SECTION_NAME as an input section.
|
|
|
|
// If we do then also indicate whether the section should be KEPT.
|
2008-02-04 06:43:05 +01:00
|
|
|
bool
|
2012-08-14 10:31:57 +02:00
|
|
|
match_name(const char* file_name, const char* section_name, bool* keep) const;
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Set the section address.
|
|
|
|
void
|
|
|
|
set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t subalign, uint64_t* dot_value, uint64_t*,
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section**, std::string* fill,
|
|
|
|
Input_section_list*);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Print for debugging.
|
2008-01-23 02:31:13 +01:00
|
|
|
void
|
|
|
|
print(FILE* f) const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
// An input section pattern.
|
|
|
|
struct Input_section_pattern
|
|
|
|
{
|
|
|
|
std::string pattern;
|
2008-02-04 06:43:05 +01:00
|
|
|
bool pattern_is_wildcard;
|
2008-01-23 02:31:13 +01:00
|
|
|
Sort_wildcard sort;
|
|
|
|
|
|
|
|
Input_section_pattern(const char* patterna, size_t patternlena,
|
|
|
|
Sort_wildcard sorta)
|
2008-02-04 06:43:05 +01:00
|
|
|
: pattern(patterna, patternlena),
|
2010-06-02 01:37:58 +02:00
|
|
|
pattern_is_wildcard(is_wildcard_string(this->pattern.c_str())),
|
2008-02-04 06:43:05 +01:00
|
|
|
sort(sorta)
|
2008-01-23 02:31:13 +01:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef std::vector<Input_section_pattern> Input_section_patterns;
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Filename_exclusions is a pair of filename pattern and a bool
|
|
|
|
// indicating whether the filename is a wildcard.
|
|
|
|
typedef std::vector<std::pair<std::string, bool> > Filename_exclusions;
|
|
|
|
|
|
|
|
// Return whether STRING matches PATTERN, where IS_WILDCARD_PATTERN
|
|
|
|
// indicates whether this is a wildcard pattern.
|
|
|
|
static inline bool
|
|
|
|
match(const char* string, const char* pattern, bool is_wildcard_pattern)
|
|
|
|
{
|
|
|
|
return (is_wildcard_pattern
|
|
|
|
? fnmatch(pattern, string, 0) == 0
|
|
|
|
: strcmp(string, pattern) == 0);
|
|
|
|
}
|
2008-01-23 02:31:13 +01:00
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// See if we match a file name.
|
|
|
|
bool
|
|
|
|
match_file_name(const char* file_name) const;
|
|
|
|
|
|
|
|
// The file name pattern. If this is the empty string, we match all
|
|
|
|
// files.
|
2008-01-23 02:31:13 +01:00
|
|
|
std::string filename_pattern_;
|
2008-02-04 06:43:05 +01:00
|
|
|
// Whether the file name pattern is a wildcard.
|
|
|
|
bool filename_is_wildcard_;
|
2008-01-23 02:31:13 +01:00
|
|
|
// How the file names should be sorted. This may only be
|
|
|
|
// SORT_WILDCARD_NONE or SORT_WILDCARD_BY_NAME.
|
|
|
|
Sort_wildcard filename_sort_;
|
|
|
|
// The list of file names to exclude.
|
|
|
|
Filename_exclusions filename_exclusions_;
|
|
|
|
// The list of input section patterns.
|
|
|
|
Input_section_patterns input_section_patterns_;
|
|
|
|
// Whether to keep this section when garbage collecting.
|
|
|
|
bool keep_;
|
2008-02-04 06:43:05 +01:00
|
|
|
// The value of dot after including all matching sections.
|
|
|
|
uint64_t final_dot_value_;
|
2008-02-09 02:22:17 +01:00
|
|
|
// The section where dot is defined after including all matching
|
|
|
|
// sections.
|
|
|
|
Output_section* final_dot_section_;
|
2008-01-23 02:31:13 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
// Construct Output_section_element_input. The parser records strings
|
|
|
|
// as pointers into a copy of the script file, which will go away when
|
|
|
|
// parsing is complete. We make sure they are in std::string objects.
|
|
|
|
|
|
|
|
Output_section_element_input::Output_section_element_input(
|
|
|
|
const Input_section_spec* spec,
|
|
|
|
bool keep)
|
2008-02-04 06:43:05 +01:00
|
|
|
: filename_pattern_(),
|
|
|
|
filename_is_wildcard_(false),
|
2008-01-23 02:31:13 +01:00
|
|
|
filename_sort_(spec->file.sort),
|
|
|
|
filename_exclusions_(),
|
|
|
|
input_section_patterns_(),
|
2008-02-04 06:43:05 +01:00
|
|
|
keep_(keep),
|
2008-02-09 02:22:17 +01:00
|
|
|
final_dot_value_(0),
|
|
|
|
final_dot_section_(NULL)
|
2008-01-23 02:31:13 +01:00
|
|
|
{
|
2008-02-04 06:43:05 +01:00
|
|
|
// The filename pattern "*" is common, and matches all files. Turn
|
|
|
|
// it into the empty string.
|
|
|
|
if (spec->file.name.length != 1 || spec->file.name.value[0] != '*')
|
|
|
|
this->filename_pattern_.assign(spec->file.name.value,
|
|
|
|
spec->file.name.length);
|
2010-06-02 01:37:58 +02:00
|
|
|
this->filename_is_wildcard_ = is_wildcard_string(this->filename_pattern_.c_str());
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
if (spec->input_sections.exclude != NULL)
|
|
|
|
{
|
|
|
|
for (String_list::const_iterator p =
|
|
|
|
spec->input_sections.exclude->begin();
|
|
|
|
p != spec->input_sections.exclude->end();
|
|
|
|
++p)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2010-06-02 01:37:58 +02:00
|
|
|
bool is_wildcard = is_wildcard_string((*p).c_str());
|
2008-02-04 06:43:05 +01:00
|
|
|
this->filename_exclusions_.push_back(std::make_pair(*p,
|
|
|
|
is_wildcard));
|
|
|
|
}
|
2008-01-23 02:31:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (spec->input_sections.sections != NULL)
|
|
|
|
{
|
|
|
|
Input_section_patterns& isp(this->input_section_patterns_);
|
|
|
|
for (String_sort_list::const_iterator p =
|
|
|
|
spec->input_sections.sections->begin();
|
|
|
|
p != spec->input_sections.sections->end();
|
|
|
|
++p)
|
|
|
|
isp.push_back(Input_section_pattern(p->name.value, p->name.length,
|
|
|
|
p->sort));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// See whether we match FILE_NAME.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Output_section_element_input::match_file_name(const char* file_name) const
|
|
|
|
{
|
|
|
|
if (!this->filename_pattern_.empty())
|
|
|
|
{
|
|
|
|
// If we were called with no filename, we refuse to match a
|
|
|
|
// pattern which requires a file name.
|
|
|
|
if (file_name == NULL)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!match(file_name, this->filename_pattern_.c_str(),
|
|
|
|
this->filename_is_wildcard_))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (file_name != NULL)
|
|
|
|
{
|
|
|
|
// Now we have to see whether FILE_NAME matches one of the
|
|
|
|
// exclusion patterns, if any.
|
|
|
|
for (Filename_exclusions::const_iterator p =
|
|
|
|
this->filename_exclusions_.begin();
|
|
|
|
p != this->filename_exclusions_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if (match(file_name, p->first.c_str(), p->second))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-08-14 10:31:57 +02:00
|
|
|
// See whether we match FILE_NAME and SECTION_NAME. If we do then
|
|
|
|
// KEEP indicates whether the section should survive garbage collection.
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
bool
|
|
|
|
Output_section_element_input::match_name(const char* file_name,
|
2012-08-14 10:31:57 +02:00
|
|
|
const char* section_name,
|
|
|
|
bool *keep) const
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
if (!this->match_file_name(file_name))
|
|
|
|
return false;
|
|
|
|
|
2012-08-14 10:31:57 +02:00
|
|
|
*keep = this->keep_;
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// If there are no section name patterns, then we match.
|
|
|
|
if (this->input_section_patterns_.empty())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// See whether we match the section name patterns.
|
|
|
|
for (Input_section_patterns::const_iterator p =
|
|
|
|
this->input_section_patterns_.begin();
|
|
|
|
p != this->input_section_patterns_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if (match(section_name, p->pattern.c_str(), p->pattern_is_wildcard))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We didn't match any section names, so we didn't match.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Information we use to sort the input sections.
|
|
|
|
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
class Input_section_info
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
public:
|
2010-05-19 09:09:36 +02:00
|
|
|
Input_section_info(const Output_section::Input_section& input_section)
|
2009-12-14 20:53:05 +01:00
|
|
|
: input_section_(input_section), section_name_(),
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
size_(0), addralign_(1)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
// Return the simple input section.
|
2010-05-19 09:09:36 +02:00
|
|
|
const Output_section::Input_section&
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
input_section() const
|
|
|
|
{ return this->input_section_; }
|
|
|
|
|
|
|
|
// Return the object.
|
|
|
|
Relobj*
|
|
|
|
relobj() const
|
|
|
|
{ return this->input_section_.relobj(); }
|
|
|
|
|
|
|
|
// Return the section index.
|
|
|
|
unsigned int
|
|
|
|
shndx()
|
|
|
|
{ return this->input_section_.shndx(); }
|
|
|
|
|
|
|
|
// Return the section name.
|
|
|
|
const std::string&
|
|
|
|
section_name() const
|
|
|
|
{ return this->section_name_; }
|
|
|
|
|
|
|
|
// Set the section name.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_section_name(const std::string name)
|
2015-06-11 19:17:04 +02:00
|
|
|
{
|
|
|
|
if (is_compressed_debug_section(name.c_str()))
|
|
|
|
this->section_name_ = corresponding_uncompressed_section_name(name);
|
|
|
|
else
|
|
|
|
this->section_name_ = name;
|
|
|
|
}
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
|
|
|
|
// Return the section size.
|
|
|
|
uint64_t
|
|
|
|
size() const
|
|
|
|
{ return this->size_; }
|
|
|
|
|
|
|
|
// Set the section size.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_size(uint64_t size)
|
|
|
|
{ this->size_ = size; }
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
|
|
|
|
// Return the address alignment.
|
|
|
|
uint64_t
|
|
|
|
addralign() const
|
|
|
|
{ return this->addralign_; }
|
|
|
|
|
|
|
|
// Set the address alignment.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_addralign(uint64_t addralign)
|
|
|
|
{ this->addralign_ = addralign; }
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
|
|
|
|
private:
|
|
|
|
// Input section, can be a relaxed section.
|
2010-05-19 09:09:36 +02:00
|
|
|
Output_section::Input_section input_section_;
|
2016-08-12 18:55:25 +02:00
|
|
|
// Name of the section.
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
std::string section_name_;
|
|
|
|
// Section size.
|
|
|
|
uint64_t size_;
|
|
|
|
// Address alignment.
|
|
|
|
uint64_t addralign_;
|
2008-02-04 06:43:05 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
// A class to sort the input sections.
|
|
|
|
|
|
|
|
class Input_section_sorter
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Input_section_sorter(Sort_wildcard filename_sort, Sort_wildcard section_sort)
|
|
|
|
: filename_sort_(filename_sort), section_sort_(section_sort)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
bool
|
|
|
|
operator()(const Input_section_info&, const Input_section_info&) const;
|
|
|
|
|
|
|
|
private:
|
2016-06-28 22:56:05 +02:00
|
|
|
static unsigned long
|
|
|
|
get_init_priority(const char*);
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
Sort_wildcard filename_sort_;
|
|
|
|
Sort_wildcard section_sort_;
|
|
|
|
};
|
|
|
|
|
2016-06-28 22:56:05 +02:00
|
|
|
// Return a relative priority of the section with the specified NAME
|
|
|
|
// (a lower value meand a higher priority), or 0 if it should be compared
|
|
|
|
// with others as strings.
|
|
|
|
// The implementation of this function is copied from ld/ldlang.c.
|
|
|
|
|
|
|
|
unsigned long
|
|
|
|
Input_section_sorter::get_init_priority(const char* name)
|
|
|
|
{
|
|
|
|
char* end;
|
|
|
|
unsigned long init_priority;
|
|
|
|
|
|
|
|
// GCC uses the following section names for the init_priority
|
|
|
|
// attribute with numerical values 101 and 65535 inclusive. A
|
|
|
|
// lower value means a higher priority.
|
2016-08-12 18:55:25 +02:00
|
|
|
//
|
2016-06-28 22:56:05 +02:00
|
|
|
// 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
|
|
|
|
// decimal numerical value of the init_priority attribute.
|
|
|
|
// The order of execution in .init_array is forward and
|
|
|
|
// .fini_array is backward.
|
|
|
|
// 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the
|
|
|
|
// decimal numerical value of the init_priority attribute.
|
|
|
|
// The order of execution in .ctors is backward and .dtors
|
|
|
|
// is forward.
|
|
|
|
|
|
|
|
if (strncmp(name, ".init_array.", 12) == 0
|
|
|
|
|| strncmp(name, ".fini_array.", 12) == 0)
|
|
|
|
{
|
|
|
|
init_priority = strtoul(name + 12, &end, 10);
|
|
|
|
return *end ? 0 : init_priority;
|
|
|
|
}
|
|
|
|
else if (strncmp(name, ".ctors.", 7) == 0
|
|
|
|
|| strncmp(name, ".dtors.", 7) == 0)
|
|
|
|
{
|
|
|
|
init_priority = strtoul(name + 7, &end, 10);
|
|
|
|
return *end ? 0 : 65535 - init_priority;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
bool
|
|
|
|
Input_section_sorter::operator()(const Input_section_info& isi1,
|
|
|
|
const Input_section_info& isi2) const
|
|
|
|
{
|
2016-06-28 22:56:05 +02:00
|
|
|
if (this->section_sort_ == SORT_WILDCARD_BY_INIT_PRIORITY)
|
|
|
|
{
|
|
|
|
unsigned long ip1 = get_init_priority(isi1.section_name().c_str());
|
|
|
|
unsigned long ip2 = get_init_priority(isi2.section_name().c_str());
|
|
|
|
if (ip1 != 0 && ip2 != 0 && ip1 != ip2)
|
|
|
|
return ip1 < ip2;
|
|
|
|
}
|
2008-02-04 06:43:05 +01:00
|
|
|
if (this->section_sort_ == SORT_WILDCARD_BY_NAME
|
|
|
|
|| this->section_sort_ == SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
|
|
|
|
|| (this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
|
2016-06-28 22:56:05 +02:00
|
|
|
&& isi1.addralign() == isi2.addralign())
|
|
|
|
|| this->section_sort_ == SORT_WILDCARD_BY_INIT_PRIORITY)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
if (isi1.section_name() != isi2.section_name())
|
|
|
|
return isi1.section_name() < isi2.section_name();
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
if (this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT
|
|
|
|
|| this->section_sort_ == SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
|
|
|
|
|| this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT_BY_NAME)
|
|
|
|
{
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
if (isi1.addralign() != isi2.addralign())
|
|
|
|
return isi1.addralign() < isi2.addralign();
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
if (this->filename_sort_ == SORT_WILDCARD_BY_NAME)
|
|
|
|
{
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
if (isi1.relobj()->name() != isi2.relobj()->name())
|
|
|
|
return (isi1.relobj()->name() < isi2.relobj()->name());
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise we leave them in the same order.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the section address. Look in INPUT_SECTIONS for sections which
|
|
|
|
// match this spec, sort them as specified, and add them to the output
|
|
|
|
// section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_element_input::set_section_addresses(
|
|
|
|
Symbol_table*,
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
Layout* layout,
|
2008-02-04 06:43:05 +01:00
|
|
|
Output_section* output_section,
|
|
|
|
uint64_t subalign,
|
|
|
|
uint64_t* dot_value,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t*,
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section** dot_section,
|
2008-02-04 06:43:05 +01:00
|
|
|
std::string* fill,
|
|
|
|
Input_section_list* input_sections)
|
|
|
|
{
|
|
|
|
// We build a list of sections which match each
|
|
|
|
// Input_section_pattern.
|
|
|
|
|
Fix gold to group sections correctly via linker script.
In PR 15370, it is noted that gold does not distinguish between
"*(.foo .bar)" and "*(.foo) *(.bar)" in linker scripts. In both
cases, gold groups all .foo sections together, followed by all
.bar sections, whereas in the first case, it should collect all
.foo and .bar sections in the order seen.
If you add sort specs, the Gnu linker has some bizarre corner
cases that I do not try to replicate. In particular,
"*(SORT_BY_NAME(.foo) SORT_BY_NAME(.bar))" does the same thing
as "*(.foo) *(.bar)". But if you apply a sort spec
to just one of several patterns, say, "*(SORT_BY_NAME(.foo) .bar)",
the Gnu linker will collect any .bar section it sees before the
first .foo, then all .foo sections, then all remaining .bar
sections. With this patch, if any of the input patterns have a
sort spec, gold will group them all as it did before; e.g.,
all .foo sections followed by all .bar sections.
2015-06-03 Cary Coutant <ccoutant@gmail.com>
gold/
PR gold/15370
* script-sections.cc
(Output_section_element_input::set_section_addresses): When there
are several patterns with no sort spec, put all sections in the same
bin.
* testsuite/Makefile.am (script_test_12): New testcase.
(script_test_12i): New testcase.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_12.t: New test linker script.
* testsuite/script_test_12i.t: New test linker script.
* testsuite/script_test_12a.c: New test source file.
* testsuite/script_test_12b.c: New test source file.
2015-06-04 04:11:42 +02:00
|
|
|
// If none of the patterns specify a sort option, we throw all
|
|
|
|
// matching input sections into a single bin, in the order we
|
|
|
|
// find them. Otherwise, we put matching input sections into
|
|
|
|
// a separate bin for each pattern, and sort each one as
|
|
|
|
// specified. Thus, an input section spec like this:
|
|
|
|
// *(.foo .bar)
|
|
|
|
// will group all .foo and .bar sections in the order seen,
|
|
|
|
// whereas this:
|
|
|
|
// *(.foo) *(.bar)
|
|
|
|
// will group all .foo sections followed by all .bar sections.
|
|
|
|
// This matches Gnu ld behavior.
|
|
|
|
|
|
|
|
// Things get really weird, though, when you add a sort spec
|
|
|
|
// on some, but not all, of the patterns, like this:
|
|
|
|
// *(SORT_BY_NAME(.foo) .bar)
|
|
|
|
// We do not attempt to match Gnu ld behavior in this case.
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
typedef std::vector<std::vector<Input_section_info> > Matching_sections;
|
|
|
|
size_t input_pattern_count = this->input_section_patterns_.size();
|
2016-06-23 18:45:25 +02:00
|
|
|
size_t bin_count = 1;
|
Fix gold to group sections correctly via linker script.
In PR 15370, it is noted that gold does not distinguish between
"*(.foo .bar)" and "*(.foo) *(.bar)" in linker scripts. In both
cases, gold groups all .foo sections together, followed by all
.bar sections, whereas in the first case, it should collect all
.foo and .bar sections in the order seen.
If you add sort specs, the Gnu linker has some bizarre corner
cases that I do not try to replicate. In particular,
"*(SORT_BY_NAME(.foo) SORT_BY_NAME(.bar))" does the same thing
as "*(.foo) *(.bar)". But if you apply a sort spec
to just one of several patterns, say, "*(SORT_BY_NAME(.foo) .bar)",
the Gnu linker will collect any .bar section it sees before the
first .foo, then all .foo sections, then all remaining .bar
sections. With this patch, if any of the input patterns have a
sort spec, gold will group them all as it did before; e.g.,
all .foo sections followed by all .bar sections.
2015-06-03 Cary Coutant <ccoutant@gmail.com>
gold/
PR gold/15370
* script-sections.cc
(Output_section_element_input::set_section_addresses): When there
are several patterns with no sort spec, put all sections in the same
bin.
* testsuite/Makefile.am (script_test_12): New testcase.
(script_test_12i): New testcase.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_12.t: New test linker script.
* testsuite/script_test_12i.t: New test linker script.
* testsuite/script_test_12a.c: New test source file.
* testsuite/script_test_12b.c: New test source file.
2015-06-04 04:11:42 +02:00
|
|
|
bool any_patterns_with_sort = false;
|
|
|
|
for (size_t i = 0; i < input_pattern_count; ++i)
|
|
|
|
{
|
|
|
|
const Input_section_pattern& isp(this->input_section_patterns_[i]);
|
|
|
|
if (isp.sort != SORT_WILDCARD_NONE)
|
|
|
|
any_patterns_with_sort = true;
|
|
|
|
}
|
2016-06-23 18:45:25 +02:00
|
|
|
if (any_patterns_with_sort)
|
|
|
|
bin_count = input_pattern_count;
|
|
|
|
Matching_sections matching_sections(bin_count);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Look through the list of sections for this output section. Add
|
|
|
|
// each one which matches to one of the elements of
|
|
|
|
// MATCHING_SECTIONS.
|
|
|
|
|
|
|
|
Input_section_list::iterator p = input_sections->begin();
|
|
|
|
while (p != input_sections->end())
|
|
|
|
{
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
Relobj* relobj = p->relobj();
|
2016-08-12 18:55:25 +02:00
|
|
|
unsigned int shndx = p->shndx();
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
Input_section_info isi(*p);
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Calling section_name and section_addralign is not very
|
|
|
|
// efficient.
|
|
|
|
|
|
|
|
// Lock the object so that we can get information about the
|
|
|
|
// section. This is OK since we know we are single-threaded
|
|
|
|
// here.
|
|
|
|
{
|
|
|
|
const Task* task = reinterpret_cast<const Task*>(-1);
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
Task_lock_obj<Object> tl(task, relobj);
|
|
|
|
|
|
|
|
isi.set_section_name(relobj->section_name(shndx));
|
|
|
|
if (p->is_relaxed_input_section())
|
2009-10-09 Doug Kwan <dougkwan@google.com>
* layout.cc (Layout::make_output_section): Call target hook to make
ordinary output section.
(Layout::finalize): Adjust parameter list of call the
Target::may_relax().
* layout.h (class Layout::section_list): New method.
* merge.h (Output_merge_base::entsize): Change visibility to public.
(Output_merge_base::is_string, Output_merge_base::do_is_string):
New methods.
(Output_merge_string::do_is_string): New method.
* object.cc (Sized_relobj::do_setup): renamed from
Sized_relobj::set_up.
* object.h (Sized_relobj::adjust_shndx,
Sized_relobj::initializ_input_to_output_maps,
Sized_relobj::free_input_to_output_maps): Change visibilities to
protected.
(Sized_relobj::setup): Virtualize.
(Sized_relobj::do_setup): New method declaration.
(Sized_relobj::invalidate_section_offset,
Sized_relobj::do_invalidate_section_offset): New method decfinitions.
(Sized_relobj::elf_file, Sized_relobj::local_values): New methods.
* options.cc (parse_int): New function.
* options.h (parse_int): New declaration.
(DEFINE_int): New macro.
(stub_group_size): New option.
* output.cc (Output_section::Output_section): Initialize memebers
merge_section_map_, merge_section_by_properties_map_,
relaxed_input_section_map_, is_relaxed_input_section_map_valid_.
(Output_section::add_input_section): Handled deferred code-fill
generation and remove an old comment.
(Output_section::add_relaxed_input_section): New method definition.
(Output_section::add_merge_input_section): Use merge section by
properties map to speed to search. Update merge section maps
as appropriate.
(Output_section::build_relaxation_map): New method definition.
(Output_section::convert_input_sections_in_list_to_relaxed_sections):
Same.
(Output_section::relax_input_section): Renamed to
Output_section::convert_input_sections_to_relaxed_sections and change
interface to take a vector of pointers to relaxed sections.
(Output_section::find_merge_section,
Output_section::find_relaxed_input_section): New method definitions.
(Output_section::is_input_address_mapped,
Output_section::output_offset, Output_section::output_address):
Use output section data maps to speed up searching.
(Output_section::find_starting_output_address): Add comments.
(Output_section::do_write,
Output_section::write_to_postprocessing_buffer): Do code-fill
generation as appropriate.
(Output_section::get_input_sections): Invalidate relaxed input section
map.
(Output_section::restore_states): Adjust type of checkpoint .
Invalidate relaxed input section map.
* output.h (Output_merge_base): New class declaration.
(Input_section_specifier): New class defintion.
(class Output_relaxed_input_section) Change base class to
Output_section_data_build.
(Output_relaxed_input_section::Output_relaxed_input_section): Adjust
base class initializer.
(Output_section::add_relaxed_input_section): New method declaration.
(Output_section::Input_section): Change visibility to protected.
(Output_section::Input_section::relobj,
Output_section::Input_section::shndx): Handle relaxed input sections.
Output_section::input_sections) Change visibility to protected. Also
define overload to return a non-const pointer.
(Output_section::Merge_section_properties): New class defintion.
(Output_section::Merge_section_by_properties_map,
Output_section::Output_section_data_by_input_section_map,
Output_section::Relaxation_map): New types.
(Output_section::relax_input_section): Rename method to
Output_section::convert_input_sections_to_relaxed_sections and change
interface to take a vector of relaxed section pointers.
(Output_section::find_merge_section,
Output_section::find_relaxed_input_section,
Output_section::build_relaxation_map,
Output_section::convert_input_sections_in_list_to_relaxed_sections):
New method declarations.
(Output_section::merge_section_map_
Output_section::merge_section_by_properties_map_,
Output_section::relaxed_input_section_map_,
Output_section::is_relaxed_input_section_map_valid_,
Output_section::generate_code_fills_at_write_): New data members.
* script-sections.cc
(Output_section_element_input::set_section_addresses): Call
current_data_size and addralign methods of relaxed input sections.
(Orphan_output_section::set_section_addresses): Call current_data_size
and addralign methods of relaxed input sections.
* symtab.cc (Symbol_table::compute_final_value): Extract template
from the body of Symbol_table::sized_finalize_symbol.
(Symbol_table::sized_finalized_symbol): Call
Symbol_table::compute_final_value.
* symtab.h (Symbol_table::Compute_final_value_status): New enum type.
(Symbol_table::compute_final_value): New templated method declaration.
* target.cc (Target::do_make_output_section): New method defintion.
* target.h (Target::make_output_section): New method declaration.
(Target::relax): Add more parameters for input objects, symbol table
and layout. Adjust call to do_relax.
(Target::do_make_output_section): New method declaration.
(Target::do_relax): Add parameters for input objects, symbol table
and layout.
2009-10-10 01:18:19 +02:00
|
|
|
{
|
2010-10-06 10:58:59 +02:00
|
|
|
// We use current data size because relaxed section sizes may not
|
2009-10-09 Doug Kwan <dougkwan@google.com>
* layout.cc (Layout::make_output_section): Call target hook to make
ordinary output section.
(Layout::finalize): Adjust parameter list of call the
Target::may_relax().
* layout.h (class Layout::section_list): New method.
* merge.h (Output_merge_base::entsize): Change visibility to public.
(Output_merge_base::is_string, Output_merge_base::do_is_string):
New methods.
(Output_merge_string::do_is_string): New method.
* object.cc (Sized_relobj::do_setup): renamed from
Sized_relobj::set_up.
* object.h (Sized_relobj::adjust_shndx,
Sized_relobj::initializ_input_to_output_maps,
Sized_relobj::free_input_to_output_maps): Change visibilities to
protected.
(Sized_relobj::setup): Virtualize.
(Sized_relobj::do_setup): New method declaration.
(Sized_relobj::invalidate_section_offset,
Sized_relobj::do_invalidate_section_offset): New method decfinitions.
(Sized_relobj::elf_file, Sized_relobj::local_values): New methods.
* options.cc (parse_int): New function.
* options.h (parse_int): New declaration.
(DEFINE_int): New macro.
(stub_group_size): New option.
* output.cc (Output_section::Output_section): Initialize memebers
merge_section_map_, merge_section_by_properties_map_,
relaxed_input_section_map_, is_relaxed_input_section_map_valid_.
(Output_section::add_input_section): Handled deferred code-fill
generation and remove an old comment.
(Output_section::add_relaxed_input_section): New method definition.
(Output_section::add_merge_input_section): Use merge section by
properties map to speed to search. Update merge section maps
as appropriate.
(Output_section::build_relaxation_map): New method definition.
(Output_section::convert_input_sections_in_list_to_relaxed_sections):
Same.
(Output_section::relax_input_section): Renamed to
Output_section::convert_input_sections_to_relaxed_sections and change
interface to take a vector of pointers to relaxed sections.
(Output_section::find_merge_section,
Output_section::find_relaxed_input_section): New method definitions.
(Output_section::is_input_address_mapped,
Output_section::output_offset, Output_section::output_address):
Use output section data maps to speed up searching.
(Output_section::find_starting_output_address): Add comments.
(Output_section::do_write,
Output_section::write_to_postprocessing_buffer): Do code-fill
generation as appropriate.
(Output_section::get_input_sections): Invalidate relaxed input section
map.
(Output_section::restore_states): Adjust type of checkpoint .
Invalidate relaxed input section map.
* output.h (Output_merge_base): New class declaration.
(Input_section_specifier): New class defintion.
(class Output_relaxed_input_section) Change base class to
Output_section_data_build.
(Output_relaxed_input_section::Output_relaxed_input_section): Adjust
base class initializer.
(Output_section::add_relaxed_input_section): New method declaration.
(Output_section::Input_section): Change visibility to protected.
(Output_section::Input_section::relobj,
Output_section::Input_section::shndx): Handle relaxed input sections.
Output_section::input_sections) Change visibility to protected. Also
define overload to return a non-const pointer.
(Output_section::Merge_section_properties): New class defintion.
(Output_section::Merge_section_by_properties_map,
Output_section::Output_section_data_by_input_section_map,
Output_section::Relaxation_map): New types.
(Output_section::relax_input_section): Rename method to
Output_section::convert_input_sections_to_relaxed_sections and change
interface to take a vector of relaxed section pointers.
(Output_section::find_merge_section,
Output_section::find_relaxed_input_section,
Output_section::build_relaxation_map,
Output_section::convert_input_sections_in_list_to_relaxed_sections):
New method declarations.
(Output_section::merge_section_map_
Output_section::merge_section_by_properties_map_,
Output_section::relaxed_input_section_map_,
Output_section::is_relaxed_input_section_map_valid_,
Output_section::generate_code_fills_at_write_): New data members.
* script-sections.cc
(Output_section_element_input::set_section_addresses): Call
current_data_size and addralign methods of relaxed input sections.
(Orphan_output_section::set_section_addresses): Call current_data_size
and addralign methods of relaxed input sections.
* symtab.cc (Symbol_table::compute_final_value): Extract template
from the body of Symbol_table::sized_finalize_symbol.
(Symbol_table::sized_finalized_symbol): Call
Symbol_table::compute_final_value.
* symtab.h (Symbol_table::Compute_final_value_status): New enum type.
(Symbol_table::compute_final_value): New templated method declaration.
* target.cc (Target::do_make_output_section): New method defintion.
* target.h (Target::make_output_section): New method declaration.
(Target::relax): Add more parameters for input objects, symbol table
and layout. Adjust call to do_relax.
(Target::do_make_output_section): New method declaration.
(Target::do_relax): Add parameters for input objects, symbol table
and layout.
2009-10-10 01:18:19 +02:00
|
|
|
// have finalized yet.
|
|
|
|
isi.set_size(p->relaxed_input_section()->current_data_size());
|
|
|
|
isi.set_addralign(p->relaxed_input_section()->addralign());
|
|
|
|
}
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
else
|
2009-10-09 Doug Kwan <dougkwan@google.com>
* layout.cc (Layout::make_output_section): Call target hook to make
ordinary output section.
(Layout::finalize): Adjust parameter list of call the
Target::may_relax().
* layout.h (class Layout::section_list): New method.
* merge.h (Output_merge_base::entsize): Change visibility to public.
(Output_merge_base::is_string, Output_merge_base::do_is_string):
New methods.
(Output_merge_string::do_is_string): New method.
* object.cc (Sized_relobj::do_setup): renamed from
Sized_relobj::set_up.
* object.h (Sized_relobj::adjust_shndx,
Sized_relobj::initializ_input_to_output_maps,
Sized_relobj::free_input_to_output_maps): Change visibilities to
protected.
(Sized_relobj::setup): Virtualize.
(Sized_relobj::do_setup): New method declaration.
(Sized_relobj::invalidate_section_offset,
Sized_relobj::do_invalidate_section_offset): New method decfinitions.
(Sized_relobj::elf_file, Sized_relobj::local_values): New methods.
* options.cc (parse_int): New function.
* options.h (parse_int): New declaration.
(DEFINE_int): New macro.
(stub_group_size): New option.
* output.cc (Output_section::Output_section): Initialize memebers
merge_section_map_, merge_section_by_properties_map_,
relaxed_input_section_map_, is_relaxed_input_section_map_valid_.
(Output_section::add_input_section): Handled deferred code-fill
generation and remove an old comment.
(Output_section::add_relaxed_input_section): New method definition.
(Output_section::add_merge_input_section): Use merge section by
properties map to speed to search. Update merge section maps
as appropriate.
(Output_section::build_relaxation_map): New method definition.
(Output_section::convert_input_sections_in_list_to_relaxed_sections):
Same.
(Output_section::relax_input_section): Renamed to
Output_section::convert_input_sections_to_relaxed_sections and change
interface to take a vector of pointers to relaxed sections.
(Output_section::find_merge_section,
Output_section::find_relaxed_input_section): New method definitions.
(Output_section::is_input_address_mapped,
Output_section::output_offset, Output_section::output_address):
Use output section data maps to speed up searching.
(Output_section::find_starting_output_address): Add comments.
(Output_section::do_write,
Output_section::write_to_postprocessing_buffer): Do code-fill
generation as appropriate.
(Output_section::get_input_sections): Invalidate relaxed input section
map.
(Output_section::restore_states): Adjust type of checkpoint .
Invalidate relaxed input section map.
* output.h (Output_merge_base): New class declaration.
(Input_section_specifier): New class defintion.
(class Output_relaxed_input_section) Change base class to
Output_section_data_build.
(Output_relaxed_input_section::Output_relaxed_input_section): Adjust
base class initializer.
(Output_section::add_relaxed_input_section): New method declaration.
(Output_section::Input_section): Change visibility to protected.
(Output_section::Input_section::relobj,
Output_section::Input_section::shndx): Handle relaxed input sections.
Output_section::input_sections) Change visibility to protected. Also
define overload to return a non-const pointer.
(Output_section::Merge_section_properties): New class defintion.
(Output_section::Merge_section_by_properties_map,
Output_section::Output_section_data_by_input_section_map,
Output_section::Relaxation_map): New types.
(Output_section::relax_input_section): Rename method to
Output_section::convert_input_sections_to_relaxed_sections and change
interface to take a vector of relaxed section pointers.
(Output_section::find_merge_section,
Output_section::find_relaxed_input_section,
Output_section::build_relaxation_map,
Output_section::convert_input_sections_in_list_to_relaxed_sections):
New method declarations.
(Output_section::merge_section_map_
Output_section::merge_section_by_properties_map_,
Output_section::relaxed_input_section_map_,
Output_section::is_relaxed_input_section_map_valid_,
Output_section::generate_code_fills_at_write_): New data members.
* script-sections.cc
(Output_section_element_input::set_section_addresses): Call
current_data_size and addralign methods of relaxed input sections.
(Orphan_output_section::set_section_addresses): Call current_data_size
and addralign methods of relaxed input sections.
* symtab.cc (Symbol_table::compute_final_value): Extract template
from the body of Symbol_table::sized_finalize_symbol.
(Symbol_table::sized_finalized_symbol): Call
Symbol_table::compute_final_value.
* symtab.h (Symbol_table::Compute_final_value_status): New enum type.
(Symbol_table::compute_final_value): New templated method declaration.
* target.cc (Target::do_make_output_section): New method defintion.
* target.h (Target::make_output_section): New method declaration.
(Target::relax): Add more parameters for input objects, symbol table
and layout. Adjust call to do_relax.
(Target::do_make_output_section): New method declaration.
(Target::do_relax): Add parameters for input objects, symbol table
and layout.
2009-10-10 01:18:19 +02:00
|
|
|
{
|
|
|
|
isi.set_size(relobj->section_size(shndx));
|
|
|
|
isi.set_addralign(relobj->section_addralign(shndx));
|
|
|
|
}
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
if (!this->match_file_name(relobj->name().c_str()))
|
2008-02-04 06:43:05 +01:00
|
|
|
++p;
|
|
|
|
else if (this->input_section_patterns_.empty())
|
|
|
|
{
|
|
|
|
matching_sections[0].push_back(isi);
|
|
|
|
p = input_sections->erase(p);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
for (i = 0; i < input_pattern_count; ++i)
|
|
|
|
{
|
|
|
|
const Input_section_pattern&
|
|
|
|
isp(this->input_section_patterns_[i]);
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
if (match(isi.section_name().c_str(), isp.pattern.c_str(),
|
2008-02-04 06:43:05 +01:00
|
|
|
isp.pattern_is_wildcard))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-06-23 18:45:25 +02:00
|
|
|
if (i >= input_pattern_count)
|
2008-02-04 06:43:05 +01:00
|
|
|
++p;
|
|
|
|
else
|
|
|
|
{
|
2016-06-23 18:45:25 +02:00
|
|
|
if (i >= bin_count)
|
Fix gold to group sections correctly via linker script.
In PR 15370, it is noted that gold does not distinguish between
"*(.foo .bar)" and "*(.foo) *(.bar)" in linker scripts. In both
cases, gold groups all .foo sections together, followed by all
.bar sections, whereas in the first case, it should collect all
.foo and .bar sections in the order seen.
If you add sort specs, the Gnu linker has some bizarre corner
cases that I do not try to replicate. In particular,
"*(SORT_BY_NAME(.foo) SORT_BY_NAME(.bar))" does the same thing
as "*(.foo) *(.bar)". But if you apply a sort spec
to just one of several patterns, say, "*(SORT_BY_NAME(.foo) .bar)",
the Gnu linker will collect any .bar section it sees before the
first .foo, then all .foo sections, then all remaining .bar
sections. With this patch, if any of the input patterns have a
sort spec, gold will group them all as it did before; e.g.,
all .foo sections followed by all .bar sections.
2015-06-03 Cary Coutant <ccoutant@gmail.com>
gold/
PR gold/15370
* script-sections.cc
(Output_section_element_input::set_section_addresses): When there
are several patterns with no sort spec, put all sections in the same
bin.
* testsuite/Makefile.am (script_test_12): New testcase.
(script_test_12i): New testcase.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_12.t: New test linker script.
* testsuite/script_test_12i.t: New test linker script.
* testsuite/script_test_12a.c: New test source file.
* testsuite/script_test_12b.c: New test source file.
2015-06-04 04:11:42 +02:00
|
|
|
i = 0;
|
2008-02-04 06:43:05 +01:00
|
|
|
matching_sections[i].push_back(isi);
|
|
|
|
p = input_sections->erase(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look through MATCHING_SECTIONS. Sort each one as specified,
|
|
|
|
// using a stable sort so that we get the default order when
|
|
|
|
// sections are otherwise equal. Add each input section to the
|
|
|
|
// output section.
|
|
|
|
|
2009-10-16 07:00:29 +02:00
|
|
|
uint64_t dot = *dot_value;
|
2016-06-23 18:45:25 +02:00
|
|
|
for (size_t i = 0; i < bin_count; ++i)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
if (matching_sections[i].empty())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
gold_assert(output_section != NULL);
|
|
|
|
|
|
|
|
const Input_section_pattern& isp(this->input_section_patterns_[i]);
|
|
|
|
if (isp.sort != SORT_WILDCARD_NONE
|
|
|
|
|| this->filename_sort_ != SORT_WILDCARD_NONE)
|
|
|
|
std::stable_sort(matching_sections[i].begin(),
|
|
|
|
matching_sections[i].end(),
|
|
|
|
Input_section_sorter(this->filename_sort_,
|
|
|
|
isp.sort));
|
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
for (std::vector<Input_section_info>::const_iterator p =
|
2008-02-04 06:43:05 +01:00
|
|
|
matching_sections[i].begin();
|
2009-12-14 20:53:05 +01:00
|
|
|
p != matching_sections[i].end();
|
|
|
|
++p)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
Fix problems with bss handling in linker scripts.
PR 16711 noted that gold allocates file space for BSS sections when using
a linker script. I've fixed that by rewriting set_section_addresses and
set_section_list_addresses to track the file offset separate from the
current virtual address, so that BSS sections do not move the file offset.
Now, if a series of BSS sections come at the end of a segment, we do not
allocate file space; but if a script forces them into the middle of a
segment, we will still allocate file space (matching Gnu ld behavior).
I've also added a warning when that happens.
That exposed another problem where orphan .bss sections were sometimes
placed in the middle of a segment. For example, if the script mentions
the .got section, but both .data and .bss are orphans, gold would put
both .data and .bss in front of .got. I've fixed that by ensuring that
orphan BSS sections are always placed after all other allocated sections.
It also exposed a problem where the SUBALIGN property is not handled
properly. The ld manual clearly states that it should override input section
alignment, whether greater or less than the given alignment, but gold would
only increase an input section's alignment. Gold would also place the output
section based on its original alignment before the SUBALIGN property took
effect, leading to a misaligned output section (where the input section
was properly aligned in memory, but was not aligned relative to the start
of the section), in violation of the ELF/gABI spec. I've fixed that by
making sure that the SUBALIGN property overrides the internal alignment of
the input sections as well as the external alignment of the output section.
This affected the behavior of script_test_2, which was written to expect
a misaligned section.
The net effect is, I think, improved compatibility with the BFD linker.
There are still cases where orphan placement differs, but the differences
should be rarer and less important. ALIGN and SUBALIGN behavior is closer,
but still not an exact match -- I still found cases where ld would create
a misaligned output section, and where gold will properly align it.
gold/
PR gold/16711
* output.cc (Output_section::set_final_data_size): Calculate data size
based on relative offset rather than file offset.
(Output_segment::set_section_addresses): Track file offset separately
from address offset.
(Output_segment::set_section_list_addresses): Add pfoff parameter.
Track file offset separately. Don't move file offset for BSS
sections.
* output.h (Output_segment::set_section_list_addresses): Add pfoff
parameter.
* script-sections.cc (Orphan_section_placement): Add PLACE_LAST_ALLOC.
(Orphan_section_placement::Orphan_section_placement): Initialize it.
(Orphan_section_placement::output_section_init): Track last allocated
section.
(Orphan_section_placement::find_place): Place BSS after last allocated
section.
(Output_section_element_input::set_section_addresses): Always override
input section alignment when SUBALIGN is specified.
(Output_section_definition::set_section_addresses): Override alignment
of output section when SUBALIGN is specified.
* testsuite/Makefile.am (script_test_15a, script_test_15b)
(script_test_15c): New test cases.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_2.cc: Adjust expected layout.
* testsuite/script_test_15.c: New source file.
* testsuite/script_test_15a.sh: New shell script.
* testsuite/script_test_15a.t: New linker script.
* testsuite/script_test_15b.sh: New shell script.
* testsuite/script_test_15b.t: New linker script.
* testsuite/script_test_15c.sh: New shell script.
* testsuite/script_test_15c.t: New linker script.
2016-12-12 02:31:25 +01:00
|
|
|
// Override the original address alignment if SUBALIGN is specified.
|
|
|
|
// We need to make a copy of the input section to modify the
|
|
|
|
// alignment.
|
2010-05-19 09:09:36 +02:00
|
|
|
Output_section::Input_section sis(p->input_section());
|
|
|
|
|
|
|
|
uint64_t this_subalign = sis.addralign();
|
|
|
|
if (!sis.is_input_section())
|
2016-08-12 18:55:25 +02:00
|
|
|
sis.output_section_data()->finalize_data_size();
|
2010-05-19 09:09:36 +02:00
|
|
|
uint64_t data_size = sis.data_size();
|
Fix problems with bss handling in linker scripts.
PR 16711 noted that gold allocates file space for BSS sections when using
a linker script. I've fixed that by rewriting set_section_addresses and
set_section_list_addresses to track the file offset separate from the
current virtual address, so that BSS sections do not move the file offset.
Now, if a series of BSS sections come at the end of a segment, we do not
allocate file space; but if a script forces them into the middle of a
segment, we will still allocate file space (matching Gnu ld behavior).
I've also added a warning when that happens.
That exposed another problem where orphan .bss sections were sometimes
placed in the middle of a segment. For example, if the script mentions
the .got section, but both .data and .bss are orphans, gold would put
both .data and .bss in front of .got. I've fixed that by ensuring that
orphan BSS sections are always placed after all other allocated sections.
It also exposed a problem where the SUBALIGN property is not handled
properly. The ld manual clearly states that it should override input section
alignment, whether greater or less than the given alignment, but gold would
only increase an input section's alignment. Gold would also place the output
section based on its original alignment before the SUBALIGN property took
effect, leading to a misaligned output section (where the input section
was properly aligned in memory, but was not aligned relative to the start
of the section), in violation of the ELF/gABI spec. I've fixed that by
making sure that the SUBALIGN property overrides the internal alignment of
the input sections as well as the external alignment of the output section.
This affected the behavior of script_test_2, which was written to expect
a misaligned section.
The net effect is, I think, improved compatibility with the BFD linker.
There are still cases where orphan placement differs, but the differences
should be rarer and less important. ALIGN and SUBALIGN behavior is closer,
but still not an exact match -- I still found cases where ld would create
a misaligned output section, and where gold will properly align it.
gold/
PR gold/16711
* output.cc (Output_section::set_final_data_size): Calculate data size
based on relative offset rather than file offset.
(Output_segment::set_section_addresses): Track file offset separately
from address offset.
(Output_segment::set_section_list_addresses): Add pfoff parameter.
Track file offset separately. Don't move file offset for BSS
sections.
* output.h (Output_segment::set_section_list_addresses): Add pfoff
parameter.
* script-sections.cc (Orphan_section_placement): Add PLACE_LAST_ALLOC.
(Orphan_section_placement::Orphan_section_placement): Initialize it.
(Orphan_section_placement::output_section_init): Track last allocated
section.
(Orphan_section_placement::find_place): Place BSS after last allocated
section.
(Output_section_element_input::set_section_addresses): Always override
input section alignment when SUBALIGN is specified.
(Output_section_definition::set_section_addresses): Override alignment
of output section when SUBALIGN is specified.
* testsuite/Makefile.am (script_test_15a, script_test_15b)
(script_test_15c): New test cases.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_2.cc: Adjust expected layout.
* testsuite/script_test_15.c: New source file.
* testsuite/script_test_15a.sh: New shell script.
* testsuite/script_test_15a.t: New linker script.
* testsuite/script_test_15b.sh: New shell script.
* testsuite/script_test_15b.t: New linker script.
* testsuite/script_test_15c.sh: New shell script.
* testsuite/script_test_15c.t: New linker script.
2016-12-12 02:31:25 +01:00
|
|
|
if (subalign > 0)
|
2010-05-19 09:09:36 +02:00
|
|
|
{
|
|
|
|
this_subalign = subalign;
|
|
|
|
sis.set_addralign(subalign);
|
|
|
|
}
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2009-10-16 07:00:29 +02:00
|
|
|
uint64_t address = align_address(dot, this_subalign);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2009-10-16 07:00:29 +02:00
|
|
|
if (address > dot && !fill->empty())
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
section_size_type length =
|
2009-10-16 07:00:29 +02:00
|
|
|
convert_to_section_size_type(address - dot);
|
2008-02-04 06:43:05 +01:00
|
|
|
std::string this_fill = this->get_fill_string(fill, length);
|
|
|
|
Output_section_data* posd = new Output_data_const(this_fill, 0);
|
|
|
|
output_section->add_output_section_data(posd);
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
layout->new_output_section_data_from_script(posd);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2010-05-19 09:09:36 +02:00
|
|
|
output_section->add_script_input_section(sis);
|
|
|
|
dot = address + data_size;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-16 07:00:29 +02:00
|
|
|
// An SHF_TLS/SHT_NOBITS section does not take up any
|
|
|
|
// address space.
|
|
|
|
if (output_section == NULL
|
|
|
|
|| (output_section->flags() & elfcpp::SHF_TLS) == 0
|
|
|
|
|| output_section->type() != elfcpp::SHT_NOBITS)
|
|
|
|
*dot_value = dot;
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
this->final_dot_value_ = *dot_value;
|
2008-02-09 02:22:17 +01:00
|
|
|
this->final_dot_section_ = *dot_section;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// Print for debugging.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_element_input::print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " ");
|
|
|
|
|
|
|
|
if (this->keep_)
|
|
|
|
fprintf(f, "KEEP(");
|
|
|
|
|
|
|
|
if (!this->filename_pattern_.empty())
|
|
|
|
{
|
|
|
|
bool need_close_paren = false;
|
|
|
|
switch (this->filename_sort_)
|
|
|
|
{
|
|
|
|
case SORT_WILDCARD_NONE:
|
|
|
|
break;
|
|
|
|
case SORT_WILDCARD_BY_NAME:
|
|
|
|
fprintf(f, "SORT_BY_NAME(");
|
|
|
|
need_close_paren = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(f, "%s", this->filename_pattern_.c_str());
|
|
|
|
|
|
|
|
if (need_close_paren)
|
|
|
|
fprintf(f, ")");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!this->input_section_patterns_.empty()
|
|
|
|
|| !this->filename_exclusions_.empty())
|
|
|
|
{
|
|
|
|
fprintf(f, "(");
|
|
|
|
|
|
|
|
bool need_space = false;
|
|
|
|
if (!this->filename_exclusions_.empty())
|
|
|
|
{
|
|
|
|
fprintf(f, "EXCLUDE_FILE(");
|
|
|
|
bool need_comma = false;
|
|
|
|
for (Filename_exclusions::const_iterator p =
|
|
|
|
this->filename_exclusions_.begin();
|
|
|
|
p != this->filename_exclusions_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if (need_comma)
|
|
|
|
fprintf(f, ", ");
|
2008-02-04 06:43:05 +01:00
|
|
|
fprintf(f, "%s", p->first.c_str());
|
2008-01-23 02:31:13 +01:00
|
|
|
need_comma = true;
|
|
|
|
}
|
|
|
|
fprintf(f, ")");
|
|
|
|
need_space = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (Input_section_patterns::const_iterator p =
|
|
|
|
this->input_section_patterns_.begin();
|
|
|
|
p != this->input_section_patterns_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if (need_space)
|
|
|
|
fprintf(f, " ");
|
|
|
|
|
|
|
|
int close_parens = 0;
|
|
|
|
switch (p->sort)
|
|
|
|
{
|
|
|
|
case SORT_WILDCARD_NONE:
|
|
|
|
break;
|
|
|
|
case SORT_WILDCARD_BY_NAME:
|
|
|
|
fprintf(f, "SORT_BY_NAME(");
|
|
|
|
close_parens = 1;
|
|
|
|
break;
|
|
|
|
case SORT_WILDCARD_BY_ALIGNMENT:
|
|
|
|
fprintf(f, "SORT_BY_ALIGNMENT(");
|
|
|
|
close_parens = 1;
|
|
|
|
break;
|
|
|
|
case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
|
|
|
|
fprintf(f, "SORT_BY_NAME(SORT_BY_ALIGNMENT(");
|
|
|
|
close_parens = 2;
|
|
|
|
break;
|
|
|
|
case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
|
|
|
|
fprintf(f, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
|
|
|
|
close_parens = 2;
|
|
|
|
break;
|
2016-06-28 22:56:05 +02:00
|
|
|
case SORT_WILDCARD_BY_INIT_PRIORITY:
|
|
|
|
fprintf(f, "SORT_BY_INIT_PRIORITY(");
|
|
|
|
close_parens = 1;
|
|
|
|
break;
|
2008-01-23 02:31:13 +01:00
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(f, "%s", p->pattern.c_str());
|
|
|
|
|
|
|
|
for (int i = 0; i < close_parens; ++i)
|
|
|
|
fprintf(f, ")");
|
|
|
|
|
|
|
|
need_space = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(f, ")");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (this->keep_)
|
|
|
|
fprintf(f, ")");
|
|
|
|
|
|
|
|
fprintf(f, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
// An output section.
|
|
|
|
|
|
|
|
class Output_section_definition : public Sections_element
|
|
|
|
{
|
|
|
|
public:
|
2008-02-04 06:43:05 +01:00
|
|
|
typedef Output_section_element::Input_section_list Input_section_list;
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
Output_section_definition(const char* name, size_t namelen,
|
|
|
|
const Parser_output_section_header* header);
|
|
|
|
|
|
|
|
// Finish the output section with the information in the trailer.
|
|
|
|
void
|
|
|
|
finish(const Parser_output_section_trailer* trailer);
|
|
|
|
|
|
|
|
// Add a symbol to be defined.
|
|
|
|
void
|
|
|
|
add_symbol_assignment(const char* name, size_t length, Expression* value,
|
|
|
|
bool provide, bool hidden);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Add an assignment to the special dot symbol.
|
|
|
|
void
|
|
|
|
add_dot_assignment(Expression* value);
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// Add an assertion.
|
|
|
|
void
|
|
|
|
add_assertion(Expression* check, const char* message, size_t messagelen);
|
|
|
|
|
|
|
|
// Add a data item to the current output section.
|
|
|
|
void
|
|
|
|
add_data(int size, bool is_signed, Expression* val);
|
|
|
|
|
|
|
|
// Add a setting for the fill value.
|
|
|
|
void
|
|
|
|
add_fill(Expression* val);
|
|
|
|
|
|
|
|
// Add an input section specification.
|
|
|
|
void
|
|
|
|
add_input_section(const Input_section_spec* spec, bool keep);
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
// Return whether the output section is relro.
|
|
|
|
bool
|
|
|
|
is_relro() const
|
|
|
|
{ return this->is_relro_; }
|
|
|
|
|
2008-08-13 09:37:46 +02:00
|
|
|
// Record that the output section is relro.
|
|
|
|
void
|
|
|
|
set_is_relro()
|
|
|
|
{ this->is_relro_ = true; }
|
|
|
|
|
2008-02-28 05:45:47 +01:00
|
|
|
// Create any required output sections.
|
|
|
|
void
|
|
|
|
create_sections(Layout*);
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Add any symbols being defined to the symbol table.
|
|
|
|
void
|
|
|
|
add_symbols_to_table(Symbol_table* symtab);
|
|
|
|
|
|
|
|
// Finalize symbols and check assertions.
|
|
|
|
void
|
2008-02-09 02:22:17 +01:00
|
|
|
finalize_symbols(Symbol_table*, const Layout*, uint64_t*);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Return the output section name to use for an input file name and
|
|
|
|
// section name.
|
|
|
|
const char*
|
|
|
|
output_section_name(const char* file_name, const char* section_name,
|
2012-08-14 10:31:57 +02:00
|
|
|
Output_section***, Script_sections::Section_type*,
|
2016-12-20 01:37:48 +01:00
|
|
|
bool*, bool);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
// Initialize OSP with an output section.
|
|
|
|
void
|
|
|
|
orphan_section_init(Orphan_section_placement* osp,
|
|
|
|
Script_sections::Elements_iterator p)
|
|
|
|
{ osp->output_section_init(this->name_, this->output_section_, p); }
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Set the section address.
|
|
|
|
void
|
|
|
|
set_section_addresses(Symbol_table* symtab, Layout* layout,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t* dot_value, uint64_t*,
|
|
|
|
uint64_t* load_address);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-02-04 07:45:50 +01:00
|
|
|
// Check a constraint (ONLY_IF_RO, etc.) on an output section. If
|
|
|
|
// this section is constrained, and the input sections do not match,
|
|
|
|
// return the constraint, and set *POSD.
|
|
|
|
Section_constraint
|
|
|
|
check_constraint(Output_section_definition** posd);
|
|
|
|
|
|
|
|
// See if this is the alternate output section for a constrained
|
|
|
|
// output section. If it is, transfer the Output_section and return
|
|
|
|
// true. Otherwise return false.
|
|
|
|
bool
|
|
|
|
alternate_constraint(Output_section_definition*, Section_constraint);
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// Get the list of segments to use for an allocated section when
|
2008-04-10 03:02:46 +02:00
|
|
|
// using a PHDRS clause.
|
2008-02-04 23:54:31 +01:00
|
|
|
Output_section*
|
2008-04-10 03:02:46 +02:00
|
|
|
allocate_to_segment(String_list** phdrs_list, bool* orphan);
|
2008-02-04 23:54:31 +01:00
|
|
|
|
2008-02-29 01:04:06 +01:00
|
|
|
// Look for an output section by name and return the address, the
|
|
|
|
// load address, the alignment, and the size. This is used when an
|
|
|
|
// expression refers to an output section which was not actually
|
|
|
|
// created. This returns true if the section was found, false
|
|
|
|
// otherwise.
|
|
|
|
bool
|
|
|
|
get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
|
|
|
|
uint64_t*) const;
|
|
|
|
|
2008-08-13 09:37:46 +02:00
|
|
|
// Return the associated Output_section if there is one.
|
|
|
|
Output_section*
|
|
|
|
get_output_section() const
|
|
|
|
{ return this->output_section_; }
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// Print the contents to the FILE. This is for debugging.
|
|
|
|
void
|
|
|
|
print(FILE*) const;
|
|
|
|
|
2010-04-09 19:32:58 +02:00
|
|
|
// Return the output section type if specified or Script_sections::ST_NONE.
|
|
|
|
Script_sections::Section_type
|
|
|
|
section_type() const;
|
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
// Store the memory region to use.
|
|
|
|
void
|
|
|
|
set_memory_region(Memory_region*, bool set_vma);
|
|
|
|
|
|
|
|
void
|
|
|
|
set_section_vma(Expression* address)
|
|
|
|
{ this->address_ = address; }
|
2016-08-12 18:55:25 +02:00
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
void
|
|
|
|
set_section_lma(Expression* address)
|
|
|
|
{ this->load_address_ = address; }
|
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
const std::string&
|
|
|
|
get_section_name() const
|
2010-09-08 18:10:33 +02:00
|
|
|
{ return this->name_; }
|
2016-08-12 18:55:25 +02:00
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
private:
|
2010-04-09 19:32:58 +02:00
|
|
|
static const char*
|
|
|
|
script_section_type_name(Script_section_type);
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
typedef std::vector<Output_section_element*> Output_section_elements;
|
|
|
|
|
|
|
|
// The output section name.
|
|
|
|
std::string name_;
|
|
|
|
// The address. This may be NULL.
|
|
|
|
Expression* address_;
|
|
|
|
// The load address. This may be NULL.
|
|
|
|
Expression* load_address_;
|
|
|
|
// The alignment. This may be NULL.
|
|
|
|
Expression* align_;
|
|
|
|
// The input section alignment. This may be NULL.
|
|
|
|
Expression* subalign_;
|
2008-02-04 07:45:50 +01:00
|
|
|
// The constraint, if any.
|
|
|
|
Section_constraint constraint_;
|
2008-01-23 02:31:13 +01:00
|
|
|
// The fill value. This may be NULL.
|
|
|
|
Expression* fill_;
|
2008-02-04 23:54:31 +01:00
|
|
|
// The list of segments this section should go into. This may be
|
|
|
|
// NULL.
|
|
|
|
String_list* phdrs_;
|
2008-01-23 02:31:13 +01:00
|
|
|
// The list of elements defining the section.
|
|
|
|
Output_section_elements elements_;
|
2008-02-04 06:43:05 +01:00
|
|
|
// The Output_section created for this definition. This will be
|
|
|
|
// NULL if none was created.
|
|
|
|
Output_section* output_section_;
|
2008-02-29 01:04:06 +01:00
|
|
|
// The address after it has been evaluated.
|
|
|
|
uint64_t evaluated_address_;
|
|
|
|
// The load address after it has been evaluated.
|
|
|
|
uint64_t evaluated_load_address_;
|
|
|
|
// The alignment after it has been evaluated.
|
|
|
|
uint64_t evaluated_addralign_;
|
2008-08-13 09:37:46 +02:00
|
|
|
// The output section is relro.
|
|
|
|
bool is_relro_;
|
2010-04-09 19:32:58 +02:00
|
|
|
// The output section type if specified.
|
|
|
|
enum Script_section_type script_section_type_;
|
2008-01-23 02:31:13 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
// Constructor.
|
|
|
|
|
|
|
|
Output_section_definition::Output_section_definition(
|
|
|
|
const char* name,
|
|
|
|
size_t namelen,
|
|
|
|
const Parser_output_section_header* header)
|
|
|
|
: name_(name, namelen),
|
|
|
|
address_(header->address),
|
|
|
|
load_address_(header->load_address),
|
|
|
|
align_(header->align),
|
|
|
|
subalign_(header->subalign),
|
2008-02-04 07:45:50 +01:00
|
|
|
constraint_(header->constraint),
|
2008-01-23 02:31:13 +01:00
|
|
|
fill_(NULL),
|
2008-02-04 23:54:31 +01:00
|
|
|
phdrs_(NULL),
|
2008-02-04 06:43:05 +01:00
|
|
|
elements_(),
|
2008-08-13 09:37:46 +02:00
|
|
|
output_section_(NULL),
|
|
|
|
evaluated_address_(0),
|
|
|
|
evaluated_load_address_(0),
|
|
|
|
evaluated_addralign_(0),
|
2010-04-09 19:32:58 +02:00
|
|
|
is_relro_(false),
|
|
|
|
script_section_type_(header->section_type)
|
2008-01-23 02:31:13 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finish an output section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::finish(const Parser_output_section_trailer* trailer)
|
|
|
|
{
|
|
|
|
this->fill_ = trailer->fill;
|
2008-02-04 23:54:31 +01:00
|
|
|
this->phdrs_ = trailer->phdrs;
|
2008-01-23 02:31:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Add a symbol to be defined.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::add_symbol_assignment(const char* name,
|
|
|
|
size_t length,
|
|
|
|
Expression* value,
|
|
|
|
bool provide,
|
|
|
|
bool hidden)
|
|
|
|
{
|
|
|
|
Output_section_element* p = new Output_section_element_assignment(name,
|
|
|
|
length,
|
|
|
|
value,
|
|
|
|
provide,
|
|
|
|
hidden);
|
|
|
|
this->elements_.push_back(p);
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Add an assignment to the special dot symbol.
|
2008-01-23 02:31:13 +01:00
|
|
|
|
|
|
|
void
|
2008-02-04 06:43:05 +01:00
|
|
|
Output_section_definition::add_dot_assignment(Expression* value)
|
|
|
|
{
|
|
|
|
Output_section_element* p = new Output_section_element_dot_assignment(value);
|
|
|
|
this->elements_.push_back(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add an assertion.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::add_assertion(Expression* check,
|
|
|
|
const char* message,
|
2008-01-23 02:31:13 +01:00
|
|
|
size_t messagelen)
|
|
|
|
{
|
|
|
|
Output_section_element* p = new Output_section_element_assertion(check,
|
|
|
|
message,
|
|
|
|
messagelen);
|
|
|
|
this->elements_.push_back(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a data item to the current output section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::add_data(int size, bool is_signed, Expression* val)
|
|
|
|
{
|
|
|
|
Output_section_element* p = new Output_section_element_data(size, is_signed,
|
|
|
|
val);
|
|
|
|
this->elements_.push_back(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a setting for the fill value.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::add_fill(Expression* val)
|
|
|
|
{
|
|
|
|
Output_section_element* p = new Output_section_element_fill(val);
|
|
|
|
this->elements_.push_back(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add an input section specification.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::add_input_section(const Input_section_spec* spec,
|
|
|
|
bool keep)
|
|
|
|
{
|
|
|
|
Output_section_element* p = new Output_section_element_input(spec, keep);
|
|
|
|
this->elements_.push_back(p);
|
|
|
|
}
|
|
|
|
|
2008-02-28 05:45:47 +01:00
|
|
|
// Create any required output sections. We need an output section if
|
|
|
|
// there is a data statement here.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::create_sections(Layout* layout)
|
|
|
|
{
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
return;
|
|
|
|
for (Output_section_elements::const_iterator p = this->elements_.begin();
|
|
|
|
p != this->elements_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if ((*p)->needs_output_section())
|
|
|
|
{
|
|
|
|
const char* name = this->name_.c_str();
|
2010-04-09 19:32:58 +02:00
|
|
|
this->output_section_ =
|
|
|
|
layout->make_output_section_for_script(name, this->section_type());
|
2008-02-28 05:45:47 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Add any symbols being defined to the symbol table.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::add_symbols_to_table(Symbol_table* symtab)
|
|
|
|
{
|
|
|
|
for (Output_section_elements::iterator p = this->elements_.begin();
|
|
|
|
p != this->elements_.end();
|
|
|
|
++p)
|
|
|
|
(*p)->add_symbols_to_table(symtab);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finalize symbols and check assertions.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::finalize_symbols(Symbol_table* symtab,
|
|
|
|
const Layout* layout,
|
|
|
|
uint64_t* dot_value)
|
|
|
|
{
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
*dot_value = this->output_section_->address();
|
|
|
|
else
|
|
|
|
{
|
|
|
|
uint64_t address = *dot_value;
|
|
|
|
if (this->address_ != NULL)
|
|
|
|
{
|
2008-02-28 05:45:47 +01:00
|
|
|
address = this->address_->eval_with_dot(symtab, layout, true,
|
2008-02-09 02:22:17 +01:00
|
|
|
*dot_value, NULL,
|
2011-10-31 23:51:03 +01:00
|
|
|
NULL, NULL, false);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
if (this->align_ != NULL)
|
|
|
|
{
|
2008-02-28 05:45:47 +01:00
|
|
|
uint64_t align = this->align_->eval_with_dot(symtab, layout, true,
|
2010-10-01 17:02:33 +02:00
|
|
|
*dot_value, NULL,
|
2011-10-31 23:51:03 +01:00
|
|
|
NULL, NULL, false);
|
2008-02-04 06:43:05 +01:00
|
|
|
address = align_address(address, align);
|
|
|
|
}
|
|
|
|
*dot_value = address;
|
|
|
|
}
|
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section* dot_section = this->output_section_;
|
2008-02-04 06:43:05 +01:00
|
|
|
for (Output_section_elements::iterator p = this->elements_.begin();
|
|
|
|
p != this->elements_.end();
|
|
|
|
++p)
|
2008-02-09 02:22:17 +01:00
|
|
|
(*p)->finalize_symbols(symtab, layout, dot_value, &dot_section);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return the output section name to use for an input section name.
|
|
|
|
|
|
|
|
const char*
|
2010-04-09 19:32:58 +02:00
|
|
|
Output_section_definition::output_section_name(
|
|
|
|
const char* file_name,
|
|
|
|
const char* section_name,
|
|
|
|
Output_section*** slot,
|
2012-08-14 10:31:57 +02:00
|
|
|
Script_sections::Section_type* psection_type,
|
2016-12-20 01:37:48 +01:00
|
|
|
bool* keep,
|
|
|
|
bool match_input_spec)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2016-12-20 01:37:48 +01:00
|
|
|
// If the section is a linker-created output section, just look for a match
|
2016-12-13 03:51:29 +01:00
|
|
|
// on the output section name.
|
2016-12-20 01:37:48 +01:00
|
|
|
if (!match_input_spec && this->name_ != "/DISCARD/")
|
2016-12-13 03:51:29 +01:00
|
|
|
{
|
|
|
|
if (this->name_ != section_name)
|
|
|
|
return NULL;
|
|
|
|
*slot = &this->output_section_;
|
|
|
|
*psection_type = this->section_type();
|
|
|
|
return this->name_.c_str();
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Ask each element whether it matches NAME.
|
|
|
|
for (Output_section_elements::const_iterator p = this->elements_.begin();
|
|
|
|
p != this->elements_.end();
|
|
|
|
++p)
|
|
|
|
{
|
2012-08-14 10:31:57 +02:00
|
|
|
if ((*p)->match_name(file_name, section_name, keep))
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
// We found a match for NAME, which means that it should go
|
|
|
|
// into this output section.
|
|
|
|
*slot = &this->output_section_;
|
2010-04-09 19:32:58 +02:00
|
|
|
*psection_type = this->section_type();
|
2008-02-04 06:43:05 +01:00
|
|
|
return this->name_.c_str();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// We don't know about this section name.
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
// Return true if memory from START to START + LENGTH is contained
|
|
|
|
// within a memory region.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Script_sections::block_in_region(Symbol_table* symtab, Layout* layout,
|
|
|
|
uint64_t start, uint64_t length) const
|
|
|
|
{
|
|
|
|
if (this->memory_regions_ == NULL)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (Memory_regions::const_iterator mr = this->memory_regions_->begin();
|
|
|
|
mr != this->memory_regions_->end();
|
|
|
|
++mr)
|
|
|
|
{
|
|
|
|
uint64_t s = (*mr)->start_address()->eval(symtab, layout, false);
|
|
|
|
uint64_t l = (*mr)->length()->eval(symtab, layout, false);
|
|
|
|
|
|
|
|
if (s <= start
|
|
|
|
&& (s + l) >= (start + length))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find a memory region that should be used by a given output SECTION.
|
|
|
|
// If provided set PREVIOUS_SECTION_RETURN to point to the last section
|
|
|
|
// that used the return memory region.
|
|
|
|
|
|
|
|
Memory_region*
|
|
|
|
Script_sections::find_memory_region(
|
|
|
|
Output_section_definition* section,
|
|
|
|
bool find_vma_region,
|
2015-08-26 09:03:04 +02:00
|
|
|
bool explicit_only,
|
2010-10-06 10:58:59 +02:00
|
|
|
Output_section_definition** previous_section_return)
|
|
|
|
{
|
|
|
|
if (previous_section_return != NULL)
|
|
|
|
* previous_section_return = NULL;
|
|
|
|
|
|
|
|
// Walk the memory regions specified in this script, if any.
|
|
|
|
if (this->memory_regions_ == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
// The /DISCARD/ section never gets assigned to any region.
|
|
|
|
if (section->get_section_name() == "/DISCARD/")
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
Memory_region* first_match = NULL;
|
|
|
|
|
|
|
|
// First check to see if a region has been assigned to this section.
|
|
|
|
for (Memory_regions::const_iterator mr = this->memory_regions_->begin();
|
|
|
|
mr != this->memory_regions_->end();
|
|
|
|
++mr)
|
|
|
|
{
|
|
|
|
if (find_vma_region)
|
|
|
|
{
|
|
|
|
for (Memory_region::Section_list::const_iterator s =
|
|
|
|
(*mr)->get_vma_section_list_start();
|
|
|
|
s != (*mr)->get_vma_section_list_end();
|
|
|
|
++s)
|
|
|
|
if ((*s) == section)
|
|
|
|
{
|
|
|
|
(*mr)->set_last_section(section);
|
|
|
|
return *mr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (Memory_region::Section_list::const_iterator s =
|
|
|
|
(*mr)->get_lma_section_list_start();
|
|
|
|
s != (*mr)->get_lma_section_list_end();
|
|
|
|
++s)
|
|
|
|
if ((*s) == section)
|
|
|
|
{
|
|
|
|
(*mr)->set_last_section(section);
|
|
|
|
return *mr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-26 09:03:04 +02:00
|
|
|
if (!explicit_only)
|
|
|
|
{
|
|
|
|
// Make a note of the first memory region whose attributes
|
|
|
|
// are compatible with the section. If we do not find an
|
|
|
|
// explicit region assignment, then we will return this region.
|
|
|
|
Output_section* out_sec = section->get_output_section();
|
|
|
|
if (first_match == NULL
|
|
|
|
&& out_sec != NULL
|
|
|
|
&& (*mr)->attributes_compatible(out_sec->flags(),
|
|
|
|
out_sec->type()))
|
|
|
|
first_match = *mr;
|
|
|
|
}
|
2010-10-06 10:58:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// With LMA computations, if an explicit region has not been specified then
|
|
|
|
// we will want to set the difference between the VMA and the LMA of the
|
|
|
|
// section were searching for to be the same as the difference between the
|
|
|
|
// VMA and LMA of the last section to be added to first matched region.
|
|
|
|
// Hence, if it was asked for, we return a pointer to the last section
|
|
|
|
// known to be used by the first matched region.
|
|
|
|
if (first_match != NULL
|
|
|
|
&& previous_section_return != NULL)
|
|
|
|
*previous_section_return = first_match->get_last_section();
|
|
|
|
|
|
|
|
return first_match;
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Set the section address. Note that the OUTPUT_SECTION_ field will
|
|
|
|
// be NULL if no input sections were mapped to this output section.
|
|
|
|
// We still have to adjust dot and process symbol assignments.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::set_section_addresses(Symbol_table* symtab,
|
|
|
|
Layout* layout,
|
2008-02-14 03:34:22 +01:00
|
|
|
uint64_t* dot_value,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t* dot_alignment,
|
2008-02-14 03:34:22 +01:00
|
|
|
uint64_t* load_address)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2010-10-06 10:58:59 +02:00
|
|
|
Memory_region* vma_region = NULL;
|
|
|
|
Memory_region* lma_region = NULL;
|
|
|
|
Script_sections* script_sections =
|
|
|
|
layout->script_options()->script_sections();
|
2008-02-04 06:43:05 +01:00
|
|
|
uint64_t address;
|
2010-04-09 19:32:58 +02:00
|
|
|
uint64_t old_dot_value = *dot_value;
|
|
|
|
uint64_t old_load_address = *load_address;
|
|
|
|
|
2013-01-10 01:18:15 +01:00
|
|
|
// If input section sorting is requested via --section-ordering-file or
|
2016-08-12 18:55:25 +02:00
|
|
|
// linker plugins, then do it here. This is important because we want
|
2013-01-10 01:18:15 +01:00
|
|
|
// any sorting specified in the linker scripts, which will be done after
|
2016-08-12 18:55:25 +02:00
|
|
|
// this, to take precedence. The final order of input sections is then
|
2013-01-10 01:18:15 +01:00
|
|
|
// guaranteed to be according to the linker script specification.
|
|
|
|
if (this->output_section_ != NULL
|
|
|
|
&& this->output_section_->input_section_order_specified())
|
|
|
|
this->output_section_->sort_attached_input_sections();
|
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
// Decide the start address for the section. The algorithm is:
|
|
|
|
// 1) If an address has been specified in a linker script, use that.
|
|
|
|
// 2) Otherwise if a memory region has been specified for the section,
|
|
|
|
// use the next free address in the region.
|
|
|
|
// 3) Otherwise if memory regions have been specified find the first
|
|
|
|
// region whose attributes are compatible with this section and
|
|
|
|
// install it into that region.
|
|
|
|
// 4) Otherwise use the current location counter.
|
|
|
|
|
|
|
|
if (this->output_section_ != NULL
|
|
|
|
// Check for --section-start.
|
|
|
|
&& parameters->options().section_start(this->output_section_->name(),
|
|
|
|
&address))
|
|
|
|
;
|
|
|
|
else if (this->address_ == NULL)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2015-08-26 09:03:04 +02:00
|
|
|
vma_region = script_sections->find_memory_region(this, true, false, NULL);
|
2010-10-06 10:58:59 +02:00
|
|
|
if (vma_region != NULL)
|
|
|
|
address = vma_region->get_current_address()->eval(symtab, layout,
|
|
|
|
false);
|
2010-05-26 17:15:05 +02:00
|
|
|
else
|
2010-10-06 10:58:59 +02:00
|
|
|
address = *dot_value;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
2010-10-06 10:58:59 +02:00
|
|
|
else
|
2015-08-26 09:03:04 +02:00
|
|
|
{
|
|
|
|
vma_region = script_sections->find_memory_region(this, true, true, NULL);
|
|
|
|
address = this->address_->eval_with_dot(symtab, layout, true,
|
|
|
|
*dot_value, NULL, NULL,
|
|
|
|
dot_alignment, false);
|
|
|
|
if (vma_region != NULL)
|
|
|
|
vma_region->set_address(address, symtab, layout);
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
uint64_t align;
|
|
|
|
if (this->align_ == NULL)
|
|
|
|
{
|
|
|
|
if (this->output_section_ == NULL)
|
|
|
|
align = 0;
|
|
|
|
else
|
|
|
|
align = this->output_section_->addralign();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section* align_section;
|
2008-02-28 05:45:47 +01:00
|
|
|
align = this->align_->eval_with_dot(symtab, layout, true, *dot_value,
|
2011-10-31 23:51:03 +01:00
|
|
|
NULL, &align_section, NULL, false);
|
2008-02-09 02:22:17 +01:00
|
|
|
if (align_section != NULL)
|
|
|
|
gold_warning(_("alignment of section %s is not absolute"),
|
|
|
|
this->name_.c_str());
|
2008-02-04 06:43:05 +01:00
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
this->output_section_->set_addralign(align);
|
|
|
|
}
|
|
|
|
|
Fix problems with bss handling in linker scripts.
PR 16711 noted that gold allocates file space for BSS sections when using
a linker script. I've fixed that by rewriting set_section_addresses and
set_section_list_addresses to track the file offset separate from the
current virtual address, so that BSS sections do not move the file offset.
Now, if a series of BSS sections come at the end of a segment, we do not
allocate file space; but if a script forces them into the middle of a
segment, we will still allocate file space (matching Gnu ld behavior).
I've also added a warning when that happens.
That exposed another problem where orphan .bss sections were sometimes
placed in the middle of a segment. For example, if the script mentions
the .got section, but both .data and .bss are orphans, gold would put
both .data and .bss in front of .got. I've fixed that by ensuring that
orphan BSS sections are always placed after all other allocated sections.
It also exposed a problem where the SUBALIGN property is not handled
properly. The ld manual clearly states that it should override input section
alignment, whether greater or less than the given alignment, but gold would
only increase an input section's alignment. Gold would also place the output
section based on its original alignment before the SUBALIGN property took
effect, leading to a misaligned output section (where the input section
was properly aligned in memory, but was not aligned relative to the start
of the section), in violation of the ELF/gABI spec. I've fixed that by
making sure that the SUBALIGN property overrides the internal alignment of
the input sections as well as the external alignment of the output section.
This affected the behavior of script_test_2, which was written to expect
a misaligned section.
The net effect is, I think, improved compatibility with the BFD linker.
There are still cases where orphan placement differs, but the differences
should be rarer and less important. ALIGN and SUBALIGN behavior is closer,
but still not an exact match -- I still found cases where ld would create
a misaligned output section, and where gold will properly align it.
gold/
PR gold/16711
* output.cc (Output_section::set_final_data_size): Calculate data size
based on relative offset rather than file offset.
(Output_segment::set_section_addresses): Track file offset separately
from address offset.
(Output_segment::set_section_list_addresses): Add pfoff parameter.
Track file offset separately. Don't move file offset for BSS
sections.
* output.h (Output_segment::set_section_list_addresses): Add pfoff
parameter.
* script-sections.cc (Orphan_section_placement): Add PLACE_LAST_ALLOC.
(Orphan_section_placement::Orphan_section_placement): Initialize it.
(Orphan_section_placement::output_section_init): Track last allocated
section.
(Orphan_section_placement::find_place): Place BSS after last allocated
section.
(Output_section_element_input::set_section_addresses): Always override
input section alignment when SUBALIGN is specified.
(Output_section_definition::set_section_addresses): Override alignment
of output section when SUBALIGN is specified.
* testsuite/Makefile.am (script_test_15a, script_test_15b)
(script_test_15c): New test cases.
* testsuite/Makefile.in: Regenerate.
* testsuite/script_test_2.cc: Adjust expected layout.
* testsuite/script_test_15.c: New source file.
* testsuite/script_test_15a.sh: New shell script.
* testsuite/script_test_15a.t: New linker script.
* testsuite/script_test_15b.sh: New shell script.
* testsuite/script_test_15b.t: New linker script.
* testsuite/script_test_15c.sh: New shell script.
* testsuite/script_test_15c.t: New linker script.
2016-12-12 02:31:25 +01:00
|
|
|
uint64_t subalign;
|
|
|
|
if (this->subalign_ == NULL)
|
|
|
|
subalign = 0;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Output_section* subalign_section;
|
|
|
|
subalign = this->subalign_->eval_with_dot(symtab, layout, true,
|
|
|
|
*dot_value, NULL,
|
|
|
|
&subalign_section, NULL,
|
|
|
|
false);
|
|
|
|
if (subalign_section != NULL)
|
|
|
|
gold_warning(_("subalign of section %s is not absolute"),
|
|
|
|
this->name_.c_str());
|
|
|
|
|
|
|
|
// Reserve a value of 0 to mean there is no SUBALIGN property.
|
|
|
|
if (subalign == 0)
|
|
|
|
subalign = 1;
|
|
|
|
|
|
|
|
// The external alignment of the output section must be at least
|
|
|
|
// as large as that of the input sections. If there is no
|
|
|
|
// explicit ALIGN property, we set the output section alignment
|
|
|
|
// to match the input section alignment.
|
|
|
|
if (align < subalign || this->align_ == NULL)
|
|
|
|
{
|
|
|
|
align = subalign;
|
|
|
|
this->output_section_->set_addralign(align);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
address = align_address(address, align);
|
|
|
|
|
2008-02-14 03:34:22 +01:00
|
|
|
uint64_t start_address = address;
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
*dot_value = address;
|
|
|
|
|
2010-04-09 19:32:58 +02:00
|
|
|
// Except for NOLOAD sections, the address of non-SHF_ALLOC sections is
|
|
|
|
// forced to zero, regardless of what the linker script wants.
|
2008-02-04 06:43:05 +01:00
|
|
|
if (this->output_section_ != NULL
|
2010-04-09 19:32:58 +02:00
|
|
|
&& ((this->output_section_->flags() & elfcpp::SHF_ALLOC) != 0
|
|
|
|
|| this->output_section_->is_noload()))
|
2008-02-04 06:43:05 +01:00
|
|
|
this->output_section_->set_address(address);
|
|
|
|
|
2008-02-29 01:04:06 +01:00
|
|
|
this->evaluated_address_ = address;
|
|
|
|
this->evaluated_addralign_ = align;
|
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
uint64_t laddr;
|
|
|
|
|
2008-02-29 01:04:06 +01:00
|
|
|
if (this->load_address_ == NULL)
|
2010-10-06 10:58:59 +02:00
|
|
|
{
|
|
|
|
Output_section_definition* previous_section;
|
|
|
|
|
|
|
|
// Determine if an LMA region has been set for this section.
|
2015-08-26 09:03:04 +02:00
|
|
|
lma_region = script_sections->find_memory_region(this, false, false,
|
2010-10-06 10:58:59 +02:00
|
|
|
&previous_section);
|
|
|
|
|
|
|
|
if (lma_region != NULL)
|
|
|
|
{
|
|
|
|
if (previous_section == NULL)
|
|
|
|
// The LMA address was explicitly set to the given region.
|
|
|
|
laddr = lma_region->get_current_address()->eval(symtab, layout,
|
|
|
|
false);
|
2016-08-12 18:55:25 +02:00
|
|
|
else
|
2010-10-06 10:58:59 +02:00
|
|
|
{
|
|
|
|
// We are not going to use the discovered lma_region, so
|
|
|
|
// make sure that we do not update it in the code below.
|
|
|
|
lma_region = NULL;
|
|
|
|
|
|
|
|
if (this->address_ != NULL || previous_section == this)
|
|
|
|
{
|
|
|
|
// Either an explicit VMA address has been set, or an
|
|
|
|
// explicit VMA region has been set, so set the LMA equal to
|
|
|
|
// the VMA.
|
|
|
|
laddr = address;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// The LMA address was not explicitly or implicitly set.
|
|
|
|
//
|
|
|
|
// We have been given the first memory region that is
|
|
|
|
// compatible with the current section and a pointer to the
|
|
|
|
// last section to use this region. Set the LMA of this
|
|
|
|
// section so that the difference between its' VMA and LMA
|
|
|
|
// is the same as the difference between the VMA and LMA of
|
|
|
|
// the last section in the given region.
|
|
|
|
laddr = address + (previous_section->evaluated_load_address_
|
|
|
|
- previous_section->evaluated_address_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
this->output_section_->set_load_address(laddr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Do not set the load address of the output section, if one exists.
|
|
|
|
// This allows future sections to determine what the load address
|
|
|
|
// should be. If none is ever set, it will default to being the
|
|
|
|
// same as the vma address.
|
|
|
|
laddr = address;
|
|
|
|
}
|
|
|
|
}
|
2008-02-29 01:04:06 +01:00
|
|
|
else
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2010-10-06 10:58:59 +02:00
|
|
|
laddr = this->load_address_->eval_with_dot(symtab, layout, true,
|
|
|
|
*dot_value,
|
|
|
|
this->output_section_,
|
2011-10-31 23:51:03 +01:00
|
|
|
NULL, NULL, false);
|
2008-02-29 01:04:06 +01:00
|
|
|
if (this->output_section_ != NULL)
|
2009-06-24 21:00:15 +02:00
|
|
|
this->output_section_->set_load_address(laddr);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
this->evaluated_load_address_ = laddr;
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
std::string fill;
|
|
|
|
if (this->fill_ != NULL)
|
|
|
|
{
|
|
|
|
// FIXME: The GNU linker supports fill values of arbitrary
|
|
|
|
// length.
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section* fill_section;
|
2008-02-28 05:45:47 +01:00
|
|
|
uint64_t fill_val = this->fill_->eval_with_dot(symtab, layout, true,
|
2008-02-04 06:43:05 +01:00
|
|
|
*dot_value,
|
2010-04-23 06:47:33 +02:00
|
|
|
NULL, &fill_section,
|
2011-10-31 23:51:03 +01:00
|
|
|
NULL, false);
|
2008-02-09 02:22:17 +01:00
|
|
|
if (fill_section != NULL)
|
|
|
|
gold_warning(_("fill of section %s is not absolute"),
|
|
|
|
this->name_.c_str());
|
2008-02-04 06:43:05 +01:00
|
|
|
unsigned char fill_buff[4];
|
|
|
|
elfcpp::Swap_unaligned<32, true>::writeval(fill_buff, fill_val);
|
|
|
|
fill.assign(reinterpret_cast<char*>(fill_buff), 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
Input_section_list input_sections;
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
{
|
|
|
|
// Get the list of input sections attached to this output
|
|
|
|
// section. This will leave the output section with only
|
|
|
|
// Output_section_data entries.
|
|
|
|
address += this->output_section_->get_input_sections(address,
|
|
|
|
fill,
|
|
|
|
&input_sections);
|
|
|
|
*dot_value = address;
|
|
|
|
}
|
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section* dot_section = this->output_section_;
|
2008-02-04 06:43:05 +01:00
|
|
|
for (Output_section_elements::iterator p = this->elements_.begin();
|
|
|
|
p != this->elements_.end();
|
|
|
|
++p)
|
|
|
|
(*p)->set_section_addresses(symtab, layout, this->output_section_,
|
2010-04-23 06:47:33 +02:00
|
|
|
subalign, dot_value, dot_alignment,
|
|
|
|
&dot_section, &fill, &input_sections);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
gold_assert(input_sections.empty());
|
2008-02-14 03:34:22 +01:00
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
if (vma_region != NULL)
|
|
|
|
{
|
|
|
|
// Update the VMA region being used by the section now that we know how
|
|
|
|
// big it is. Use the current address in the region, rather than
|
|
|
|
// start_address because that might have been aligned upwards and we
|
|
|
|
// need to allow for the padding.
|
|
|
|
Expression* addr = vma_region->get_current_address();
|
|
|
|
uint64_t size = *dot_value - addr->eval(symtab, layout, false);
|
|
|
|
|
|
|
|
vma_region->increment_offset(this->get_section_name(), size,
|
|
|
|
symtab, layout);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the LMA region is different from the VMA region, then increment the
|
|
|
|
// offset there as well. Note that we use the same "dot_value -
|
|
|
|
// start_address" formula that is used in the load_address assignment below.
|
|
|
|
if (lma_region != NULL && lma_region != vma_region)
|
|
|
|
lma_region->increment_offset(this->get_section_name(),
|
|
|
|
*dot_value - start_address,
|
|
|
|
symtab, layout);
|
|
|
|
|
|
|
|
// Compute the load address for the following section.
|
|
|
|
if (this->output_section_ == NULL)
|
2008-02-14 03:34:22 +01:00
|
|
|
*load_address = *dot_value;
|
2010-10-06 10:58:59 +02:00
|
|
|
else if (this->load_address_ == NULL)
|
|
|
|
{
|
|
|
|
if (lma_region == NULL)
|
|
|
|
*load_address = *dot_value;
|
|
|
|
else
|
|
|
|
*load_address =
|
|
|
|
lma_region->get_current_address()->eval(symtab, layout, false);
|
|
|
|
}
|
2008-02-14 03:34:22 +01:00
|
|
|
else
|
|
|
|
*load_address = (this->output_section_->load_address()
|
|
|
|
+ (*dot_value - start_address));
|
2008-08-13 09:37:46 +02:00
|
|
|
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
{
|
|
|
|
if (this->is_relro_)
|
|
|
|
this->output_section_->set_is_relro();
|
|
|
|
else
|
|
|
|
this->output_section_->clear_is_relro();
|
2010-04-09 19:32:58 +02:00
|
|
|
|
|
|
|
// If this is a NOLOAD section, keep dot and load address unchanged.
|
|
|
|
if (this->output_section_->is_noload())
|
|
|
|
{
|
|
|
|
*dot_value = old_dot_value;
|
|
|
|
*load_address = old_load_address;
|
|
|
|
}
|
2008-08-13 09:37:46 +02:00
|
|
|
}
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2008-02-04 07:45:50 +01:00
|
|
|
// Check a constraint (ONLY_IF_RO, etc.) on an output section. If
|
|
|
|
// this section is constrained, and the input sections do not match,
|
|
|
|
// return the constraint, and set *POSD.
|
|
|
|
|
|
|
|
Section_constraint
|
|
|
|
Output_section_definition::check_constraint(Output_section_definition** posd)
|
|
|
|
{
|
|
|
|
switch (this->constraint_)
|
|
|
|
{
|
|
|
|
case CONSTRAINT_NONE:
|
|
|
|
return CONSTRAINT_NONE;
|
|
|
|
|
|
|
|
case CONSTRAINT_ONLY_IF_RO:
|
|
|
|
if (this->output_section_ != NULL
|
|
|
|
&& (this->output_section_->flags() & elfcpp::SHF_WRITE) != 0)
|
|
|
|
{
|
|
|
|
*posd = this;
|
|
|
|
return CONSTRAINT_ONLY_IF_RO;
|
|
|
|
}
|
|
|
|
return CONSTRAINT_NONE;
|
|
|
|
|
|
|
|
case CONSTRAINT_ONLY_IF_RW:
|
|
|
|
if (this->output_section_ != NULL
|
|
|
|
&& (this->output_section_->flags() & elfcpp::SHF_WRITE) == 0)
|
|
|
|
{
|
|
|
|
*posd = this;
|
|
|
|
return CONSTRAINT_ONLY_IF_RW;
|
|
|
|
}
|
|
|
|
return CONSTRAINT_NONE;
|
|
|
|
|
|
|
|
case CONSTRAINT_SPECIAL:
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
gold_error(_("SPECIAL constraints are not implemented"));
|
|
|
|
return CONSTRAINT_NONE;
|
|
|
|
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// See if this is the alternate output section for a constrained
|
|
|
|
// output section. If it is, transfer the Output_section and return
|
|
|
|
// true. Otherwise return false.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Output_section_definition::alternate_constraint(
|
|
|
|
Output_section_definition* posd,
|
|
|
|
Section_constraint constraint)
|
|
|
|
{
|
|
|
|
if (this->name_ != posd->name_)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
switch (constraint)
|
|
|
|
{
|
|
|
|
case CONSTRAINT_ONLY_IF_RO:
|
|
|
|
if (this->constraint_ != CONSTRAINT_ONLY_IF_RW)
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CONSTRAINT_ONLY_IF_RW:
|
|
|
|
if (this->constraint_ != CONSTRAINT_ONLY_IF_RO)
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
|
|
|
|
// We have found the alternate constraint. We just need to move
|
|
|
|
// over the Output_section. When constraints are used properly,
|
|
|
|
// THIS should not have an output_section pointer, as all the input
|
|
|
|
// sections should have matched the other definition.
|
|
|
|
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
gold_error(_("mismatched definition for constrained sections"));
|
|
|
|
|
|
|
|
this->output_section_ = posd->output_section_;
|
|
|
|
posd->output_section_ = NULL;
|
|
|
|
|
2008-08-13 09:37:46 +02:00
|
|
|
if (this->is_relro_)
|
|
|
|
this->output_section_->set_is_relro();
|
|
|
|
else
|
|
|
|
this->output_section_->clear_is_relro();
|
|
|
|
|
2008-02-04 07:45:50 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// Get the list of segments to use for an allocated section when using
|
2008-04-10 03:02:46 +02:00
|
|
|
// a PHDRS clause.
|
2008-02-04 23:54:31 +01:00
|
|
|
|
|
|
|
Output_section*
|
2008-04-10 03:02:46 +02:00
|
|
|
Output_section_definition::allocate_to_segment(String_list** phdrs_list,
|
|
|
|
bool* orphan)
|
2008-02-04 23:54:31 +01:00
|
|
|
{
|
2010-05-19 19:49:19 +02:00
|
|
|
// Update phdrs_list even if we don't have an output section. It
|
|
|
|
// might be used by the following sections.
|
|
|
|
if (this->phdrs_ != NULL)
|
|
|
|
*phdrs_list = this->phdrs_;
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
if (this->output_section_ == NULL)
|
|
|
|
return NULL;
|
|
|
|
if ((this->output_section_->flags() & elfcpp::SHF_ALLOC) == 0)
|
|
|
|
return NULL;
|
2008-04-10 03:02:46 +02:00
|
|
|
*orphan = false;
|
2008-02-04 23:54:31 +01:00
|
|
|
return this->output_section_;
|
|
|
|
}
|
|
|
|
|
2008-02-29 01:04:06 +01:00
|
|
|
// Look for an output section by name and return the address, the load
|
|
|
|
// address, the alignment, and the size. This is used when an
|
|
|
|
// expression refers to an output section which was not actually
|
|
|
|
// created. This returns true if the section was found, false
|
|
|
|
// otherwise.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Output_section_definition::get_output_section_info(const char* name,
|
|
|
|
uint64_t* address,
|
|
|
|
uint64_t* load_address,
|
2009-12-14 20:53:05 +01:00
|
|
|
uint64_t* addralign,
|
2008-02-29 01:04:06 +01:00
|
|
|
uint64_t* size) const
|
|
|
|
{
|
|
|
|
if (this->name_ != name)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
{
|
|
|
|
*address = this->output_section_->address();
|
|
|
|
if (this->output_section_->has_load_address())
|
|
|
|
*load_address = this->output_section_->load_address();
|
|
|
|
else
|
|
|
|
*load_address = *address;
|
2009-12-14 20:53:05 +01:00
|
|
|
*addralign = this->output_section_->addralign();
|
2008-02-29 01:04:06 +01:00
|
|
|
*size = this->output_section_->current_data_size();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*address = this->evaluated_address_;
|
|
|
|
*load_address = this->evaluated_load_address_;
|
2009-12-14 20:53:05 +01:00
|
|
|
*addralign = this->evaluated_addralign_;
|
2008-02-29 01:04:06 +01:00
|
|
|
*size = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// Print for debugging.
|
|
|
|
|
|
|
|
void
|
|
|
|
Output_section_definition::print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " %s ", this->name_.c_str());
|
|
|
|
|
|
|
|
if (this->address_ != NULL)
|
|
|
|
{
|
|
|
|
this->address_->print(f);
|
|
|
|
fprintf(f, " ");
|
|
|
|
}
|
|
|
|
|
2010-04-09 19:32:58 +02:00
|
|
|
if (this->script_section_type_ != SCRIPT_SECTION_TYPE_NONE)
|
|
|
|
fprintf(f, "(%s) ",
|
|
|
|
this->script_section_type_name(this->script_section_type_));
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
fprintf(f, ": ");
|
|
|
|
|
|
|
|
if (this->load_address_ != NULL)
|
|
|
|
{
|
|
|
|
fprintf(f, "AT(");
|
|
|
|
this->load_address_->print(f);
|
|
|
|
fprintf(f, ") ");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (this->align_ != NULL)
|
|
|
|
{
|
|
|
|
fprintf(f, "ALIGN(");
|
|
|
|
this->align_->print(f);
|
|
|
|
fprintf(f, ") ");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (this->subalign_ != NULL)
|
|
|
|
{
|
|
|
|
fprintf(f, "SUBALIGN(");
|
|
|
|
this->subalign_->print(f);
|
|
|
|
fprintf(f, ") ");
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(f, "{\n");
|
|
|
|
|
|
|
|
for (Output_section_elements::const_iterator p = this->elements_.begin();
|
|
|
|
p != this->elements_.end();
|
|
|
|
++p)
|
|
|
|
(*p)->print(f);
|
|
|
|
|
|
|
|
fprintf(f, " }");
|
|
|
|
|
|
|
|
if (this->fill_ != NULL)
|
|
|
|
{
|
|
|
|
fprintf(f, " = ");
|
|
|
|
this->fill_->print(f);
|
|
|
|
}
|
|
|
|
|
2008-02-05 00:53:15 +01:00
|
|
|
if (this->phdrs_ != NULL)
|
|
|
|
{
|
|
|
|
for (String_list::const_iterator p = this->phdrs_->begin();
|
|
|
|
p != this->phdrs_->end();
|
|
|
|
++p)
|
|
|
|
fprintf(f, " :%s", p->c_str());
|
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
fprintf(f, "\n");
|
|
|
|
}
|
|
|
|
|
2010-04-09 19:32:58 +02:00
|
|
|
Script_sections::Section_type
|
|
|
|
Output_section_definition::section_type() const
|
|
|
|
{
|
|
|
|
switch (this->script_section_type_)
|
|
|
|
{
|
|
|
|
case SCRIPT_SECTION_TYPE_NONE:
|
|
|
|
return Script_sections::ST_NONE;
|
|
|
|
case SCRIPT_SECTION_TYPE_NOLOAD:
|
|
|
|
return Script_sections::ST_NOLOAD;
|
|
|
|
case SCRIPT_SECTION_TYPE_COPY:
|
|
|
|
case SCRIPT_SECTION_TYPE_DSECT:
|
|
|
|
case SCRIPT_SECTION_TYPE_INFO:
|
|
|
|
case SCRIPT_SECTION_TYPE_OVERLAY:
|
|
|
|
// There are not really support so we treat them as ST_NONE. The
|
|
|
|
// parse should have issued errors for them already.
|
|
|
|
return Script_sections::ST_NONE;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the name of a script section type.
|
|
|
|
|
|
|
|
const char*
|
2010-08-25 10:36:54 +02:00
|
|
|
Output_section_definition::script_section_type_name(
|
2010-04-09 19:32:58 +02:00
|
|
|
Script_section_type script_section_type)
|
|
|
|
{
|
|
|
|
switch (script_section_type)
|
|
|
|
{
|
|
|
|
case SCRIPT_SECTION_TYPE_NONE:
|
|
|
|
return "NONE";
|
|
|
|
case SCRIPT_SECTION_TYPE_NOLOAD:
|
|
|
|
return "NOLOAD";
|
|
|
|
case SCRIPT_SECTION_TYPE_DSECT:
|
|
|
|
return "DSECT";
|
|
|
|
case SCRIPT_SECTION_TYPE_COPY:
|
|
|
|
return "COPY";
|
|
|
|
case SCRIPT_SECTION_TYPE_INFO:
|
|
|
|
return "INFO";
|
|
|
|
case SCRIPT_SECTION_TYPE_OVERLAY:
|
|
|
|
return "OVERLAY";
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
void
|
|
|
|
Output_section_definition::set_memory_region(Memory_region* mr, bool set_vma)
|
|
|
|
{
|
|
|
|
gold_assert(mr != NULL);
|
|
|
|
// Add the current section to the specified region's list.
|
|
|
|
mr->add_section(this, set_vma);
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// An output section created to hold orphaned input sections. These
|
|
|
|
// do not actually appear in linker scripts. However, for convenience
|
|
|
|
// when setting the output section addresses, we put a marker to these
|
|
|
|
// sections in the appropriate place in the list of SECTIONS elements.
|
|
|
|
|
|
|
|
class Orphan_output_section : public Sections_element
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Orphan_output_section(Output_section* os)
|
|
|
|
: os_(os)
|
|
|
|
{ }
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
// Return whether the orphan output section is relro. We can just
|
|
|
|
// check the output section because we always set the flag, if
|
|
|
|
// needed, just after we create the Orphan_output_section.
|
2008-02-04 06:43:05 +01:00
|
|
|
bool
|
2009-03-19 06:51:49 +01:00
|
|
|
is_relro() const
|
|
|
|
{ return this->os_->is_relro(); }
|
|
|
|
|
|
|
|
// Initialize OSP with an output section. This should have been
|
|
|
|
// done already.
|
|
|
|
void
|
|
|
|
orphan_section_init(Orphan_section_placement*,
|
|
|
|
Script_sections::Elements_iterator)
|
|
|
|
{ gold_unreachable(); }
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Set section addresses.
|
|
|
|
void
|
2010-04-23 06:47:33 +02:00
|
|
|
set_section_addresses(Symbol_table*, Layout*, uint64_t*, uint64_t*,
|
|
|
|
uint64_t*);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// Get the list of segments to use for an allocated section when
|
2008-04-10 03:02:46 +02:00
|
|
|
// using a PHDRS clause.
|
2008-02-04 23:54:31 +01:00
|
|
|
Output_section*
|
2008-04-10 03:02:46 +02:00
|
|
|
allocate_to_segment(String_list**, bool*);
|
2008-02-04 23:54:31 +01:00
|
|
|
|
2008-08-13 09:37:46 +02:00
|
|
|
// Return the associated Output_section.
|
|
|
|
Output_section*
|
|
|
|
get_output_section() const
|
|
|
|
{ return this->os_; }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Print for debugging.
|
|
|
|
void
|
|
|
|
print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " marker for orphaned output section %s\n",
|
|
|
|
this->os_->name());
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Output_section* os_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Set section addresses.
|
|
|
|
|
|
|
|
void
|
|
|
|
Orphan_output_section::set_section_addresses(Symbol_table*, Layout*,
|
2008-02-14 03:34:22 +01:00
|
|
|
uint64_t* dot_value,
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t*,
|
2008-02-14 03:34:22 +01:00
|
|
|
uint64_t* load_address)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2010-05-19 09:09:36 +02:00
|
|
|
typedef std::list<Output_section::Input_section> Input_section_list;
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-02-14 03:34:22 +01:00
|
|
|
bool have_load_address = *load_address != *dot_value;
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
uint64_t address = *dot_value;
|
|
|
|
address = align_address(address, this->os_->addralign());
|
|
|
|
|
2013-01-10 01:18:15 +01:00
|
|
|
// If input section sorting is requested via --section-ordering-file or
|
2016-08-12 18:55:25 +02:00
|
|
|
// linker plugins, then do it here. This is important because we want
|
2013-01-10 01:18:15 +01:00
|
|
|
// any sorting specified in the linker scripts, which will be done after
|
2016-08-12 18:55:25 +02:00
|
|
|
// this, to take precedence. The final order of input sections is then
|
2013-01-10 01:18:15 +01:00
|
|
|
// guaranteed to be according to the linker script specification.
|
|
|
|
if (this->os_ != NULL
|
|
|
|
&& this->os_->input_section_order_specified())
|
|
|
|
this->os_->sort_attached_input_sections();
|
|
|
|
|
2011-06-09 21:25:02 +02:00
|
|
|
// For a relocatable link, all orphan sections are put at
|
|
|
|
// address 0. In general we expect all sections to be at
|
|
|
|
// address 0 for a relocatable link, but we permit the linker
|
|
|
|
// script to override that for specific output sections.
|
|
|
|
if (parameters->options().relocatable())
|
|
|
|
{
|
|
|
|
address = 0;
|
|
|
|
*load_address = 0;
|
|
|
|
have_load_address = false;
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
if ((this->os_->flags() & elfcpp::SHF_ALLOC) != 0)
|
2008-02-14 03:34:22 +01:00
|
|
|
{
|
|
|
|
this->os_->set_address(address);
|
|
|
|
if (have_load_address)
|
|
|
|
this->os_->set_load_address(align_address(*load_address,
|
|
|
|
this->os_->addralign()));
|
|
|
|
}
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
Input_section_list input_sections;
|
|
|
|
address += this->os_->get_input_sections(address, "", &input_sections);
|
|
|
|
|
|
|
|
for (Input_section_list::iterator p = input_sections.begin();
|
|
|
|
p != input_sections.end();
|
|
|
|
++p)
|
|
|
|
{
|
2010-05-19 09:09:36 +02:00
|
|
|
uint64_t addralign = p->addralign();
|
|
|
|
if (!p->is_input_section())
|
2016-08-12 18:55:25 +02:00
|
|
|
p->output_section_data()->finalize_data_size();
|
2010-05-19 09:09:36 +02:00
|
|
|
uint64_t size = p->data_size();
|
2009-12-14 20:53:05 +01:00
|
|
|
address = align_address(address, addralign);
|
2010-05-19 09:09:36 +02:00
|
|
|
this->os_->add_script_input_section(*p);
|
2008-02-04 06:43:05 +01:00
|
|
|
address += size;
|
|
|
|
}
|
|
|
|
|
2013-04-15 18:37:30 +02:00
|
|
|
if (parameters->options().relocatable())
|
|
|
|
{
|
|
|
|
// For a relocatable link, reset DOT_VALUE to 0.
|
|
|
|
*dot_value = 0;
|
|
|
|
*load_address = 0;
|
|
|
|
}
|
|
|
|
else if (this->os_ == NULL
|
|
|
|
|| (this->os_->flags() & elfcpp::SHF_TLS) == 0
|
|
|
|
|| this->os_->type() != elfcpp::SHT_NOBITS)
|
2009-10-16 07:00:29 +02:00
|
|
|
{
|
2013-04-15 18:37:30 +02:00
|
|
|
// An SHF_TLS/SHT_NOBITS section does not take up any address space.
|
2009-10-16 07:00:29 +02:00
|
|
|
if (!have_load_address)
|
|
|
|
*load_address = address;
|
|
|
|
else
|
|
|
|
*load_address += address - *dot_value;
|
2008-02-14 03:34:22 +01:00
|
|
|
|
2009-10-16 07:00:29 +02:00
|
|
|
*dot_value = address;
|
|
|
|
}
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// Get the list of segments to use for an allocated section when using
|
|
|
|
// a PHDRS clause. If this is an allocated section, return the
|
|
|
|
// Output_section. We don't change the list of segments.
|
|
|
|
|
|
|
|
Output_section*
|
2008-04-10 03:02:46 +02:00
|
|
|
Orphan_output_section::allocate_to_segment(String_list**, bool* orphan)
|
2008-02-04 23:54:31 +01:00
|
|
|
{
|
|
|
|
if ((this->os_->flags() & elfcpp::SHF_ALLOC) == 0)
|
|
|
|
return NULL;
|
2008-04-10 03:02:46 +02:00
|
|
|
*orphan = true;
|
2008-02-04 23:54:31 +01:00
|
|
|
return this->os_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Class Phdrs_element. A program header from a PHDRS clause.
|
|
|
|
|
|
|
|
class Phdrs_element
|
|
|
|
{
|
|
|
|
public:
|
2009-12-14 20:53:05 +01:00
|
|
|
Phdrs_element(const char* name, size_t namelen, unsigned int type,
|
|
|
|
bool includes_filehdr, bool includes_phdrs,
|
2008-02-04 23:54:31 +01:00
|
|
|
bool is_flags_valid, unsigned int flags,
|
2009-12-14 20:53:05 +01:00
|
|
|
Expression* load_address)
|
|
|
|
: name_(name, namelen), type_(type), includes_filehdr_(includes_filehdr),
|
|
|
|
includes_phdrs_(includes_phdrs), is_flags_valid_(is_flags_valid),
|
|
|
|
flags_(flags), load_address_(load_address), load_address_value_(0),
|
2008-02-04 23:54:31 +01:00
|
|
|
segment_(NULL)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
// Return the name of this segment.
|
|
|
|
const std::string&
|
|
|
|
name() const
|
|
|
|
{ return this->name_; }
|
|
|
|
|
|
|
|
// Return the type of the segment.
|
|
|
|
unsigned int
|
|
|
|
type() const
|
|
|
|
{ return this->type_; }
|
|
|
|
|
|
|
|
// Whether to include the file header.
|
|
|
|
bool
|
|
|
|
includes_filehdr() const
|
|
|
|
{ return this->includes_filehdr_; }
|
|
|
|
|
|
|
|
// Whether to include the program headers.
|
|
|
|
bool
|
|
|
|
includes_phdrs() const
|
|
|
|
{ return this->includes_phdrs_; }
|
|
|
|
|
|
|
|
// Return whether there is a load address.
|
|
|
|
bool
|
|
|
|
has_load_address() const
|
|
|
|
{ return this->load_address_ != NULL; }
|
|
|
|
|
|
|
|
// Evaluate the load address expression if there is one.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
eval_load_address(Symbol_table* symtab, Layout* layout)
|
2008-02-04 23:54:31 +01:00
|
|
|
{
|
|
|
|
if (this->load_address_ != NULL)
|
2009-12-14 20:53:05 +01:00
|
|
|
this->load_address_value_ = this->load_address_->eval(symtab, layout,
|
2008-02-28 05:45:47 +01:00
|
|
|
true);
|
2008-02-04 23:54:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return the load address.
|
|
|
|
uint64_t
|
|
|
|
load_address() const
|
|
|
|
{
|
|
|
|
gold_assert(this->load_address_ != NULL);
|
|
|
|
return this->load_address_value_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create the segment.
|
|
|
|
Output_segment*
|
|
|
|
create_segment(Layout* layout)
|
|
|
|
{
|
|
|
|
this->segment_ = layout->make_output_segment(this->type_, this->flags_);
|
|
|
|
return this->segment_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the segment.
|
|
|
|
Output_segment*
|
|
|
|
segment()
|
|
|
|
{ return this->segment_; }
|
|
|
|
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
// Release the segment.
|
|
|
|
void
|
|
|
|
release_segment()
|
|
|
|
{ this->segment_ = NULL; }
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// Set the segment flags if appropriate.
|
|
|
|
void
|
|
|
|
set_flags_if_valid()
|
|
|
|
{
|
|
|
|
if (this->is_flags_valid_)
|
|
|
|
this->segment_->set_flags(this->flags_);
|
|
|
|
}
|
|
|
|
|
2008-02-05 00:53:15 +01:00
|
|
|
// Print for debugging.
|
|
|
|
void
|
|
|
|
print(FILE*) const;
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
private:
|
|
|
|
// The name used in the script.
|
|
|
|
std::string name_;
|
|
|
|
// The type of the segment (PT_LOAD, etc.).
|
|
|
|
unsigned int type_;
|
|
|
|
// Whether this segment includes the file header.
|
|
|
|
bool includes_filehdr_;
|
|
|
|
// Whether this segment includes the section headers.
|
|
|
|
bool includes_phdrs_;
|
|
|
|
// Whether the flags were explicitly specified.
|
|
|
|
bool is_flags_valid_;
|
|
|
|
// The flags for this segment (PF_R, etc.) if specified.
|
|
|
|
unsigned int flags_;
|
|
|
|
// The expression for the load address for this segment. This may
|
|
|
|
// be NULL.
|
|
|
|
Expression* load_address_;
|
|
|
|
// The actual load address from evaluating the expression.
|
|
|
|
uint64_t load_address_value_;
|
|
|
|
// The segment itself.
|
|
|
|
Output_segment* segment_;
|
|
|
|
};
|
|
|
|
|
2008-02-05 00:53:15 +01:00
|
|
|
// Print for debugging.
|
|
|
|
|
|
|
|
void
|
|
|
|
Phdrs_element::print(FILE* f) const
|
|
|
|
{
|
|
|
|
fprintf(f, " %s 0x%x", this->name_.c_str(), this->type_);
|
|
|
|
if (this->includes_filehdr_)
|
|
|
|
fprintf(f, " FILEHDR");
|
|
|
|
if (this->includes_phdrs_)
|
|
|
|
fprintf(f, " PHDRS");
|
|
|
|
if (this->is_flags_valid_)
|
|
|
|
fprintf(f, " FLAGS(%u)", this->flags_);
|
|
|
|
if (this->load_address_ != NULL)
|
|
|
|
{
|
|
|
|
fprintf(f, " AT(");
|
|
|
|
this->load_address_->print(f);
|
|
|
|
fprintf(f, ")");
|
|
|
|
}
|
|
|
|
fprintf(f, ";\n");
|
|
|
|
}
|
|
|
|
|
2010-09-08 18:10:33 +02:00
|
|
|
// Add a memory region.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::add_memory_region(const char* name, size_t namelen,
|
|
|
|
unsigned int attributes,
|
|
|
|
Expression* start, Expression* length)
|
|
|
|
{
|
|
|
|
if (this->memory_regions_ == NULL)
|
|
|
|
this->memory_regions_ = new Memory_regions();
|
|
|
|
else if (this->find_memory_region(name, namelen))
|
|
|
|
{
|
2010-10-06 10:58:59 +02:00
|
|
|
gold_error(_("region '%.*s' already defined"), static_cast<int>(namelen),
|
2010-09-08 22:08:14 +02:00
|
|
|
name);
|
2010-09-08 18:10:33 +02:00
|
|
|
// FIXME: Add a GOLD extension to allow multiple regions with the same
|
|
|
|
// name. This would amount to a single region covering disjoint blocks
|
|
|
|
// of memory, which is useful for embedded devices.
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: Check the length and start values. Currently we allow
|
|
|
|
// non-constant expressions for these values, whereas LD does not.
|
|
|
|
|
|
|
|
// FIXME: Add a GOLD extension to allow NEGATIVE LENGTHS. This would
|
|
|
|
// describe a region that packs from the end address going down, rather
|
|
|
|
// than the start address going up. This would be useful for embedded
|
|
|
|
// devices.
|
|
|
|
|
|
|
|
this->memory_regions_->push_back(new Memory_region(name, namelen, attributes,
|
|
|
|
start, length));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find a memory region.
|
|
|
|
|
|
|
|
Memory_region*
|
|
|
|
Script_sections::find_memory_region(const char* name, size_t namelen)
|
|
|
|
{
|
|
|
|
if (this->memory_regions_ == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
for (Memory_regions::const_iterator m = this->memory_regions_->begin();
|
|
|
|
m != this->memory_regions_->end();
|
|
|
|
++m)
|
|
|
|
if ((*m)->name_match(name, namelen))
|
|
|
|
return *m;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find a memory region's origin.
|
|
|
|
|
|
|
|
Expression*
|
|
|
|
Script_sections::find_memory_region_origin(const char* name, size_t namelen)
|
|
|
|
{
|
|
|
|
Memory_region* mr = find_memory_region(name, namelen);
|
|
|
|
if (mr == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return mr->start_address();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find a memory region's length.
|
|
|
|
|
|
|
|
Expression*
|
|
|
|
Script_sections::find_memory_region_length(const char* name, size_t namelen)
|
|
|
|
{
|
|
|
|
Memory_region* mr = find_memory_region(name, namelen);
|
|
|
|
if (mr == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return mr->length();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the memory region to use for the current section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::set_memory_region(Memory_region* mr, bool set_vma)
|
|
|
|
{
|
|
|
|
gold_assert(!this->sections_elements_->empty());
|
|
|
|
this->sections_elements_->back()->set_memory_region(mr, set_vma);
|
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// Class Script_sections.
|
|
|
|
|
|
|
|
Script_sections::Script_sections()
|
|
|
|
: saw_sections_clause_(false),
|
|
|
|
in_sections_clause_(false),
|
|
|
|
sections_elements_(NULL),
|
2008-02-04 23:54:31 +01:00
|
|
|
output_section_(NULL),
|
2010-09-08 18:10:33 +02:00
|
|
|
memory_regions_(NULL),
|
2008-08-13 09:37:46 +02:00
|
|
|
phdrs_elements_(NULL),
|
2009-03-19 06:51:49 +01:00
|
|
|
orphan_section_placement_(NULL),
|
|
|
|
data_segment_align_start_(),
|
|
|
|
saw_data_segment_align_(false),
|
2009-10-16 Doug Kwan <dougkwan@google.com>
* expression.cc (class Segment_start_expression): New class definition.
(Segment_start_expression::value): New method definition.
(script_exp_function_segment_start): Return a new
Segment_start_expression.
* gold/script-c.h (script_saw_segment_start_expression): New function
prototype.
* script-sections.cc (Script_sections::Script_sections): Initialize
SAW_SEGMENT_START_EXPRESSION_ to false.
(Script_sections::set_section_addresses): Use -Ttext, -Tdata
and -Tbbs options to specify section addresses if given in
command line and no SEGMENT_START expression is seen in a script.
* script-sections.h (Script_sections::saw_segment_start_expression,
Script_sections::set_saw_segment_start_expression): New method
definition.
(Script_sections::saw_segment_start_expression_): New data member
declaration.
* script.cc (script_saw_segment_start_expression): New function.
* yyscript.y (SEGMENT_START): Call script_saw_segment_start_expression.
* testsuite/Makefile.am (check_SCRIPTS): Add script_test_6.sh,
script_test_7.sh and script_test_8.sh.
(check_DATA): Add script_test_6.stdout, script_test_7.stdout and
script_test_8.stdout.
(MOSTLYCLEANFILES): Add script_test_6, script_test_7 and script_test_8.
(script_test_6, script_test_6.stdout, script_test_7,
script_test_7.stdout, script_test_8, script_test_8.stdout): New rules.
* Makefile.in: Regenerate.
* testsuite/script_test_6.sh: New file.
* testsuite/script_test_6.t: Same.
* testsuite/script_test_7.sh: Same.
* testsuite/script_test_7.t: Same.
* testsuite/script_test_8.sh: Same.
2009-10-16 20:56:07 +02:00
|
|
|
saw_relro_end_(false),
|
2015-06-04 05:30:11 +02:00
|
|
|
saw_segment_start_expression_(false),
|
|
|
|
segments_created_(false)
|
2008-01-23 02:31:13 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
// Start a SECTIONS clause.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::start_sections()
|
|
|
|
{
|
|
|
|
gold_assert(!this->in_sections_clause_ && this->output_section_ == NULL);
|
|
|
|
this->saw_sections_clause_ = true;
|
|
|
|
this->in_sections_clause_ = true;
|
|
|
|
if (this->sections_elements_ == NULL)
|
|
|
|
this->sections_elements_ = new Sections_elements;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finish a SECTIONS clause.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::finish_sections()
|
|
|
|
{
|
|
|
|
gold_assert(this->in_sections_clause_ && this->output_section_ == NULL);
|
|
|
|
this->in_sections_clause_ = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a symbol to be defined.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::add_symbol_assignment(const char* name, size_t length,
|
|
|
|
Expression* val, bool provide,
|
|
|
|
bool hidden)
|
|
|
|
{
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
this->output_section_->add_symbol_assignment(name, length, val,
|
|
|
|
provide, hidden);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Sections_element* p = new Sections_element_assignment(name, length,
|
|
|
|
val, provide,
|
|
|
|
hidden);
|
|
|
|
this->sections_elements_->push_back(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Add an assignment to the special dot symbol.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::add_dot_assignment(Expression* val)
|
|
|
|
{
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
this->output_section_->add_dot_assignment(val);
|
|
|
|
else
|
|
|
|
{
|
2009-10-16 07:19:07 +02:00
|
|
|
// The GNU linker permits assignments to . to appears outside of
|
|
|
|
// a SECTIONS clause, and treats it as appearing inside, so
|
|
|
|
// sections_elements_ may be NULL here.
|
|
|
|
if (this->sections_elements_ == NULL)
|
|
|
|
{
|
|
|
|
this->sections_elements_ = new Sections_elements;
|
|
|
|
this->saw_sections_clause_ = true;
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
Sections_element* p = new Sections_element_dot_assignment(val);
|
|
|
|
this->sections_elements_->push_back(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// Add an assertion.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::add_assertion(Expression* check, const char* message,
|
|
|
|
size_t messagelen)
|
|
|
|
{
|
|
|
|
if (this->output_section_ != NULL)
|
|
|
|
this->output_section_->add_assertion(check, message, messagelen);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Sections_element* p = new Sections_element_assertion(check, message,
|
|
|
|
messagelen);
|
|
|
|
this->sections_elements_->push_back(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Start processing entries for an output section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::start_output_section(
|
|
|
|
const char* name,
|
|
|
|
size_t namelen,
|
2010-08-25 10:36:54 +02:00
|
|
|
const Parser_output_section_header* header)
|
2008-01-23 02:31:13 +01:00
|
|
|
{
|
|
|
|
Output_section_definition* posd = new Output_section_definition(name,
|
|
|
|
namelen,
|
|
|
|
header);
|
|
|
|
this->sections_elements_->push_back(posd);
|
|
|
|
gold_assert(this->output_section_ == NULL);
|
|
|
|
this->output_section_ = posd;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Stop processing entries for an output section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::finish_output_section(
|
|
|
|
const Parser_output_section_trailer* trailer)
|
|
|
|
{
|
|
|
|
gold_assert(this->output_section_ != NULL);
|
|
|
|
this->output_section_->finish(trailer);
|
|
|
|
this->output_section_ = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a data item to the current output section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::add_data(int size, bool is_signed, Expression* val)
|
|
|
|
{
|
|
|
|
gold_assert(this->output_section_ != NULL);
|
|
|
|
this->output_section_->add_data(size, is_signed, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a fill value setting to the current output section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::add_fill(Expression* val)
|
|
|
|
{
|
|
|
|
gold_assert(this->output_section_ != NULL);
|
|
|
|
this->output_section_->add_fill(val);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add an input section specification to the current output section.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::add_input_section(const Input_section_spec* spec, bool keep)
|
|
|
|
{
|
|
|
|
gold_assert(this->output_section_ != NULL);
|
|
|
|
this->output_section_->add_input_section(spec, keep);
|
|
|
|
}
|
|
|
|
|
2008-08-13 09:37:46 +02:00
|
|
|
// This is called when we see DATA_SEGMENT_ALIGN. It means that any
|
|
|
|
// subsequent output sections may be relro.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::data_segment_align()
|
|
|
|
{
|
2009-03-19 06:51:49 +01:00
|
|
|
if (this->saw_data_segment_align_)
|
2008-08-13 09:37:46 +02:00
|
|
|
gold_error(_("DATA_SEGMENT_ALIGN may only appear once in a linker script"));
|
2009-03-19 06:51:49 +01:00
|
|
|
gold_assert(!this->sections_elements_->empty());
|
|
|
|
Sections_elements::iterator p = this->sections_elements_->end();
|
|
|
|
--p;
|
|
|
|
this->data_segment_align_start_ = p;
|
|
|
|
this->saw_data_segment_align_ = true;
|
2008-08-13 09:37:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// This is called when we see DATA_SEGMENT_RELRO_END. It means that
|
|
|
|
// any output sections seen since DATA_SEGMENT_ALIGN are relro.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::data_segment_relro_end()
|
|
|
|
{
|
|
|
|
if (this->saw_relro_end_)
|
|
|
|
gold_error(_("DATA_SEGMENT_RELRO_END may only appear once "
|
|
|
|
"in a linker script"));
|
|
|
|
this->saw_relro_end_ = true;
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
if (!this->saw_data_segment_align_)
|
2008-08-13 09:37:46 +02:00
|
|
|
gold_error(_("DATA_SEGMENT_RELRO_END must follow DATA_SEGMENT_ALIGN"));
|
|
|
|
else
|
|
|
|
{
|
2009-03-19 06:51:49 +01:00
|
|
|
Sections_elements::iterator p = this->data_segment_align_start_;
|
|
|
|
for (++p; p != this->sections_elements_->end(); ++p)
|
|
|
|
(*p)->set_is_relro();
|
2008-08-13 09:37:46 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-28 05:45:47 +01:00
|
|
|
// Create any required sections.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::create_sections(Layout* layout)
|
|
|
|
{
|
|
|
|
if (!this->saw_sections_clause_)
|
|
|
|
return;
|
|
|
|
for (Sections_elements::iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
|
|
|
(*p)->create_sections(layout);
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Add any symbols we are defining to the symbol table.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::add_symbols_to_table(Symbol_table* symtab)
|
|
|
|
{
|
|
|
|
if (!this->saw_sections_clause_)
|
|
|
|
return;
|
|
|
|
for (Sections_elements::iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
|
|
|
(*p)->add_symbols_to_table(symtab);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finalize symbols and check assertions.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::finalize_symbols(Symbol_table* symtab, const Layout* layout)
|
|
|
|
{
|
|
|
|
if (!this->saw_sections_clause_)
|
|
|
|
return;
|
|
|
|
uint64_t dot_value = 0;
|
|
|
|
for (Sections_elements::iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
2008-02-09 02:22:17 +01:00
|
|
|
(*p)->finalize_symbols(symtab, layout, &dot_value);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return the name of the output section to use for an input file name
|
|
|
|
// and section name.
|
|
|
|
|
|
|
|
const char*
|
2010-04-09 19:32:58 +02:00
|
|
|
Script_sections::output_section_name(
|
|
|
|
const char* file_name,
|
|
|
|
const char* section_name,
|
|
|
|
Output_section*** output_section_slot,
|
2012-08-14 10:31:57 +02:00
|
|
|
Script_sections::Section_type* psection_type,
|
2016-12-20 01:37:48 +01:00
|
|
|
bool* keep,
|
|
|
|
bool is_input_section)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
for (Sections_elements::const_iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
const char* ret = (*p)->output_section_name(file_name, section_name,
|
2010-04-09 19:32:58 +02:00
|
|
|
output_section_slot,
|
2016-12-20 01:37:48 +01:00
|
|
|
psection_type, keep,
|
|
|
|
is_input_section);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
if (ret != NULL)
|
|
|
|
{
|
|
|
|
// The special name /DISCARD/ means that the input section
|
|
|
|
// should be discarded.
|
|
|
|
if (strcmp(ret, "/DISCARD/") == 0)
|
|
|
|
{
|
|
|
|
*output_section_slot = NULL;
|
2010-04-09 19:32:58 +02:00
|
|
|
*psection_type = Script_sections::ST_NONE;
|
2008-02-04 06:43:05 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-13 22:01:13 +01:00
|
|
|
// We have an orphan section.
|
2008-02-04 06:43:05 +01:00
|
|
|
*output_section_slot = NULL;
|
2010-04-09 19:32:58 +02:00
|
|
|
*psection_type = Script_sections::ST_NONE;
|
2016-12-02 04:54:05 +01:00
|
|
|
*keep = false;
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2016-12-13 22:01:13 +01:00
|
|
|
General_options::Orphan_handling orphan_handling =
|
|
|
|
parameters->options().orphan_handling_enum();
|
|
|
|
if (orphan_handling == General_options::ORPHAN_DISCARD)
|
|
|
|
return NULL;
|
|
|
|
if (orphan_handling == General_options::ORPHAN_ERROR)
|
|
|
|
{
|
|
|
|
if (file_name == NULL)
|
|
|
|
gold_error(_("unplaced orphan section '%s'"), section_name);
|
|
|
|
else
|
|
|
|
gold_error(_("unplaced orphan section '%s' from '%s'"),
|
|
|
|
section_name, file_name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (orphan_handling == General_options::ORPHAN_WARN)
|
|
|
|
{
|
|
|
|
if (file_name == NULL)
|
|
|
|
gold_warning(_("orphan section '%s' is being placed in section '%s'"),
|
|
|
|
section_name, section_name);
|
|
|
|
else
|
|
|
|
gold_warning(_("orphan section '%s' from '%s' is being placed "
|
|
|
|
"in section '%s'"),
|
|
|
|
section_name, file_name, section_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we couldn't find a mapping for the name, the output section
|
|
|
|
// gets the name of the input section.
|
2008-02-04 06:43:05 +01:00
|
|
|
return section_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Place a marker for an orphan output section into the SECTIONS
|
|
|
|
// clause.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::place_orphan(Output_section* os)
|
|
|
|
{
|
2009-03-19 06:51:49 +01:00
|
|
|
Orphan_section_placement* osp = this->orphan_section_placement_;
|
|
|
|
if (osp == NULL)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
2009-03-19 06:51:49 +01:00
|
|
|
// Initialize the Orphan_section_placement structure.
|
|
|
|
osp = new Orphan_section_placement();
|
|
|
|
for (Sections_elements::iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
|
|
|
(*p)->orphan_section_init(osp, p);
|
|
|
|
gold_assert(!this->sections_elements_->empty());
|
|
|
|
Sections_elements::iterator last = this->sections_elements_->end();
|
|
|
|
--last;
|
|
|
|
osp->last_init(last);
|
|
|
|
this->orphan_section_placement_ = osp;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
Orphan_output_section* orphan = new Orphan_output_section(os);
|
2008-08-13 09:37:46 +02:00
|
|
|
|
2009-03-19 06:51:49 +01:00
|
|
|
// Look for where to put ORPHAN.
|
|
|
|
Sections_elements::iterator* where;
|
|
|
|
if (osp->find_place(os, &where))
|
|
|
|
{
|
|
|
|
if ((**where)->is_relro())
|
|
|
|
os->set_is_relro();
|
|
|
|
else
|
|
|
|
os->clear_is_relro();
|
|
|
|
|
|
|
|
// We want to insert ORPHAN after *WHERE, and then update *WHERE
|
|
|
|
// so that the next one goes after this one.
|
|
|
|
Sections_elements::iterator p = *where;
|
|
|
|
gold_assert(p != this->sections_elements_->end());
|
|
|
|
++p;
|
|
|
|
*where = this->sections_elements_->insert(p, orphan);
|
|
|
|
}
|
2008-08-13 09:37:46 +02:00
|
|
|
else
|
2009-03-19 06:51:49 +01:00
|
|
|
{
|
|
|
|
os->clear_is_relro();
|
|
|
|
// We don't have a place to put this orphan section. Put it,
|
|
|
|
// and all other sections like it, at the end, but before the
|
|
|
|
// sections which always come at the end.
|
|
|
|
Sections_elements::iterator last = osp->last_place();
|
|
|
|
*where = this->sections_elements_->insert(last, orphan);
|
|
|
|
}
|
2016-12-13 02:52:09 +01:00
|
|
|
|
|
|
|
if ((os->flags() & elfcpp::SHF_ALLOC) != 0)
|
|
|
|
osp->update_last_alloc(*where);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Set the addresses of all the output sections. Walk through all the
|
|
|
|
// elements, tracking the dot symbol. Apply assignments which set
|
|
|
|
// absolute symbol values, in case they are used when setting dot.
|
|
|
|
// Fill in data statement values. As we find output sections, set the
|
|
|
|
// address, set the address of all associated input sections, and
|
|
|
|
// update dot. Return the segment which should hold the file header
|
|
|
|
// and segment headers, if any.
|
|
|
|
|
|
|
|
Output_segment*
|
|
|
|
Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout)
|
|
|
|
{
|
|
|
|
gold_assert(this->saw_sections_clause_);
|
2016-08-12 18:55:25 +02:00
|
|
|
|
2008-02-04 07:45:50 +01:00
|
|
|
// Implement ONLY_IF_RO/ONLY_IF_RW constraints. These are a pain
|
|
|
|
// for our representation.
|
|
|
|
for (Sections_elements::iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
Output_section_definition* posd;
|
|
|
|
Section_constraint failed_constraint = (*p)->check_constraint(&posd);
|
|
|
|
if (failed_constraint != CONSTRAINT_NONE)
|
|
|
|
{
|
|
|
|
Sections_elements::iterator q;
|
|
|
|
for (q = this->sections_elements_->begin();
|
|
|
|
q != this->sections_elements_->end();
|
|
|
|
++q)
|
|
|
|
{
|
|
|
|
if (q != p)
|
|
|
|
{
|
|
|
|
if ((*q)->alternate_constraint(posd, failed_constraint))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (q == this->sections_elements_->end())
|
|
|
|
gold_error(_("no matching section constraint"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-13 09:37:46 +02:00
|
|
|
// Force the alignment of the first TLS section to be the maximum
|
|
|
|
// alignment of all TLS sections.
|
|
|
|
Output_section* first_tls = NULL;
|
|
|
|
uint64_t tls_align = 0;
|
|
|
|
for (Sections_elements::const_iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
|
|
|
{
|
2010-08-25 10:36:54 +02:00
|
|
|
Output_section* os = (*p)->get_output_section();
|
2008-08-13 09:37:46 +02:00
|
|
|
if (os != NULL && (os->flags() & elfcpp::SHF_TLS) != 0)
|
|
|
|
{
|
|
|
|
if (first_tls == NULL)
|
|
|
|
first_tls = os;
|
|
|
|
if (os->addralign() > tls_align)
|
|
|
|
tls_align = os->addralign();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (first_tls != NULL)
|
|
|
|
first_tls->set_addralign(tls_align);
|
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
// For a relocatable link, we implicitly set dot to zero.
|
2008-02-04 06:43:05 +01:00
|
|
|
uint64_t dot_value = 0;
|
2010-04-23 06:47:33 +02:00
|
|
|
uint64_t dot_alignment = 0;
|
2008-02-14 03:34:22 +01:00
|
|
|
uint64_t load_address = 0;
|
2009-10-16 Doug Kwan <dougkwan@google.com>
* expression.cc (class Segment_start_expression): New class definition.
(Segment_start_expression::value): New method definition.
(script_exp_function_segment_start): Return a new
Segment_start_expression.
* gold/script-c.h (script_saw_segment_start_expression): New function
prototype.
* script-sections.cc (Script_sections::Script_sections): Initialize
SAW_SEGMENT_START_EXPRESSION_ to false.
(Script_sections::set_section_addresses): Use -Ttext, -Tdata
and -Tbbs options to specify section addresses if given in
command line and no SEGMENT_START expression is seen in a script.
* script-sections.h (Script_sections::saw_segment_start_expression,
Script_sections::set_saw_segment_start_expression): New method
definition.
(Script_sections::saw_segment_start_expression_): New data member
declaration.
* script.cc (script_saw_segment_start_expression): New function.
* yyscript.y (SEGMENT_START): Call script_saw_segment_start_expression.
* testsuite/Makefile.am (check_SCRIPTS): Add script_test_6.sh,
script_test_7.sh and script_test_8.sh.
(check_DATA): Add script_test_6.stdout, script_test_7.stdout and
script_test_8.stdout.
(MOSTLYCLEANFILES): Add script_test_6, script_test_7 and script_test_8.
(script_test_6, script_test_6.stdout, script_test_7,
script_test_7.stdout, script_test_8, script_test_8.stdout): New rules.
* Makefile.in: Regenerate.
* testsuite/script_test_6.sh: New file.
* testsuite/script_test_6.t: Same.
* testsuite/script_test_7.sh: Same.
* testsuite/script_test_7.t: Same.
* testsuite/script_test_8.sh: Same.
2009-10-16 20:56:07 +02:00
|
|
|
|
|
|
|
// Check to see if we want to use any of -Ttext, -Tdata and -Tbss options
|
|
|
|
// to set section addresses. If the script has any SEGMENT_START
|
|
|
|
// expression, we do not set the section addresses.
|
|
|
|
bool use_tsection_options =
|
|
|
|
(!this->saw_segment_start_expression_
|
|
|
|
&& (parameters->options().user_set_Ttext()
|
|
|
|
|| parameters->options().user_set_Tdata()
|
|
|
|
|| parameters->options().user_set_Tbss()));
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
for (Sections_elements::iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
2009-10-16 Doug Kwan <dougkwan@google.com>
* expression.cc (class Segment_start_expression): New class definition.
(Segment_start_expression::value): New method definition.
(script_exp_function_segment_start): Return a new
Segment_start_expression.
* gold/script-c.h (script_saw_segment_start_expression): New function
prototype.
* script-sections.cc (Script_sections::Script_sections): Initialize
SAW_SEGMENT_START_EXPRESSION_ to false.
(Script_sections::set_section_addresses): Use -Ttext, -Tdata
and -Tbbs options to specify section addresses if given in
command line and no SEGMENT_START expression is seen in a script.
* script-sections.h (Script_sections::saw_segment_start_expression,
Script_sections::set_saw_segment_start_expression): New method
definition.
(Script_sections::saw_segment_start_expression_): New data member
declaration.
* script.cc (script_saw_segment_start_expression): New function.
* yyscript.y (SEGMENT_START): Call script_saw_segment_start_expression.
* testsuite/Makefile.am (check_SCRIPTS): Add script_test_6.sh,
script_test_7.sh and script_test_8.sh.
(check_DATA): Add script_test_6.stdout, script_test_7.stdout and
script_test_8.stdout.
(MOSTLYCLEANFILES): Add script_test_6, script_test_7 and script_test_8.
(script_test_6, script_test_6.stdout, script_test_7,
script_test_7.stdout, script_test_8, script_test_8.stdout): New rules.
* Makefile.in: Regenerate.
* testsuite/script_test_6.sh: New file.
* testsuite/script_test_6.t: Same.
* testsuite/script_test_7.sh: Same.
* testsuite/script_test_7.t: Same.
* testsuite/script_test_8.sh: Same.
2009-10-16 20:56:07 +02:00
|
|
|
{
|
|
|
|
Output_section* os = (*p)->get_output_section();
|
|
|
|
|
|
|
|
// Handle -Ttext, -Tdata and -Tbss options. We do this by looking for
|
2016-08-12 18:55:25 +02:00
|
|
|
// the special sections by names and doing dot assignments.
|
2009-10-16 Doug Kwan <dougkwan@google.com>
* expression.cc (class Segment_start_expression): New class definition.
(Segment_start_expression::value): New method definition.
(script_exp_function_segment_start): Return a new
Segment_start_expression.
* gold/script-c.h (script_saw_segment_start_expression): New function
prototype.
* script-sections.cc (Script_sections::Script_sections): Initialize
SAW_SEGMENT_START_EXPRESSION_ to false.
(Script_sections::set_section_addresses): Use -Ttext, -Tdata
and -Tbbs options to specify section addresses if given in
command line and no SEGMENT_START expression is seen in a script.
* script-sections.h (Script_sections::saw_segment_start_expression,
Script_sections::set_saw_segment_start_expression): New method
definition.
(Script_sections::saw_segment_start_expression_): New data member
declaration.
* script.cc (script_saw_segment_start_expression): New function.
* yyscript.y (SEGMENT_START): Call script_saw_segment_start_expression.
* testsuite/Makefile.am (check_SCRIPTS): Add script_test_6.sh,
script_test_7.sh and script_test_8.sh.
(check_DATA): Add script_test_6.stdout, script_test_7.stdout and
script_test_8.stdout.
(MOSTLYCLEANFILES): Add script_test_6, script_test_7 and script_test_8.
(script_test_6, script_test_6.stdout, script_test_7,
script_test_7.stdout, script_test_8, script_test_8.stdout): New rules.
* Makefile.in: Regenerate.
* testsuite/script_test_6.sh: New file.
* testsuite/script_test_6.t: Same.
* testsuite/script_test_7.sh: Same.
* testsuite/script_test_7.t: Same.
* testsuite/script_test_8.sh: Same.
2009-10-16 20:56:07 +02:00
|
|
|
if (use_tsection_options
|
|
|
|
&& os != NULL
|
|
|
|
&& (os->flags() & elfcpp::SHF_ALLOC) != 0)
|
|
|
|
{
|
|
|
|
uint64_t new_dot_value = dot_value;
|
|
|
|
|
|
|
|
if (parameters->options().user_set_Ttext()
|
|
|
|
&& strcmp(os->name(), ".text") == 0)
|
|
|
|
new_dot_value = parameters->options().Ttext();
|
|
|
|
else if (parameters->options().user_set_Tdata()
|
|
|
|
&& strcmp(os->name(), ".data") == 0)
|
|
|
|
new_dot_value = parameters->options().Tdata();
|
|
|
|
else if (parameters->options().user_set_Tbss()
|
|
|
|
&& strcmp(os->name(), ".bss") == 0)
|
|
|
|
new_dot_value = parameters->options().Tbss();
|
|
|
|
|
|
|
|
// Update dot and load address if necessary.
|
|
|
|
if (new_dot_value < dot_value)
|
|
|
|
gold_error(_("dot may not move backward"));
|
|
|
|
else if (new_dot_value != dot_value)
|
|
|
|
{
|
|
|
|
dot_value = new_dot_value;
|
|
|
|
load_address = new_dot_value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-23 06:47:33 +02:00
|
|
|
(*p)->set_section_addresses(symtab, layout, &dot_value, &dot_alignment,
|
|
|
|
&load_address);
|
2016-08-12 18:55:25 +02:00
|
|
|
}
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
if (this->phdrs_elements_ != NULL)
|
|
|
|
{
|
|
|
|
for (Phdrs_elements::iterator p = this->phdrs_elements_->begin();
|
|
|
|
p != this->phdrs_elements_->end();
|
|
|
|
++p)
|
|
|
|
(*p)->eval_load_address(symtab, layout);
|
|
|
|
}
|
|
|
|
|
2010-04-23 06:47:33 +02:00
|
|
|
return this->create_segments(layout, dot_alignment);
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Sort the sections in order to put them into segments.
|
|
|
|
|
|
|
|
class Sort_output_sections
|
|
|
|
{
|
|
|
|
public:
|
2010-10-12 21:21:41 +02:00
|
|
|
Sort_output_sections(const Script_sections::Sections_elements* elements)
|
|
|
|
: elements_(elements)
|
|
|
|
{ }
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
bool
|
|
|
|
operator()(const Output_section* os1, const Output_section* os2) const;
|
2010-10-12 21:21:41 +02:00
|
|
|
|
|
|
|
private:
|
2011-03-14 16:22:16 +01:00
|
|
|
int
|
|
|
|
script_compare(const Output_section* os1, const Output_section* os2) const;
|
2010-10-12 21:21:41 +02:00
|
|
|
|
|
|
|
private:
|
|
|
|
const Script_sections::Sections_elements* elements_;
|
2008-02-04 06:43:05 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
bool
|
|
|
|
Sort_output_sections::operator()(const Output_section* os1,
|
|
|
|
const Output_section* os2) const
|
|
|
|
{
|
|
|
|
// Sort first by the load address.
|
|
|
|
uint64_t lma1 = (os1->has_load_address()
|
|
|
|
? os1->load_address()
|
|
|
|
: os1->address());
|
|
|
|
uint64_t lma2 = (os2->has_load_address()
|
|
|
|
? os2->load_address()
|
|
|
|
: os2->address());
|
|
|
|
if (lma1 != lma2)
|
|
|
|
return lma1 < lma2;
|
|
|
|
|
|
|
|
// Then sort by the virtual address.
|
|
|
|
if (os1->address() != os2->address())
|
|
|
|
return os1->address() < os2->address();
|
|
|
|
|
2011-03-14 16:22:16 +01:00
|
|
|
// If the linker script says which of these sections is first, go
|
|
|
|
// with what it says.
|
|
|
|
int i = this->script_compare(os1, os2);
|
|
|
|
if (i != 0)
|
|
|
|
return i < 0;
|
|
|
|
|
2011-01-04 22:46:06 +01:00
|
|
|
// Sort PROGBITS before NOBITS.
|
|
|
|
bool nobits1 = os1->type() == elfcpp::SHT_NOBITS;
|
|
|
|
bool nobits2 = os2->type() == elfcpp::SHT_NOBITS;
|
|
|
|
if (nobits1 != nobits2)
|
|
|
|
return nobits2;
|
|
|
|
|
|
|
|
// Sort PROGBITS TLS sections to the end, NOBITS TLS sections to the
|
|
|
|
// beginning.
|
2008-02-04 06:43:05 +01:00
|
|
|
bool tls1 = (os1->flags() & elfcpp::SHF_TLS) != 0;
|
|
|
|
bool tls2 = (os2->flags() & elfcpp::SHF_TLS) != 0;
|
|
|
|
if (tls1 != tls2)
|
2011-01-04 22:46:06 +01:00
|
|
|
return nobits1 ? tls1 : tls2;
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2010-04-09 19:32:58 +02:00
|
|
|
// Sort non-NOLOAD before NOLOAD.
|
|
|
|
if (os1->is_noload() && !os2->is_noload())
|
|
|
|
return true;
|
|
|
|
if (!os1->is_noload() && os2->is_noload())
|
|
|
|
return true;
|
2011-03-14 16:22:16 +01:00
|
|
|
|
|
|
|
// The sections seem practically identical. Sort by name to get a
|
|
|
|
// stable sort.
|
|
|
|
return os1->name() < os2->name();
|
2010-10-12 21:21:41 +02:00
|
|
|
}
|
|
|
|
|
2011-03-14 16:22:16 +01:00
|
|
|
// Return -1 if OS1 comes before OS2 in ELEMENTS_, 1 if comes after, 0
|
|
|
|
// if either OS1 or OS2 is not mentioned. This ensures that we keep
|
|
|
|
// empty sections in the order in which they appear in a linker
|
|
|
|
// script.
|
2010-10-12 21:21:41 +02:00
|
|
|
|
2011-03-14 16:22:16 +01:00
|
|
|
int
|
|
|
|
Sort_output_sections::script_compare(const Output_section* os1,
|
|
|
|
const Output_section* os2) const
|
2010-10-12 21:21:41 +02:00
|
|
|
{
|
|
|
|
if (this->elements_ == NULL)
|
2011-03-14 16:22:16 +01:00
|
|
|
return 0;
|
2010-10-12 21:21:41 +02:00
|
|
|
|
2011-03-14 16:22:16 +01:00
|
|
|
bool found_os1 = false;
|
|
|
|
bool found_os2 = false;
|
2010-10-12 21:21:41 +02:00
|
|
|
for (Script_sections::Sections_elements::const_iterator
|
|
|
|
p = this->elements_->begin();
|
|
|
|
p != this->elements_->end();
|
|
|
|
++p)
|
|
|
|
{
|
2011-03-14 16:22:16 +01:00
|
|
|
if (os2 == (*p)->get_output_section())
|
2010-10-12 21:21:41 +02:00
|
|
|
{
|
2011-03-14 16:22:16 +01:00
|
|
|
if (found_os1)
|
|
|
|
return -1;
|
|
|
|
found_os2 = true;
|
|
|
|
}
|
|
|
|
else if (os1 == (*p)->get_output_section())
|
|
|
|
{
|
|
|
|
if (found_os2)
|
|
|
|
return 1;
|
|
|
|
found_os1 = true;
|
2010-10-12 21:21:41 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-14 16:22:16 +01:00
|
|
|
return 0;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return whether OS is a BSS section. This is a SHT_NOBITS section.
|
|
|
|
// We treat a section with the SHF_TLS flag set as taking up space
|
|
|
|
// even if it is SHT_NOBITS (this is true of .tbss), as we allocate
|
|
|
|
// space for them in the file.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Script_sections::is_bss_section(const Output_section* os)
|
|
|
|
{
|
|
|
|
return (os->type() == elfcpp::SHT_NOBITS
|
|
|
|
&& (os->flags() & elfcpp::SHF_TLS) == 0);
|
|
|
|
}
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// Return the size taken by the file header and the program headers.
|
|
|
|
|
|
|
|
size_t
|
|
|
|
Script_sections::total_header_size(Layout* layout) const
|
|
|
|
{
|
|
|
|
size_t segment_count = layout->segment_count();
|
|
|
|
size_t file_header_size;
|
|
|
|
size_t segment_headers_size;
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().get_size() == 32)
|
2008-02-04 23:54:31 +01:00
|
|
|
{
|
|
|
|
file_header_size = elfcpp::Elf_sizes<32>::ehdr_size;
|
|
|
|
segment_headers_size = segment_count * elfcpp::Elf_sizes<32>::phdr_size;
|
|
|
|
}
|
2008-02-28 01:18:24 +01:00
|
|
|
else if (parameters->target().get_size() == 64)
|
2008-02-04 23:54:31 +01:00
|
|
|
{
|
|
|
|
file_header_size = elfcpp::Elf_sizes<64>::ehdr_size;
|
|
|
|
segment_headers_size = segment_count * elfcpp::Elf_sizes<64>::phdr_size;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gold_unreachable();
|
|
|
|
|
|
|
|
return file_header_size + segment_headers_size;
|
|
|
|
}
|
|
|
|
|
2010-12-14 20:03:30 +01:00
|
|
|
// Return the amount we have to subtract from the LMA to accommodate
|
2008-02-04 23:54:31 +01:00
|
|
|
// headers of the given size. The complication is that the file
|
|
|
|
// header have to be at the start of a page, as otherwise it will not
|
|
|
|
// be at the start of the file.
|
|
|
|
|
|
|
|
uint64_t
|
|
|
|
Script_sections::header_size_adjustment(uint64_t lma,
|
|
|
|
size_t sizeof_headers) const
|
|
|
|
{
|
2008-02-28 01:18:24 +01:00
|
|
|
const uint64_t abi_pagesize = parameters->target().abi_pagesize();
|
2008-02-04 23:54:31 +01:00
|
|
|
uint64_t hdr_lma = lma - sizeof_headers;
|
|
|
|
hdr_lma &= ~(abi_pagesize - 1);
|
|
|
|
return lma - hdr_lma;
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Create the PT_LOAD segments when using a SECTIONS clause. Returns
|
|
|
|
// the segment which should hold the file header and segment headers,
|
|
|
|
// if any.
|
|
|
|
|
|
|
|
Output_segment*
|
2010-04-23 06:47:33 +02:00
|
|
|
Script_sections::create_segments(Layout* layout, uint64_t dot_alignment)
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
gold_assert(this->saw_sections_clause_);
|
|
|
|
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->options().relocatable())
|
2008-02-04 06:43:05 +01:00
|
|
|
return NULL;
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
if (this->saw_phdrs_clause())
|
2010-04-23 06:47:33 +02:00
|
|
|
return create_segments_from_phdrs_clause(layout, dot_alignment);
|
2008-02-04 23:54:31 +01:00
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
Layout::Section_list sections;
|
|
|
|
layout->get_allocated_sections(§ions);
|
|
|
|
|
|
|
|
// Sort the sections by address.
|
2016-08-12 18:55:25 +02:00
|
|
|
std::stable_sort(sections.begin(), sections.end(),
|
2010-10-12 21:21:41 +02:00
|
|
|
Sort_output_sections(this->sections_elements_));
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
this->create_note_and_tls_segments(layout, §ions);
|
|
|
|
|
|
|
|
// Walk through the sections adding them to PT_LOAD segments.
|
2008-02-28 01:18:24 +01:00
|
|
|
const uint64_t abi_pagesize = parameters->target().abi_pagesize();
|
2008-02-04 06:43:05 +01:00
|
|
|
Output_segment* first_seg = NULL;
|
|
|
|
Output_segment* current_seg = NULL;
|
|
|
|
bool is_current_seg_readonly = true;
|
|
|
|
uint64_t last_vma = 0;
|
|
|
|
uint64_t last_lma = 0;
|
|
|
|
uint64_t last_size = 0;
|
2016-12-13 02:52:09 +01:00
|
|
|
bool in_bss = false;
|
2008-02-04 06:43:05 +01:00
|
|
|
for (Layout::Section_list::iterator p = sections.begin();
|
|
|
|
p != sections.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
const uint64_t vma = (*p)->address();
|
|
|
|
const uint64_t lma = ((*p)->has_load_address()
|
|
|
|
? (*p)->load_address()
|
|
|
|
: vma);
|
|
|
|
const uint64_t size = (*p)->current_data_size();
|
|
|
|
|
|
|
|
bool need_new_segment;
|
|
|
|
if (current_seg == NULL)
|
|
|
|
need_new_segment = true;
|
|
|
|
else if (lma - vma != last_lma - last_vma)
|
|
|
|
{
|
|
|
|
// This section has a different LMA relationship than the
|
|
|
|
// last one; we need a new segment.
|
|
|
|
need_new_segment = true;
|
|
|
|
}
|
|
|
|
else if (align_address(last_lma + last_size, abi_pagesize)
|
|
|
|
< align_address(lma, abi_pagesize))
|
|
|
|
{
|
|
|
|
// Putting this section in the segment would require
|
|
|
|
// skipping a page.
|
|
|
|
need_new_segment = true;
|
|
|
|
}
|
2016-12-13 02:52:09 +01:00
|
|
|
else if (in_bss && !is_bss_section(*p))
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
// A non-BSS section can not follow a BSS section in the
|
|
|
|
// same segment.
|
|
|
|
need_new_segment = true;
|
|
|
|
}
|
|
|
|
else if (is_current_seg_readonly
|
2008-07-23 01:01:20 +02:00
|
|
|
&& ((*p)->flags() & elfcpp::SHF_WRITE) != 0
|
|
|
|
&& !parameters->options().omagic())
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
// Don't put a writable section in the same segment as a
|
|
|
|
// non-writable section.
|
|
|
|
need_new_segment = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Otherwise, reuse the existing segment.
|
|
|
|
need_new_segment = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
elfcpp::Elf_Word seg_flags =
|
|
|
|
Layout::section_flags_to_segment((*p)->flags());
|
|
|
|
|
|
|
|
if (need_new_segment)
|
|
|
|
{
|
|
|
|
current_seg = layout->make_output_segment(elfcpp::PT_LOAD,
|
|
|
|
seg_flags);
|
|
|
|
current_seg->set_addresses(vma, lma);
|
2010-04-23 06:47:33 +02:00
|
|
|
current_seg->set_minimum_p_align(dot_alignment);
|
2008-02-04 06:43:05 +01:00
|
|
|
if (first_seg == NULL)
|
|
|
|
first_seg = current_seg;
|
|
|
|
is_current_seg_readonly = true;
|
2016-12-13 02:52:09 +01:00
|
|
|
in_bss = false;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2010-08-03 Ian Lance Taylor <iant@google.com>
PR 11805
* layout.h (enum Output_section_order): Define.
(class Layout): Update declarations.
* layout.cc (Layout::get_output_section): Add order parameter.
Remove is_interp, is_dynamic_linker_section, is_last_relro, and
is_first_non_relro parameters. Change all callers.
(Layout::choose_output_section): Likewise.
(Layout::add_output_section_data): Likewise.
(Layout::make_output_section): Likewise. Set order.
(Layout::default_section_order): New function.
(Layout::layout_eh_frame): Call add_output_section_to_nonload.
* output.cc (Output_section::Output_section): Initialize order_.
Don't initialize deleted fields.
(Output_segment::Output_segment): Don't initialize deleted
fields.
(Output_segment::add_output_section_to_load): New function
replacing add_output_section. Change all callers to call this or
add_output_section_to_nonload.
(Output_segment::add_output_section_to_nonload): New function.
(Output_segment::remove_output_section): Rewrite.
(Output_segment::add_initial_output_data): Likewise.
(Output_segment::has_any_data_sections): Likewise.
(Output_segment::is_first_section_relro): Likewise.
(Output_segment::maximum_alignment): Likewise.
(Output_segment::has_dynamic_reloc): New function replacing
dynamic_reloc_count. Change all callers.
(Output_segment::has_dynamic_reloc_list): New function replacing
dynamic_reloc_count_list. Change all callers.
(Output_segment::set_section_addresses): Rewrite.
(Output_segment::set_offset): Rewrite.
(Output_segment::find_first_and_last_list): Remove.
(Output_segment::set_tls_offsets): Rewrite.
(Output_segment::first_section_load_address): Likewise.
(Output_segment::output_section_count): Likewise.
(Output_segment::section_with_lowest_load_address): Likewise.
(Output_segment::write_section_headers): Likewise.
(Output_segment::print_sections_to_map): Likewise.
* output.h (class Output_data): Remove dynamic_reloc_count_
field. Add has_dynamic_reloc_ field. Make bools into bitfields.
(Output_data::add_dynamic_reloc): Rewrite.
(Output_data::has_dynamic_reloc): New function.
(Output_data::dynamic_reloc_count): Remove.
(class Output_section): Add order_ field. Remvoe is_relro_local_,
is_last_relro_, is_first_non_relro_, is_interp_,
is_dynamic_linker_section_ fields. Add order and set_order
functions. Remove is_relro_local, set_is_relro_local,
is_last_relro, set_is_last_relro, is_first_non_relro,
set_is_first_non_relro functions, is_interp, set_is_interp,
is_dynamic_linker_section, and set_is_dynamic_linker_section
functions.
(class Output_segment): Change Output_data_list from std::list to
std:;vector. Add output_lists_ field. Remove output_data_ and
output_bss_ fields. Update declarations.
2010-08-03 16:07:13 +02:00
|
|
|
current_seg->add_output_section_to_load(layout, *p, seg_flags);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
if (((*p)->flags() & elfcpp::SHF_WRITE) != 0)
|
|
|
|
is_current_seg_readonly = false;
|
|
|
|
|
2016-12-13 02:52:09 +01:00
|
|
|
if (is_bss_section(*p) && size > 0)
|
|
|
|
in_bss = true;
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
last_vma = vma;
|
|
|
|
last_lma = lma;
|
|
|
|
last_size = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
// An ELF program should work even if the program headers are not in
|
|
|
|
// a PT_LOAD segment. However, it appears that the Linux kernel
|
|
|
|
// does not set the AT_PHDR auxiliary entry in that case. It sets
|
|
|
|
// the load address to p_vaddr - p_offset of the first PT_LOAD
|
|
|
|
// segment. It then sets AT_PHDR to the load address plus the
|
|
|
|
// offset to the program headers, e_phoff in the file header. This
|
|
|
|
// fails when the program headers appear in the file before the
|
|
|
|
// first PT_LOAD segment. Therefore, we always create a PT_LOAD
|
|
|
|
// segment to hold the file header and the program headers. This is
|
|
|
|
// effectively what the GNU linker does, and it is slightly more
|
|
|
|
// efficient in any case. We try to use the first PT_LOAD segment
|
|
|
|
// if we can, otherwise we make a new one.
|
|
|
|
|
2008-02-28 05:45:47 +01:00
|
|
|
if (first_seg == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2009-06-23 08:07:50 +02:00
|
|
|
// -n or -N mean that the program is not demand paged and there is
|
|
|
|
// no need to put the program headers in a PT_LOAD segment.
|
|
|
|
if (parameters->options().nmagic() || parameters->options().omagic())
|
|
|
|
return NULL;
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
size_t sizeof_headers = this->total_header_size(layout);
|
2008-02-04 07:45:50 +01:00
|
|
|
|
2008-02-28 05:45:47 +01:00
|
|
|
uint64_t vma = first_seg->vaddr();
|
|
|
|
uint64_t lma = first_seg->paddr();
|
|
|
|
|
|
|
|
uint64_t subtract = this->header_size_adjustment(lma, sizeof_headers);
|
|
|
|
|
2008-04-16 00:50:37 +02:00
|
|
|
if ((lma & (abi_pagesize - 1)) >= sizeof_headers)
|
|
|
|
{
|
|
|
|
first_seg->set_addresses(vma - subtract, lma - subtract);
|
|
|
|
return first_seg;
|
|
|
|
}
|
|
|
|
|
2008-02-28 05:45:47 +01:00
|
|
|
// If there is no room to squeeze in the headers, then punt. The
|
|
|
|
// resulting executable probably won't run on GNU/Linux, but we
|
|
|
|
// trust that the user knows what they are doing.
|
|
|
|
if (lma < subtract || vma < subtract)
|
|
|
|
return NULL;
|
|
|
|
|
2010-10-06 10:58:59 +02:00
|
|
|
// If memory regions have been specified and the address range
|
|
|
|
// we are about to use is not contained within any region then
|
|
|
|
// issue a warning message about the segment we are going to
|
|
|
|
// create. It will be outside of any region and so possibly
|
|
|
|
// using non-existent or protected memory. We test LMA rather
|
|
|
|
// than VMA since we assume that the headers will never be
|
|
|
|
// relocated.
|
|
|
|
if (this->memory_regions_ != NULL
|
|
|
|
&& !this->block_in_region (NULL, layout, lma - subtract, subtract))
|
|
|
|
gold_warning(_("creating a segment to contain the file and program"
|
|
|
|
" headers outside of any MEMORY region"));
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
Output_segment* load_seg = layout->make_output_segment(elfcpp::PT_LOAD,
|
|
|
|
elfcpp::PF_R);
|
2008-02-28 05:45:47 +01:00
|
|
|
load_seg->set_addresses(vma - subtract, lma - subtract);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
return load_seg;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a PT_NOTE segment for each SHT_NOTE section and a PT_TLS
|
|
|
|
// segment if there are any SHT_TLS sections.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::create_note_and_tls_segments(
|
|
|
|
Layout* layout,
|
|
|
|
const Layout::Section_list* sections)
|
|
|
|
{
|
2008-02-04 23:54:31 +01:00
|
|
|
gold_assert(!this->saw_phdrs_clause());
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
bool saw_tls = false;
|
|
|
|
for (Layout::Section_list::const_iterator p = sections->begin();
|
|
|
|
p != sections->end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if ((*p)->type() == elfcpp::SHT_NOTE)
|
|
|
|
{
|
|
|
|
elfcpp::Elf_Word seg_flags =
|
|
|
|
Layout::section_flags_to_segment((*p)->flags());
|
|
|
|
Output_segment* oseg = layout->make_output_segment(elfcpp::PT_NOTE,
|
|
|
|
seg_flags);
|
2010-08-03 Ian Lance Taylor <iant@google.com>
PR 11805
* layout.h (enum Output_section_order): Define.
(class Layout): Update declarations.
* layout.cc (Layout::get_output_section): Add order parameter.
Remove is_interp, is_dynamic_linker_section, is_last_relro, and
is_first_non_relro parameters. Change all callers.
(Layout::choose_output_section): Likewise.
(Layout::add_output_section_data): Likewise.
(Layout::make_output_section): Likewise. Set order.
(Layout::default_section_order): New function.
(Layout::layout_eh_frame): Call add_output_section_to_nonload.
* output.cc (Output_section::Output_section): Initialize order_.
Don't initialize deleted fields.
(Output_segment::Output_segment): Don't initialize deleted
fields.
(Output_segment::add_output_section_to_load): New function
replacing add_output_section. Change all callers to call this or
add_output_section_to_nonload.
(Output_segment::add_output_section_to_nonload): New function.
(Output_segment::remove_output_section): Rewrite.
(Output_segment::add_initial_output_data): Likewise.
(Output_segment::has_any_data_sections): Likewise.
(Output_segment::is_first_section_relro): Likewise.
(Output_segment::maximum_alignment): Likewise.
(Output_segment::has_dynamic_reloc): New function replacing
dynamic_reloc_count. Change all callers.
(Output_segment::has_dynamic_reloc_list): New function replacing
dynamic_reloc_count_list. Change all callers.
(Output_segment::set_section_addresses): Rewrite.
(Output_segment::set_offset): Rewrite.
(Output_segment::find_first_and_last_list): Remove.
(Output_segment::set_tls_offsets): Rewrite.
(Output_segment::first_section_load_address): Likewise.
(Output_segment::output_section_count): Likewise.
(Output_segment::section_with_lowest_load_address): Likewise.
(Output_segment::write_section_headers): Likewise.
(Output_segment::print_sections_to_map): Likewise.
* output.h (class Output_data): Remove dynamic_reloc_count_
field. Add has_dynamic_reloc_ field. Make bools into bitfields.
(Output_data::add_dynamic_reloc): Rewrite.
(Output_data::has_dynamic_reloc): New function.
(Output_data::dynamic_reloc_count): Remove.
(class Output_section): Add order_ field. Remvoe is_relro_local_,
is_last_relro_, is_first_non_relro_, is_interp_,
is_dynamic_linker_section_ fields. Add order and set_order
functions. Remove is_relro_local, set_is_relro_local,
is_last_relro, set_is_last_relro, is_first_non_relro,
set_is_first_non_relro functions, is_interp, set_is_interp,
is_dynamic_linker_section, and set_is_dynamic_linker_section
functions.
(class Output_segment): Change Output_data_list from std::list to
std:;vector. Add output_lists_ field. Remove output_data_ and
output_bss_ fields. Update declarations.
2010-08-03 16:07:13 +02:00
|
|
|
oseg->add_output_section_to_nonload(*p, seg_flags);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
// Incorporate any subsequent SHT_NOTE sections, in the
|
|
|
|
// hopes that the script is sensible.
|
|
|
|
Layout::Section_list::const_iterator pnext = p + 1;
|
|
|
|
while (pnext != sections->end()
|
|
|
|
&& (*pnext)->type() == elfcpp::SHT_NOTE)
|
|
|
|
{
|
|
|
|
seg_flags = Layout::section_flags_to_segment((*pnext)->flags());
|
2010-08-03 Ian Lance Taylor <iant@google.com>
PR 11805
* layout.h (enum Output_section_order): Define.
(class Layout): Update declarations.
* layout.cc (Layout::get_output_section): Add order parameter.
Remove is_interp, is_dynamic_linker_section, is_last_relro, and
is_first_non_relro parameters. Change all callers.
(Layout::choose_output_section): Likewise.
(Layout::add_output_section_data): Likewise.
(Layout::make_output_section): Likewise. Set order.
(Layout::default_section_order): New function.
(Layout::layout_eh_frame): Call add_output_section_to_nonload.
* output.cc (Output_section::Output_section): Initialize order_.
Don't initialize deleted fields.
(Output_segment::Output_segment): Don't initialize deleted
fields.
(Output_segment::add_output_section_to_load): New function
replacing add_output_section. Change all callers to call this or
add_output_section_to_nonload.
(Output_segment::add_output_section_to_nonload): New function.
(Output_segment::remove_output_section): Rewrite.
(Output_segment::add_initial_output_data): Likewise.
(Output_segment::has_any_data_sections): Likewise.
(Output_segment::is_first_section_relro): Likewise.
(Output_segment::maximum_alignment): Likewise.
(Output_segment::has_dynamic_reloc): New function replacing
dynamic_reloc_count. Change all callers.
(Output_segment::has_dynamic_reloc_list): New function replacing
dynamic_reloc_count_list. Change all callers.
(Output_segment::set_section_addresses): Rewrite.
(Output_segment::set_offset): Rewrite.
(Output_segment::find_first_and_last_list): Remove.
(Output_segment::set_tls_offsets): Rewrite.
(Output_segment::first_section_load_address): Likewise.
(Output_segment::output_section_count): Likewise.
(Output_segment::section_with_lowest_load_address): Likewise.
(Output_segment::write_section_headers): Likewise.
(Output_segment::print_sections_to_map): Likewise.
* output.h (class Output_data): Remove dynamic_reloc_count_
field. Add has_dynamic_reloc_ field. Make bools into bitfields.
(Output_data::add_dynamic_reloc): Rewrite.
(Output_data::has_dynamic_reloc): New function.
(Output_data::dynamic_reloc_count): Remove.
(class Output_section): Add order_ field. Remvoe is_relro_local_,
is_last_relro_, is_first_non_relro_, is_interp_,
is_dynamic_linker_section_ fields. Add order and set_order
functions. Remove is_relro_local, set_is_relro_local,
is_last_relro, set_is_last_relro, is_first_non_relro,
set_is_first_non_relro functions, is_interp, set_is_interp,
is_dynamic_linker_section, and set_is_dynamic_linker_section
functions.
(class Output_segment): Change Output_data_list from std::list to
std:;vector. Add output_lists_ field. Remove output_data_ and
output_bss_ fields. Update declarations.
2010-08-03 16:07:13 +02:00
|
|
|
oseg->add_output_section_to_nonload(*pnext, seg_flags);
|
2008-02-04 06:43:05 +01:00
|
|
|
p = pnext;
|
|
|
|
++pnext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (((*p)->flags() & elfcpp::SHF_TLS) != 0)
|
|
|
|
{
|
|
|
|
if (saw_tls)
|
|
|
|
gold_error(_("TLS sections are not adjacent"));
|
|
|
|
|
|
|
|
elfcpp::Elf_Word seg_flags =
|
|
|
|
Layout::section_flags_to_segment((*p)->flags());
|
|
|
|
Output_segment* oseg = layout->make_output_segment(elfcpp::PT_TLS,
|
|
|
|
seg_flags);
|
2010-08-03 Ian Lance Taylor <iant@google.com>
PR 11805
* layout.h (enum Output_section_order): Define.
(class Layout): Update declarations.
* layout.cc (Layout::get_output_section): Add order parameter.
Remove is_interp, is_dynamic_linker_section, is_last_relro, and
is_first_non_relro parameters. Change all callers.
(Layout::choose_output_section): Likewise.
(Layout::add_output_section_data): Likewise.
(Layout::make_output_section): Likewise. Set order.
(Layout::default_section_order): New function.
(Layout::layout_eh_frame): Call add_output_section_to_nonload.
* output.cc (Output_section::Output_section): Initialize order_.
Don't initialize deleted fields.
(Output_segment::Output_segment): Don't initialize deleted
fields.
(Output_segment::add_output_section_to_load): New function
replacing add_output_section. Change all callers to call this or
add_output_section_to_nonload.
(Output_segment::add_output_section_to_nonload): New function.
(Output_segment::remove_output_section): Rewrite.
(Output_segment::add_initial_output_data): Likewise.
(Output_segment::has_any_data_sections): Likewise.
(Output_segment::is_first_section_relro): Likewise.
(Output_segment::maximum_alignment): Likewise.
(Output_segment::has_dynamic_reloc): New function replacing
dynamic_reloc_count. Change all callers.
(Output_segment::has_dynamic_reloc_list): New function replacing
dynamic_reloc_count_list. Change all callers.
(Output_segment::set_section_addresses): Rewrite.
(Output_segment::set_offset): Rewrite.
(Output_segment::find_first_and_last_list): Remove.
(Output_segment::set_tls_offsets): Rewrite.
(Output_segment::first_section_load_address): Likewise.
(Output_segment::output_section_count): Likewise.
(Output_segment::section_with_lowest_load_address): Likewise.
(Output_segment::write_section_headers): Likewise.
(Output_segment::print_sections_to_map): Likewise.
* output.h (class Output_data): Remove dynamic_reloc_count_
field. Add has_dynamic_reloc_ field. Make bools into bitfields.
(Output_data::add_dynamic_reloc): Rewrite.
(Output_data::has_dynamic_reloc): New function.
(Output_data::dynamic_reloc_count): Remove.
(class Output_section): Add order_ field. Remvoe is_relro_local_,
is_last_relro_, is_first_non_relro_, is_interp_,
is_dynamic_linker_section_ fields. Add order and set_order
functions. Remove is_relro_local, set_is_relro_local,
is_last_relro, set_is_last_relro, is_first_non_relro,
set_is_first_non_relro functions, is_interp, set_is_interp,
is_dynamic_linker_section, and set_is_dynamic_linker_section
functions.
(class Output_segment): Change Output_data_list from std::list to
std:;vector. Add output_lists_ field. Remove output_data_ and
output_bss_ fields. Update declarations.
2010-08-03 16:07:13 +02:00
|
|
|
oseg->add_output_section_to_nonload(*p, seg_flags);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
|
|
|
Layout::Section_list::const_iterator pnext = p + 1;
|
|
|
|
while (pnext != sections->end()
|
|
|
|
&& ((*pnext)->flags() & elfcpp::SHF_TLS) != 0)
|
|
|
|
{
|
|
|
|
seg_flags = Layout::section_flags_to_segment((*pnext)->flags());
|
2010-08-03 Ian Lance Taylor <iant@google.com>
PR 11805
* layout.h (enum Output_section_order): Define.
(class Layout): Update declarations.
* layout.cc (Layout::get_output_section): Add order parameter.
Remove is_interp, is_dynamic_linker_section, is_last_relro, and
is_first_non_relro parameters. Change all callers.
(Layout::choose_output_section): Likewise.
(Layout::add_output_section_data): Likewise.
(Layout::make_output_section): Likewise. Set order.
(Layout::default_section_order): New function.
(Layout::layout_eh_frame): Call add_output_section_to_nonload.
* output.cc (Output_section::Output_section): Initialize order_.
Don't initialize deleted fields.
(Output_segment::Output_segment): Don't initialize deleted
fields.
(Output_segment::add_output_section_to_load): New function
replacing add_output_section. Change all callers to call this or
add_output_section_to_nonload.
(Output_segment::add_output_section_to_nonload): New function.
(Output_segment::remove_output_section): Rewrite.
(Output_segment::add_initial_output_data): Likewise.
(Output_segment::has_any_data_sections): Likewise.
(Output_segment::is_first_section_relro): Likewise.
(Output_segment::maximum_alignment): Likewise.
(Output_segment::has_dynamic_reloc): New function replacing
dynamic_reloc_count. Change all callers.
(Output_segment::has_dynamic_reloc_list): New function replacing
dynamic_reloc_count_list. Change all callers.
(Output_segment::set_section_addresses): Rewrite.
(Output_segment::set_offset): Rewrite.
(Output_segment::find_first_and_last_list): Remove.
(Output_segment::set_tls_offsets): Rewrite.
(Output_segment::first_section_load_address): Likewise.
(Output_segment::output_section_count): Likewise.
(Output_segment::section_with_lowest_load_address): Likewise.
(Output_segment::write_section_headers): Likewise.
(Output_segment::print_sections_to_map): Likewise.
* output.h (class Output_data): Remove dynamic_reloc_count_
field. Add has_dynamic_reloc_ field. Make bools into bitfields.
(Output_data::add_dynamic_reloc): Rewrite.
(Output_data::has_dynamic_reloc): New function.
(Output_data::dynamic_reloc_count): Remove.
(class Output_section): Add order_ field. Remvoe is_relro_local_,
is_last_relro_, is_first_non_relro_, is_interp_,
is_dynamic_linker_section_ fields. Add order and set_order
functions. Remove is_relro_local, set_is_relro_local,
is_last_relro, set_is_last_relro, is_first_non_relro,
set_is_first_non_relro functions, is_interp, set_is_interp,
is_dynamic_linker_section, and set_is_dynamic_linker_section
functions.
(class Output_segment): Change Output_data_list from std::list to
std:;vector. Add output_lists_ field. Remove output_data_ and
output_bss_ fields. Update declarations.
2010-08-03 16:07:13 +02:00
|
|
|
oseg->add_output_section_to_nonload(*pnext, seg_flags);
|
2008-02-04 06:43:05 +01:00
|
|
|
p = pnext;
|
|
|
|
++pnext;
|
|
|
|
}
|
|
|
|
|
|
|
|
saw_tls = true;
|
|
|
|
}
|
2011-06-17 15:00:01 +02:00
|
|
|
|
2015-06-04 05:30:11 +02:00
|
|
|
// If we see a section named .interp then put the .interp section
|
|
|
|
// in a PT_INTERP segment.
|
2011-06-20 00:09:17 +02:00
|
|
|
// This is for GNU ld compatibility.
|
|
|
|
if (strcmp((*p)->name(), ".interp") == 0)
|
2011-06-17 15:00:01 +02:00
|
|
|
{
|
|
|
|
elfcpp::Elf_Word seg_flags =
|
|
|
|
Layout::section_flags_to_segment((*p)->flags());
|
|
|
|
Output_segment* oseg = layout->make_output_segment(elfcpp::PT_INTERP,
|
|
|
|
seg_flags);
|
|
|
|
oseg->add_output_section_to_nonload(*p, seg_flags);
|
|
|
|
}
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
2015-06-04 05:30:11 +02:00
|
|
|
|
|
|
|
this->segments_created_ = true;
|
2008-02-04 06:43:05 +01:00
|
|
|
}
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// Add a program header. The PHDRS clause is syntactically distinct
|
|
|
|
// from the SECTIONS clause, but we implement it with the SECTIONS
|
2009-06-24 21:00:15 +02:00
|
|
|
// support because PHDRS is useless if there is no SECTIONS clause.
|
2008-02-04 23:54:31 +01:00
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::add_phdr(const char* name, size_t namelen, unsigned int type,
|
|
|
|
bool includes_filehdr, bool includes_phdrs,
|
|
|
|
bool is_flags_valid, unsigned int flags,
|
|
|
|
Expression* load_address)
|
|
|
|
{
|
|
|
|
if (this->phdrs_elements_ == NULL)
|
|
|
|
this->phdrs_elements_ = new Phdrs_elements();
|
|
|
|
this->phdrs_elements_->push_back(new Phdrs_element(name, namelen, type,
|
|
|
|
includes_filehdr,
|
|
|
|
includes_phdrs,
|
|
|
|
is_flags_valid, flags,
|
|
|
|
load_address));
|
|
|
|
}
|
|
|
|
|
2008-02-04 07:45:50 +01:00
|
|
|
// Return the number of segments we expect to create based on the
|
|
|
|
// SECTIONS clause. This is used to implement SIZEOF_HEADERS.
|
|
|
|
|
|
|
|
size_t
|
|
|
|
Script_sections::expected_segment_count(const Layout* layout) const
|
|
|
|
{
|
2015-06-04 05:30:11 +02:00
|
|
|
// If we've already created the segments, we won't be adding any more.
|
|
|
|
if (this->segments_created_)
|
|
|
|
return 0;
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
if (this->saw_phdrs_clause())
|
|
|
|
return this->phdrs_elements_->size();
|
|
|
|
|
2008-02-04 07:45:50 +01:00
|
|
|
Layout::Section_list sections;
|
|
|
|
layout->get_allocated_sections(§ions);
|
|
|
|
|
|
|
|
// We assume that we will need two PT_LOAD segments.
|
|
|
|
size_t ret = 2;
|
|
|
|
|
|
|
|
bool saw_note = false;
|
|
|
|
bool saw_tls = false;
|
2015-06-04 05:30:11 +02:00
|
|
|
bool saw_interp = false;
|
2008-02-04 07:45:50 +01:00
|
|
|
for (Layout::Section_list::const_iterator p = sections.begin();
|
|
|
|
p != sections.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if ((*p)->type() == elfcpp::SHT_NOTE)
|
|
|
|
{
|
|
|
|
// Assume that all note sections will fit into a single
|
|
|
|
// PT_NOTE segment.
|
|
|
|
if (!saw_note)
|
|
|
|
{
|
|
|
|
++ret;
|
|
|
|
saw_note = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (((*p)->flags() & elfcpp::SHF_TLS) != 0)
|
|
|
|
{
|
|
|
|
// There can only be one PT_TLS segment.
|
|
|
|
if (!saw_tls)
|
|
|
|
{
|
|
|
|
++ret;
|
|
|
|
saw_tls = true;
|
|
|
|
}
|
|
|
|
}
|
2015-06-04 05:30:11 +02:00
|
|
|
else if (strcmp((*p)->name(), ".interp") == 0)
|
|
|
|
{
|
|
|
|
// There can only be one PT_INTERP segment.
|
|
|
|
if (!saw_interp)
|
|
|
|
{
|
|
|
|
++ret;
|
|
|
|
saw_interp = true;
|
|
|
|
}
|
|
|
|
}
|
2008-02-04 07:45:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// Create the segments from a PHDRS clause. Return the segment which
|
|
|
|
// should hold the file header and program headers, if any.
|
|
|
|
|
|
|
|
Output_segment*
|
2010-04-23 06:47:33 +02:00
|
|
|
Script_sections::create_segments_from_phdrs_clause(Layout* layout,
|
|
|
|
uint64_t dot_alignment)
|
2008-02-04 23:54:31 +01:00
|
|
|
{
|
|
|
|
this->attach_sections_using_phdrs_clause(layout);
|
2010-04-23 06:47:33 +02:00
|
|
|
return this->set_phdrs_clause_addresses(layout, dot_alignment);
|
2008-02-04 23:54:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Create the segments from the PHDRS clause, and put the output
|
|
|
|
// sections in them.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::attach_sections_using_phdrs_clause(Layout* layout)
|
|
|
|
{
|
|
|
|
typedef std::map<std::string, Output_segment*> Name_to_segment;
|
|
|
|
Name_to_segment name_to_segment;
|
|
|
|
for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
|
|
|
|
p != this->phdrs_elements_->end();
|
|
|
|
++p)
|
|
|
|
name_to_segment[(*p)->name()] = (*p)->create_segment(layout);
|
2015-06-04 05:30:11 +02:00
|
|
|
this->segments_created_ = true;
|
2008-02-04 23:54:31 +01:00
|
|
|
|
|
|
|
// Walk through the output sections and attach them to segments.
|
|
|
|
// Output sections in the script which do not list segments are
|
|
|
|
// attached to the same set of segments as the immediately preceding
|
|
|
|
// output section.
|
2016-08-12 18:55:25 +02:00
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
String_list* phdr_names = NULL;
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
bool load_segments_only = false;
|
2008-02-04 23:54:31 +01:00
|
|
|
for (Sections_elements::const_iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
|
|
|
{
|
2011-06-29 02:39:54 +02:00
|
|
|
bool is_orphan;
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
String_list* old_phdr_names = phdr_names;
|
2011-06-29 02:39:54 +02:00
|
|
|
Output_section* os = (*p)->allocate_to_segment(&phdr_names, &is_orphan);
|
2008-02-04 23:54:31 +01:00
|
|
|
if (os == NULL)
|
|
|
|
continue;
|
|
|
|
|
2011-06-29 02:39:54 +02:00
|
|
|
elfcpp::Elf_Word seg_flags =
|
|
|
|
Layout::section_flags_to_segment(os->flags());
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
if (phdr_names == NULL)
|
|
|
|
{
|
2011-06-29 02:39:54 +02:00
|
|
|
// Don't worry about empty orphan sections.
|
|
|
|
if (is_orphan && os->current_data_size() > 0)
|
|
|
|
gold_error(_("allocated section %s not in any segment"),
|
|
|
|
os->name());
|
|
|
|
|
|
|
|
// To avoid later crashes drop this section into the first
|
|
|
|
// PT_LOAD segment.
|
|
|
|
for (Phdrs_elements::const_iterator ppe =
|
|
|
|
this->phdrs_elements_->begin();
|
|
|
|
ppe != this->phdrs_elements_->end();
|
|
|
|
++ppe)
|
|
|
|
{
|
|
|
|
Output_segment* oseg = (*ppe)->segment();
|
|
|
|
if (oseg->type() == elfcpp::PT_LOAD)
|
|
|
|
{
|
|
|
|
oseg->add_output_section_to_load(layout, os, seg_flags);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
// We see a list of segments names. Disable PT_LOAD segment only
|
|
|
|
// filtering.
|
|
|
|
if (old_phdr_names != phdr_names)
|
|
|
|
load_segments_only = false;
|
2016-08-12 18:55:25 +02:00
|
|
|
|
2008-04-10 03:02:46 +02:00
|
|
|
// If this is an orphan section--one that was not explicitly
|
|
|
|
// mentioned in the linker script--then it should not inherit
|
|
|
|
// any segment type other than PT_LOAD. Otherwise, e.g., the
|
|
|
|
// PT_INTERP segment will pick up following orphan sections,
|
|
|
|
// which does not make sense. If this is not an orphan section,
|
|
|
|
// we trust the linker script.
|
2011-06-29 02:39:54 +02:00
|
|
|
if (is_orphan)
|
2008-04-10 03:02:46 +02:00
|
|
|
{
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
// Enable PT_LOAD segments only filtering until we see another
|
|
|
|
// list of segment names.
|
|
|
|
load_segments_only = true;
|
2008-04-10 03:02:46 +02:00
|
|
|
}
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
bool in_load_segment = false;
|
|
|
|
for (String_list::const_iterator q = phdr_names->begin();
|
|
|
|
q != phdr_names->end();
|
|
|
|
++q)
|
|
|
|
{
|
|
|
|
Name_to_segment::const_iterator r = name_to_segment.find(*q);
|
|
|
|
if (r == name_to_segment.end())
|
|
|
|
gold_error(_("no segment %s"), q->c_str());
|
|
|
|
else
|
|
|
|
{
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
if (load_segments_only
|
|
|
|
&& r->second->type() != elfcpp::PT_LOAD)
|
|
|
|
continue;
|
|
|
|
|
2010-08-03 Ian Lance Taylor <iant@google.com>
PR 11805
* layout.h (enum Output_section_order): Define.
(class Layout): Update declarations.
* layout.cc (Layout::get_output_section): Add order parameter.
Remove is_interp, is_dynamic_linker_section, is_last_relro, and
is_first_non_relro parameters. Change all callers.
(Layout::choose_output_section): Likewise.
(Layout::add_output_section_data): Likewise.
(Layout::make_output_section): Likewise. Set order.
(Layout::default_section_order): New function.
(Layout::layout_eh_frame): Call add_output_section_to_nonload.
* output.cc (Output_section::Output_section): Initialize order_.
Don't initialize deleted fields.
(Output_segment::Output_segment): Don't initialize deleted
fields.
(Output_segment::add_output_section_to_load): New function
replacing add_output_section. Change all callers to call this or
add_output_section_to_nonload.
(Output_segment::add_output_section_to_nonload): New function.
(Output_segment::remove_output_section): Rewrite.
(Output_segment::add_initial_output_data): Likewise.
(Output_segment::has_any_data_sections): Likewise.
(Output_segment::is_first_section_relro): Likewise.
(Output_segment::maximum_alignment): Likewise.
(Output_segment::has_dynamic_reloc): New function replacing
dynamic_reloc_count. Change all callers.
(Output_segment::has_dynamic_reloc_list): New function replacing
dynamic_reloc_count_list. Change all callers.
(Output_segment::set_section_addresses): Rewrite.
(Output_segment::set_offset): Rewrite.
(Output_segment::find_first_and_last_list): Remove.
(Output_segment::set_tls_offsets): Rewrite.
(Output_segment::first_section_load_address): Likewise.
(Output_segment::output_section_count): Likewise.
(Output_segment::section_with_lowest_load_address): Likewise.
(Output_segment::write_section_headers): Likewise.
(Output_segment::print_sections_to_map): Likewise.
* output.h (class Output_data): Remove dynamic_reloc_count_
field. Add has_dynamic_reloc_ field. Make bools into bitfields.
(Output_data::add_dynamic_reloc): Rewrite.
(Output_data::has_dynamic_reloc): New function.
(Output_data::dynamic_reloc_count): Remove.
(class Output_section): Add order_ field. Remvoe is_relro_local_,
is_last_relro_, is_first_non_relro_, is_interp_,
is_dynamic_linker_section_ fields. Add order and set_order
functions. Remove is_relro_local, set_is_relro_local,
is_last_relro, set_is_last_relro, is_first_non_relro,
set_is_first_non_relro functions, is_interp, set_is_interp,
is_dynamic_linker_section, and set_is_dynamic_linker_section
functions.
(class Output_segment): Change Output_data_list from std::list to
std:;vector. Add output_lists_ field. Remove output_data_ and
output_bss_ fields. Update declarations.
2010-08-03 16:07:13 +02:00
|
|
|
if (r->second->type() != elfcpp::PT_LOAD)
|
|
|
|
r->second->add_output_section_to_nonload(os, seg_flags);
|
|
|
|
else
|
2008-02-04 23:54:31 +01:00
|
|
|
{
|
2010-08-03 Ian Lance Taylor <iant@google.com>
PR 11805
* layout.h (enum Output_section_order): Define.
(class Layout): Update declarations.
* layout.cc (Layout::get_output_section): Add order parameter.
Remove is_interp, is_dynamic_linker_section, is_last_relro, and
is_first_non_relro parameters. Change all callers.
(Layout::choose_output_section): Likewise.
(Layout::add_output_section_data): Likewise.
(Layout::make_output_section): Likewise. Set order.
(Layout::default_section_order): New function.
(Layout::layout_eh_frame): Call add_output_section_to_nonload.
* output.cc (Output_section::Output_section): Initialize order_.
Don't initialize deleted fields.
(Output_segment::Output_segment): Don't initialize deleted
fields.
(Output_segment::add_output_section_to_load): New function
replacing add_output_section. Change all callers to call this or
add_output_section_to_nonload.
(Output_segment::add_output_section_to_nonload): New function.
(Output_segment::remove_output_section): Rewrite.
(Output_segment::add_initial_output_data): Likewise.
(Output_segment::has_any_data_sections): Likewise.
(Output_segment::is_first_section_relro): Likewise.
(Output_segment::maximum_alignment): Likewise.
(Output_segment::has_dynamic_reloc): New function replacing
dynamic_reloc_count. Change all callers.
(Output_segment::has_dynamic_reloc_list): New function replacing
dynamic_reloc_count_list. Change all callers.
(Output_segment::set_section_addresses): Rewrite.
(Output_segment::set_offset): Rewrite.
(Output_segment::find_first_and_last_list): Remove.
(Output_segment::set_tls_offsets): Rewrite.
(Output_segment::first_section_load_address): Likewise.
(Output_segment::output_section_count): Likewise.
(Output_segment::section_with_lowest_load_address): Likewise.
(Output_segment::write_section_headers): Likewise.
(Output_segment::print_sections_to_map): Likewise.
* output.h (class Output_data): Remove dynamic_reloc_count_
field. Add has_dynamic_reloc_ field. Make bools into bitfields.
(Output_data::add_dynamic_reloc): Rewrite.
(Output_data::has_dynamic_reloc): New function.
(Output_data::dynamic_reloc_count): Remove.
(class Output_section): Add order_ field. Remvoe is_relro_local_,
is_last_relro_, is_first_non_relro_, is_interp_,
is_dynamic_linker_section_ fields. Add order and set_order
functions. Remove is_relro_local, set_is_relro_local,
is_last_relro, set_is_last_relro, is_first_non_relro,
set_is_first_non_relro functions, is_interp, set_is_interp,
is_dynamic_linker_section, and set_is_dynamic_linker_section
functions.
(class Output_segment): Change Output_data_list from std::list to
std:;vector. Add output_lists_ field. Remove output_data_ and
output_bss_ fields. Update declarations.
2010-08-03 16:07:13 +02:00
|
|
|
r->second->add_output_section_to_load(layout, os, seg_flags);
|
2008-02-04 23:54:31 +01:00
|
|
|
if (in_load_segment)
|
|
|
|
gold_error(_("section in two PT_LOAD segments"));
|
|
|
|
in_load_segment = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!in_load_segment)
|
|
|
|
gold_error(_("allocated section not in any PT_LOAD segment"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the addresses for segments created from a PHDRS clause. Return
|
|
|
|
// the segment which should hold the file header and program headers,
|
|
|
|
// if any.
|
|
|
|
|
|
|
|
Output_segment*
|
2010-04-23 06:47:33 +02:00
|
|
|
Script_sections::set_phdrs_clause_addresses(Layout* layout,
|
|
|
|
uint64_t dot_alignment)
|
2008-02-04 23:54:31 +01:00
|
|
|
{
|
|
|
|
Output_segment* load_seg = NULL;
|
|
|
|
for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
|
|
|
|
p != this->phdrs_elements_->end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
// Note that we have to set the flags after adding the output
|
|
|
|
// sections to the segment, as adding an output segment can
|
|
|
|
// change the flags.
|
|
|
|
(*p)->set_flags_if_valid();
|
|
|
|
|
|
|
|
Output_segment* oseg = (*p)->segment();
|
|
|
|
|
|
|
|
if (oseg->type() != elfcpp::PT_LOAD)
|
|
|
|
{
|
|
|
|
// The addresses of non-PT_LOAD segments are set from the
|
|
|
|
// PT_LOAD segments.
|
|
|
|
if ((*p)->has_load_address())
|
|
|
|
gold_error(_("may only specify load address for PT_LOAD segment"));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-04-23 06:47:33 +02:00
|
|
|
oseg->set_minimum_p_align(dot_alignment);
|
|
|
|
|
2008-02-04 23:54:31 +01:00
|
|
|
// The output sections should have addresses from the SECTIONS
|
|
|
|
// clause. The addresses don't have to be in order, so find the
|
|
|
|
// one with the lowest load address. Use that to set the
|
|
|
|
// address of the segment.
|
|
|
|
|
|
|
|
Output_section* osec = oseg->section_with_lowest_load_address();
|
|
|
|
if (osec == NULL)
|
|
|
|
{
|
|
|
|
oseg->set_addresses(0, 0);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t vma = osec->address();
|
|
|
|
uint64_t lma = osec->has_load_address() ? osec->load_address() : vma;
|
|
|
|
|
|
|
|
// Override the load address of the section with the load
|
|
|
|
// address specified for the segment.
|
|
|
|
if ((*p)->has_load_address())
|
|
|
|
{
|
|
|
|
if (osec->has_load_address())
|
|
|
|
gold_warning(_("PHDRS load address overrides "
|
|
|
|
"section %s load address"),
|
|
|
|
osec->name());
|
|
|
|
|
|
|
|
lma = (*p)->load_address();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool headers = (*p)->includes_filehdr() && (*p)->includes_phdrs();
|
|
|
|
if (!headers && ((*p)->includes_filehdr() || (*p)->includes_phdrs()))
|
|
|
|
{
|
|
|
|
// We could support this if we wanted to.
|
|
|
|
gold_error(_("using only one of FILEHDR and PHDRS is "
|
|
|
|
"not currently supported"));
|
|
|
|
}
|
|
|
|
if (headers)
|
|
|
|
{
|
|
|
|
size_t sizeof_headers = this->total_header_size(layout);
|
|
|
|
uint64_t subtract = this->header_size_adjustment(lma,
|
|
|
|
sizeof_headers);
|
|
|
|
if (lma >= subtract && vma >= subtract)
|
|
|
|
{
|
|
|
|
lma -= subtract;
|
|
|
|
vma -= subtract;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
gold_error(_("sections loaded on first page without room "
|
|
|
|
"for file and program headers "
|
|
|
|
"are not supported"));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (load_seg != NULL)
|
|
|
|
gold_error(_("using FILEHDR and PHDRS on more than one "
|
|
|
|
"PT_LOAD segment is not currently supported"));
|
|
|
|
load_seg = oseg;
|
|
|
|
}
|
|
|
|
|
|
|
|
oseg->set_addresses(vma, lma);
|
|
|
|
}
|
|
|
|
|
|
|
|
return load_seg;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add the file header and segment headers to non-load segments
|
|
|
|
// specified in the PHDRS clause.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::put_headers_in_phdrs(Output_data* file_header,
|
|
|
|
Output_data* segment_headers)
|
|
|
|
{
|
|
|
|
gold_assert(this->saw_phdrs_clause());
|
|
|
|
for (Phdrs_elements::iterator p = this->phdrs_elements_->begin();
|
|
|
|
p != this->phdrs_elements_->end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if ((*p)->type() != elfcpp::PT_LOAD)
|
|
|
|
{
|
|
|
|
if ((*p)->includes_phdrs())
|
|
|
|
(*p)->segment()->add_initial_output_data(segment_headers);
|
|
|
|
if ((*p)->includes_filehdr())
|
|
|
|
(*p)->segment()->add_initial_output_data(file_header);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-29 01:04:06 +01:00
|
|
|
// Look for an output section by name and return the address, the load
|
|
|
|
// address, the alignment, and the size. This is used when an
|
|
|
|
// expression refers to an output section which was not actually
|
|
|
|
// created. This returns true if the section was found, false
|
|
|
|
// otherwise.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Script_sections::get_output_section_info(const char* name, uint64_t* address,
|
|
|
|
uint64_t* load_address,
|
2009-12-14 20:53:05 +01:00
|
|
|
uint64_t* addralign,
|
2008-02-29 01:04:06 +01:00
|
|
|
uint64_t* size) const
|
|
|
|
{
|
|
|
|
if (!this->saw_sections_clause_)
|
|
|
|
return false;
|
|
|
|
for (Sections_elements::const_iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
2009-12-14 20:53:05 +01:00
|
|
|
if ((*p)->get_output_section_info(name, address, load_address, addralign,
|
2008-02-29 01:04:06 +01:00
|
|
|
size))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
// Release all Output_segments. This remove all pointers to all
|
|
|
|
// Output_segments.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::release_segments()
|
|
|
|
{
|
|
|
|
if (this->saw_phdrs_clause())
|
|
|
|
{
|
|
|
|
for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
|
|
|
|
p != this->phdrs_elements_->end();
|
|
|
|
++p)
|
|
|
|
(*p)->release_segment();
|
|
|
|
}
|
2016-08-12 18:55:25 +02:00
|
|
|
this->segments_created_ = false;
|
2009-09-17 Doug Kwan <dougkwan@google.com>
* debug.h (DEBUG_RELAXATION): New constant.
(DEBUG_ALL): Add DEBUG_RELAXATION.
(debug_string_to_enum): Add relaxation debug option.
* layout.cc
(Layout::Relaxation_debug_check::check_output_data_for_reset_values,
Layout::Relaxation_debug_check::read_sections,
Layout::Relaxation_debug_check::read_sections): New method definitions.
(Layout::Layout): Initialize data members
record_output_section_data_from_scrips_,
script_output_section_data_list_ and relaxation_debug_check_.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method definitions.
(Layout::finalize): Support relaxation. Move section layout code to
Layout::relaxation_loop_body.
(Layout::set_asection_address_from_script): Move code for orphan
section placement out.
(Layout::place_orphan_sections_in_script): New method definition.
* layout.h (Output_segment_headers, Output_file_header):
New forward class declarations.
(Layout::~Layout): Define.
(Layout::new_output_section_data_from_script): New method definition.
(Layout::place_orphan_sections_in_script): New method declaration.
(Layout::Segment_states): New type declaration.
(Layout::save_segments, Layout::restore_segments,
Layout::clean_up_after_relaxation, Layout::prepare_for_relaxation,
Layout::relaxation_loop_body): New method declarations.
(Layout::Output_section_data_list): New type declaration.
(Layout::Relaxation_debug_check): New class definition.
(Layout::record_output_section_data_from_script_,
Layout::script_output_section_data_list_, Layout::segment_states_,
Layout::relaxation_debug_check_): New data members.
* output.cc: (Output_section_headers::do_size): New method definition.
(Output_section_headers::Output_section_headers): Move size
computation to Output_section_headers::do_size.
(Output_segment_headers::do_size): New method definition.
(Output_file_header::Output_file_header): Move size computation to
Output_file_header::do_size and call it.
(Output_file_header::do_size): New method definition.
(Output_data_group::Output_data_group): Adjust call to
Output_section_data.
(Output_data_dynamic::set_final_data_size): Add DT_NULL tag only once.
(Output_symtab_xindex::do_write): Add array bound check.
(Output_section::Input_section::print_to_mapfile): Handle
RELAXED_INPUT_SECTION_CODE.
(Output_section::Output_section): Initialize data member checkpoint_.
(Output_section::~Output_section): Delete checkpoint object pointed
by checkpoint_.
(Output_section::add_input_section): Always add an Input_section if
relaxing.
(Output_section::add_merge_input_section): Add assert.
(Output_section::relax_input_section): New method definition.
(Output_section::set_final_data_size): Set load address to zero for
an unallocated section.
(Output_section::do_address_and_file_offset_have_reset_values):
New method definition.
(Output_section::Input_section_sort_enty::Input_section_sort_enty):
Handle relaxed input section.
(Output_section::sort_attached_input_sections): Checkpoint input
section list lazily.
(Output_section::get_input_sections): Change type of input_sections to
list of Simple_input_section pointers. Checkpoint input section list
lazily. Also handle relaxed input sections.
(Output_section::add_input_section_for_script): Take a reference to
a Simple_input_section object instead of Relobj pointer and section
index as parameter. Handle relaxed input sections.
(Output_section::save_states, Output_section::restore_states): New
method definitions.
* output.h (Output_data::Output_data): Initialize is_data_size_fixed_.
(Output_data::is_data_size_fixed): New method definition.
(Output_data::reset_addresss_and_file_offset): Do not reset data size
if it is fixed.
(Output_data::address_and_file_offset_have_reset_values): New method
definition.
(Output_data::do_address_and_file_offset_have_reset_values): New method
definition.
(Output_data::set_data_size): Check that data size is not fixed.
(Output_data::fix_data_size): New method definition.
(Output_data::is_data_size_fixed_): New data member.
(Output_section_headers::set_final_data_size): New method definition.
(Output_section_headers::do_size): New method declaration.
(Output_segment_headers::set_final_data_size): New method definition.
(Output_segment_headers::do_size): New method declaration.
(Output_file_header::set_final_data_size)::New method definition.
(Output_file_header::do_size)::New method declaration.
(Output_section_data::Output_section_data): Add new parameter
is_data_size_fixed and use it to fix data size.
(Output_data_const::Output_data_const): Adjust call to base class
constructor and fix data size.
(Output_data_const_buffer::Output_data_const_buffer): Adjust call to
base class constructor and fix data size.
(Output_data_fixed_space::Output_data_fixed_space): Adjust call to
base class constructor and fix data size.
(Output_data_zero_fill::Output_data_zero_fill): Adjust call to base
class constructor and fix data size.
(Output_data_group::set_final_data_size): New method definition.
(Output_data_dynamic::Dynamic_entry::tag): New method definition.
(Output_symtab_xindex::Output_symtab_xindex): Adjust call to base
class constructor and fix data size.
(Output_relaxed_input_section): New class definition.
(Output_section::Simple_input_section): New class definition.
(Output_section::get_input_sections): Adjust parameter list.
(Output_section::add_input_section_for_script): Same.
(Output_section::save_states, Output_section::restore_states,
Output_section::do_address_and_file_offset_have_reset_values,
(Output_section::Input_section::Input_section): Handle
RELAXED_INPUT_SECTION_CODE. Add new overload for
Output_relaxed_input_section.
(Output_section::Input_section::is_input_section,
Output_section::Input_section::set_output_section): Handle relaxed
input section.
(Output_section::Input_section::is_relaxed_input_section,
Output_section::Input_section::output_section_data,
Output_section::Input_section::relaxed_input_section): New method
definitions.
(Output_section::Input_section::RELAXED_INPUT_SECTION_CODE): New enum
value.
(Output_section::Input_section::u1_): Update comments.
(Output_section::Input_section::u2_): Add new union member poris.
(Output_section::Checkpoint_output_section): New classs definition.
(Output_section::relax_input_section): New method declaration.
(Output_section::checkpoint_): New data member.
(Output_segment): Update comments.
(Output_segment::Output_segment): Un-privatize copy constructor.
(Output_segment::operator=): Un-privatize.
* script-sections.cc (Output_section_element::Input_section_list):
Change element type to Output_section::Simple_input_section.
(Output_section_element_dot_assignment::set_section_addresses):
Register output section data for relaxation clean up.
(Output_data_exression::Output_data_expression): Adjust call to base
constructor to fix data size.
(Output_section_element_data::set_section_addresses): Register
Output_data_expression object for relaxation clean up.
(struct Input_section_info): Replace Relobj pointer and section index
pair with Output_section::Simple_input_section and Convert struct to a
class.
(Input_section_sorter::operator()): Adjust access to
Input_section_info data member to use accessors.
(Output_section_element_input::set_section_addresses): Use layout
parameter. Adjust code to use Output_section::Simple_input_section
and Input_secction_info classes. Register filler for relaxation
clean up.
(Orphan_output_section::set_section_addresses): Replace Relobj pointer
and section index pair with Output_section::Simple_input_section
class. Adjust code accordingly.
(Phdrs_element::release_segment): New method definition.
(Script_sections::attach_sections_using_phdrs_clause): Do not modify
segment list.
(Script_sections::release_segments): New method definition.
* gold/script-sections.h (Script_sections::release_segments): New
method declaration.
* gold/target.h (Target::may_relax, Target::relax,
Target::do_may_relax, Target::do_relax): New method definitions.
2009-09-18 03:10:38 +02:00
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
// Print the SECTIONS clause to F for debugging.
|
|
|
|
|
|
|
|
void
|
|
|
|
Script_sections::print(FILE* f) const
|
|
|
|
{
|
2010-09-08 18:10:33 +02:00
|
|
|
if (this->phdrs_elements_ != NULL)
|
|
|
|
{
|
|
|
|
fprintf(f, "PHDRS {\n");
|
|
|
|
for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
|
|
|
|
p != this->phdrs_elements_->end();
|
|
|
|
++p)
|
|
|
|
(*p)->print(f);
|
|
|
|
fprintf(f, "}\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (this->memory_regions_ != NULL)
|
|
|
|
{
|
|
|
|
fprintf(f, "MEMORY {\n");
|
|
|
|
for (Memory_regions::const_iterator m = this->memory_regions_->begin();
|
|
|
|
m != this->memory_regions_->end();
|
|
|
|
++m)
|
|
|
|
(*m)->print(f);
|
|
|
|
fprintf(f, "}\n");
|
|
|
|
}
|
|
|
|
|
2008-01-23 02:31:13 +01:00
|
|
|
if (!this->saw_sections_clause_)
|
|
|
|
return;
|
|
|
|
|
|
|
|
fprintf(f, "SECTIONS {\n");
|
|
|
|
|
|
|
|
for (Sections_elements::const_iterator p = this->sections_elements_->begin();
|
|
|
|
p != this->sections_elements_->end();
|
|
|
|
++p)
|
|
|
|
(*p)->print(f);
|
|
|
|
|
|
|
|
fprintf(f, "}\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
} // End namespace gold.
|