const Arm_exidx_section_offset_map& section_offset_map,
uint32_t deleted_bytes);
+ // Build output contents.
+ void
+ build_contents(const unsigned char*, section_size_type);
+
// Return the original EXIDX input section.
const Arm_exidx_input_section&
exidx_input_section() const
const Arm_exidx_input_section& exidx_input_section_;
// Section offset map.
const Arm_exidx_section_offset_map& section_offset_map_;
+ // Merged section contents. We need to keep build the merged section
+ // and save it here to avoid accessing the original EXIDX section when
+ // we cannot lock the sections' object.
+ unsigned char* section_contents_;
};
// A class to wrap an ordinary input section containing executable code.
public:
Arm_input_section(Relobj* relobj, unsigned int shndx)
: Output_relaxed_input_section(relobj, shndx, 1),
- original_addralign_(1), original_size_(0), stub_table_(NULL)
+ original_addralign_(1), original_size_(0), stub_table_(NULL),
+ original_contents_(NULL)
{ }
~Arm_input_section()
- { }
+ { delete[] this->original_contents_; }
// Initialize.
void
uint32_t original_size_;
// Stub table.
Stub_table<big_endian>* stub_table_;
+ // Original section contents. We have to make a copy here since the file
+ // containing the original section may not be locked when we need to access
+ // the contents.
+ unsigned char* original_contents_;
};
// Arm_exidx_fixup class. This is used to define a number of methods
~Arm_exidx_fixup()
{ delete this->section_offset_map_; }
- // Process an EXIDX section for entry merging. Return number of bytes to
- // be deleted in output. If parts of the input EXIDX section are merged
- // a heap allocated Arm_exidx_section_offset_map is store in the located
- // PSECTION_OFFSET_MAP. The caller owns the map and is reponsible for
- // releasing it.
+ // Process an EXIDX section for entry merging. SECTION_CONTENTS points
+ // to the EXIDX contents and SECTION_SIZE is the size of the contents. Return
+ // number of bytes to be deleted in output. If parts of the input EXIDX
+ // section are merged a heap allocated Arm_exidx_section_offset_map is store
+ // in the located PSECTION_OFFSET_MAP. The caller owns the map and is
+ // reponsible for releasing it.
template<bool big_endian>
uint32_t
process_exidx_section(const Arm_exidx_input_section* exidx_input_section,
+ const unsigned char* section_contents,
+ section_size_type section_size,
Arm_exidx_section_offset_map** psection_offset_map);
// Append an EXIDX_CANTUNWIND entry pointing at the end of the last
// Group input sections for stub generation.
void
- group_sections(section_size_type, bool, Target_arm<big_endian>*);
+ group_sections(section_size_type, bool, Target_arm<big_endian>*, const Task*);
// Downcast a base pointer to an Arm_output_section pointer. This is
// not type-safe but we only use Arm_output_section not the base class.
fix_exidx_coverage(Layout* layout,
const Text_section_list& sorted_text_section,
Symbol_table* symtab,
- bool merge_exidx_entries);
+ bool merge_exidx_entries,
+ const Task* task);
// Link an EXIDX section into its corresponding text section.
void
Input_section_list::const_iterator,
Input_section_list::const_iterator,
Target_arm<big_endian>*,
- std::vector<Output_relaxed_input_section*>*);
+ std::vector<Output_relaxed_input_section*>*,
+ const Task* task);
};
// Arm_exidx_input_section class. This represents an EXIDX input section.
static_cast<section_offset_type>(-1);
Arm_exidx_input_section(Relobj* relobj, unsigned int shndx,
- unsigned int link, uint32_t size, uint32_t addralign)
+ unsigned int link, uint32_t size,
+ uint32_t addralign, uint32_t text_size)
: relobj_(relobj), shndx_(shndx), link_(link), size_(size),
- addralign_(addralign), has_errors_(false)
+ addralign_(addralign), text_size_(text_size), has_errors_(false)
{ }
~Arm_exidx_input_section()
size() const
{ return this->size_; }
- // Reutnr address alignment of EXIDX input section.
+ // Return address alignment of EXIDX input section.
uint32_t
addralign() const
{ return this->addralign_; }
+ // Return size of the associated text input section.
+ uint32_t
+ text_size() const
+ { return this->text_size_; }
+
// Whether there are any errors in the EXIDX input section.
bool
has_errors() const
uint32_t size_;
// Address alignment of this. For ARM 32-bit is sufficient.
uint32_t addralign_;
+ // Size of associated text section.
+ uint32_t text_size_;
// Whether this has any errors.
bool has_errors_;
};
{ return !parameters->options().relocatable(); }
bool
- do_relax(int, const Input_objects*, Symbol_table*, Layout*);
+ do_relax(int, const Input_objects*, Symbol_table*, Layout*, const Task*);
// Determine whether an object attribute tag takes an integer, a
// string or both.
// Group input sections for stub generation.
void
- group_sections(Layout*, section_size_type, bool);
+ group_sections(Layout*, section_size_type, bool, const Task*);
// Scan a relocation for stub generation.
void
// Fix .ARM.exidx section coverage.
void
fix_exidx_coverage(Layout*, const Input_objects*,
- Arm_output_section<big_endian>*, Symbol_table*);
+ Arm_output_section<big_endian>*, Symbol_table*,
+ const Task*);
// Functors for STL set.
struct output_section_address_less_than
Relobj* relobj = this->relobj();
unsigned int shndx = this->shndx();
- // Cache these to speed up size and alignment queries. It is too slow
- // to call section_addraglin and section_size every time.
+ // We have to cache original size, alignment and contents to avoid locking
+ // the original file.
this->original_addralign_ =
convert_types<uint32_t, uint64_t>(relobj->section_addralign(shndx));
+
+ // This is not efficient but we expect only a small number of relaxed
+ // input sections for stubs.
+ section_size_type section_size;
+ const unsigned char* section_contents =
+ relobj->section_contents(shndx, §ion_size, false);
this->original_size_ =
convert_types<uint32_t, uint64_t>(relobj->section_size(shndx));
+ gold_assert(this->original_contents_ == NULL);
+ this->original_contents_ = new unsigned char[section_size];
+ memcpy(this->original_contents_, section_contents, section_size);
+
// We want to make this look like the original input section after
// output sections are finalized.
Output_section* os = relobj->output_section(shndx);
Arm_input_section<big_endian>::do_write(Output_file* of)
{
// We have to write out the original section content.
- section_size_type section_size;
- const unsigned char* section_contents =
- this->relobj()->section_contents(this->shndx(), §ion_size, false);
- of->write(this->offset(), section_contents, section_size);
+ gold_assert(this->original_contents_ != NULL);
+ of->write(this->offset(), this->original_contents_,
+ this->original_size_);
// If this owns a stub table and it is not empty, write it.
if (this->is_stub_table_owner() && !this->stub_table_->empty())
Arm_address output_offset =
arm_relobj->get_output_section_offset(this->shndx_);
Arm_address section_start;
+ section_size_type section_size;
+
+ // Find out the end of the text section referred by this.
if (output_offset != Arm_relobj<big_endian>::invalid_address)
- section_start = os->address() + output_offset;
+ {
+ section_start = os->address() + output_offset;
+ const Arm_exidx_input_section* exidx_input_section =
+ arm_relobj->exidx_input_section_by_link(this->shndx_);
+ gold_assert(exidx_input_section != NULL);
+ section_size =
+ convert_to_section_size_type(exidx_input_section->text_size());
+ }
else
{
// Currently this only happens for a relaxed section.
os->find_relaxed_input_section(this->relobj_, this->shndx_);
gold_assert(poris != NULL);
section_start = poris->address();
+ section_size = convert_to_section_size_type(poris->data_size());
}
// We always append this to the end of an EXIDX section.
- Arm_address output_address =
- section_start + this->relobj_->section_size(this->shndx_);
+ Arm_address output_address = section_start + section_size;
// Write out the entry. The first word either points to the beginning
// or after the end of a text section. The second word is the special
exidx_input_section_(exidx_input_section),
section_offset_map_(section_offset_map)
{
+ // If we retain or discard the whole EXIDX input section, we would
+ // not be here.
+ gold_assert(deleted_bytes != 0
+ && deleted_bytes != this->exidx_input_section_.size());
+
// Fix size here so that we do not need to implement set_final_data_size.
- this->set_data_size(exidx_input_section.size() - deleted_bytes);
+ uint32_t size = exidx_input_section.size() - deleted_bytes;
+ this->set_data_size(size);
this->fix_data_size();
+
+ // Allocate buffer for section contents and build contents.
+ this->section_contents_ = new unsigned char[size];
+}
+
+// Build the contents of a merged EXIDX output section.
+
+void
+Arm_exidx_merged_section::build_contents(
+ const unsigned char* original_contents,
+ section_size_type original_size)
+{
+ // Go over spans of input offsets and write only those that are not
+ // discarded.
+ section_offset_type in_start = 0;
+ section_offset_type out_start = 0;
+ section_offset_type in_max =
+ convert_types<section_offset_type>(original_size);
+ section_offset_type out_max =
+ convert_types<section_offset_type>(this->data_size());
+ for (Arm_exidx_section_offset_map::const_iterator p =
+ this->section_offset_map_.begin();
+ p != this->section_offset_map_.end();
+ ++p)
+ {
+ section_offset_type in_end = p->first;
+ gold_assert(in_end >= in_start);
+ section_offset_type out_end = p->second;
+ size_t in_chunk_size = convert_types<size_t>(in_end - in_start + 1);
+ if (out_end != -1)
+ {
+ size_t out_chunk_size =
+ convert_types<size_t>(out_end - out_start + 1);
+
+ gold_assert(out_chunk_size == in_chunk_size
+ && in_end < in_max && out_end < out_max);
+
+ memcpy(this->section_contents_ + out_start,
+ original_contents + in_start,
+ out_chunk_size);
+ out_start += out_chunk_size;
+ }
+ in_start += in_chunk_size;
+ }
}
// Given an input OBJECT, an input section index SHNDX within that
void
Arm_exidx_merged_section::do_write(Output_file* of)
{
- // If we retain or discard the whole EXIDX input section, we would
- // not be here.
- gold_assert(this->data_size() != this->exidx_input_section_.size()
- && this->data_size() != 0);
-
off_t offset = this->offset();
const section_size_type oview_size = this->data_size();
unsigned char* const oview = of->get_output_view(offset, oview_size);
Output_section* os = this->relobj()->output_section(this->shndx());
gold_assert(os != NULL);
- // Get contents of EXIDX input section.
- section_size_type section_size;
- const unsigned char* section_contents =
- this->relobj()->section_contents(this->shndx(), §ion_size, false);
- gold_assert(section_size == this->exidx_input_section_.size());
-
- // Go over spans of input offsets and write only those that are not
- // discarded.
- section_offset_type in_start = 0;
- section_offset_type out_start = 0;
- for(Arm_exidx_section_offset_map::const_iterator p =
- this->section_offset_map_.begin();
- p != this->section_offset_map_.end();
- ++p)
- {
- section_offset_type in_end = p->first;
- gold_assert(in_end >= in_start);
- section_offset_type out_end = p->second;
- size_t in_chunk_size = convert_types<size_t>(in_end - in_start + 1);
- if (out_end != -1)
- {
- size_t out_chunk_size =
- convert_types<size_t>(out_end - out_start + 1);
- gold_assert(out_chunk_size == in_chunk_size);
- memcpy(oview + out_start, section_contents + in_start,
- out_chunk_size);
- out_start += out_chunk_size;
- }
- in_start += in_chunk_size;
- }
-
- gold_assert(convert_to_section_size_type(out_start) == oview_size);
+ memcpy(oview, this->section_contents_, oview_size);
of->write_output_view(this->offset(), oview_size, oview);
}
}
// Process EXIDX_INPUT_SECTION for EXIDX entry merging. Return the number of
-// bytes deleted. If some entries are merged, also store a pointer to a newly
-// created Arm_exidx_section_offset_map object in *PSECTION_OFFSET_MAP. The
-// caller owns the map and is responsible for releasing it after use.
+// bytes deleted. SECTION_CONTENTS points to the contents of the EXIDX
+// section and SECTION_SIZE is the number of bytes pointed by SECTION_CONTENTS.
+// If some entries are merged, also store a pointer to a newly created
+// Arm_exidx_section_offset_map object in *PSECTION_OFFSET_MAP. The caller
+// owns the map and is responsible for releasing it after use.
template<bool big_endian>
uint32_t
Arm_exidx_fixup::process_exidx_section(
const Arm_exidx_input_section* exidx_input_section,
+ const unsigned char* section_contents,
+ section_size_type section_size,
Arm_exidx_section_offset_map** psection_offset_map)
{
Relobj* relobj = exidx_input_section->relobj();
unsigned shndx = exidx_input_section->shndx();
- section_size_type section_size;
- const unsigned char* section_contents =
- relobj->section_contents(shndx, §ion_size, false);
if ((section_size % 8) != 0)
{
Input_section_list::const_iterator end,
Input_section_list::const_iterator owner,
Target_arm<big_endian>* target,
- std::vector<Output_relaxed_input_section*>* new_relaxed_sections)
+ std::vector<Output_relaxed_input_section*>* new_relaxed_sections,
+ const Task* task)
{
// We use a different kind of relaxed section in an EXIDX section.
// The static casting from Output_relaxed_input_section to
else
{
gold_assert(owner->is_input_section());
- // Create a new relaxed input section.
+ // Create a new relaxed input section. We need to lock the original
+ // file.
+ Task_lock_obj<Object> tl(task, owner->relobj());
arm_input_section =
target->new_arm_input_section(owner->relobj(), owner->shndx());
new_relaxed_sections->push_back(arm_input_section);
Arm_output_section<big_endian>::group_sections(
section_size_type group_size,
bool stubs_always_after_branch,
- Target_arm<big_endian>* target)
+ Target_arm<big_endian>* target,
+ const Task* task)
{
// We only care about sections containing code.
if ((this->flags() & elfcpp::SHF_EXECINSTR) == 0)
{
gold_assert(group_end != this->input_sections().end());
this->create_stub_group(group_begin, group_end, group_end,
- target, &new_relaxed_sections);
+ target, &new_relaxed_sections,
+ task);
state = NO_GROUP;
}
else
{
gold_assert(group_end != this->input_sections().end());
this->create_stub_group(group_begin, group_end, stub_table,
- target, &new_relaxed_sections);
+ target, &new_relaxed_sections, task);
state = NO_GROUP;
}
break;
}
// If we see an input section and currently there is no group, start
- // a new one. Skip any empty sections.
+ // a new one. Skip any empty sections. We look at the data size
+ // instead of calling p->relobj()->section_size() to avoid locking.
if ((p->is_input_section() || p->is_relaxed_input_section())
- && (p->relobj()->section_size(p->shndx()) != 0))
+ && (p->data_size() != 0))
{
if (state == NO_GROUP)
{
(state == FINDING_STUB_SECTION
? group_end
: stub_table),
- target, &new_relaxed_sections);
+ target, &new_relaxed_sections, task);
}
// Convert input section into relaxed input section in a batch.
Layout* layout,
const Text_section_list& sorted_text_sections,
Symbol_table* symtab,
- bool merge_exidx_entries)
+ bool merge_exidx_entries,
+ const Task* task)
{
// We should only do this for the EXIDX output section.
gold_assert(this->type() == elfcpp::SHT_ARM_EXIDX);
continue;
}
+ // We need to access the contents of the EXIDX section, lock the
+ // object here.
+ Task_lock_obj<Object> tl(task, exidx_relobj);
+ section_size_type exidx_size;
+ const unsigned char* exidx_contents =
+ exidx_relobj->section_contents(exidx_shndx, &exidx_size, false);
+
// Fix up coverage and append input section to output data list.
Arm_exidx_section_offset_map* section_offset_map = NULL;
uint32_t deleted_bytes =
exidx_fixup.process_exidx_section<big_endian>(exidx_input_section,
+ exidx_contents,
+ exidx_size,
§ion_offset_map);
if (deleted_bytes == exidx_input_section->size())
// Some entries are merged. We need to convert this EXIDX input
// section into a relaxed section.
gold_assert(section_offset_map != NULL);
+
Arm_exidx_merged_section* merged_section =
new Arm_exidx_merged_section(*exidx_input_section,
*section_offset_map, deleted_bytes);
+ merged_section->build_contents(exidx_contents, exidx_size);
+
const std::string secname = exidx_relobj->section_name(exidx_shndx);
this->add_relaxed_input_section(layout, merged_section, secname);
arm_relobj->convert_input_section_to_relaxed_section(exidx_shndx);
// Create an Arm_exidx_input_section object for this EXIDX section.
Arm_exidx_input_section* exidx_input_section =
new Arm_exidx_input_section(this, shndx, text_shndx, shdr.get_sh_size(),
- shdr.get_sh_addralign());
+ shdr.get_sh_addralign(),
+ text_shdr.get_sh_size());
gold_assert(this->exidx_section_map_[shndx] == NULL);
this->exidx_section_map_[shndx] = exidx_input_section;
section_offset_type section_offset = shdr.get_sh_offset();
section_size_type section_size =
convert_to_section_size_type(shdr.get_sh_size());
- File_view* view = this->get_lasting_view(section_offset,
- section_size, true, false);
+ const unsigned char* view =
+ this->get_view(section_offset, section_size, true, false);
this->attributes_section_data_ =
- new Attributes_section_data(view->data(), section_size);
+ new Attributes_section_data(view, section_size);
}
else if (shdr.get_sh_type() == elfcpp::SHT_ARM_EXIDX)
{
locsize, true, true);
// Process the deferred EXIDX sections.
- for(unsigned int i = 0; i < deferred_exidx_sections.size(); ++i)
+ for (unsigned int i = 0; i < deferred_exidx_sections.size(); ++i)
{
unsigned int shndx = deferred_exidx_sections[i];
elfcpp::Shdr<32, big_endian> shdr(pshdrs + shndx * shdr_size);
section_offset_type section_offset = shdr.get_sh_offset();
section_size_type section_size =
convert_to_section_size_type(shdr.get_sh_size());
- File_view* view = this->get_lasting_view(section_offset,
- section_size, true, false);
+ const unsigned char* view =
+ this->get_view(section_offset, section_size, true, false);
this->attributes_section_data_ =
- new Attributes_section_data(view->data(), section_size);
+ new Attributes_section_data(view, section_size);
break;
}
}
Target_arm<big_endian>::group_sections(
Layout* layout,
section_size_type group_size,
- bool stubs_always_after_branch)
+ bool stubs_always_after_branch,
+ const Task* task)
{
// Group input sections and insert stub table
Layout::Section_list section_list;
Arm_output_section<big_endian>* output_section =
Arm_output_section<big_endian>::as_arm_output_section(*p);
output_section->group_sections(group_size, stubs_always_after_branch,
- this);
+ this, task);
}
}
int pass,
const Input_objects* input_objects,
Symbol_table* symtab,
- Layout* layout)
+ Layout* layout,
+ const Task* task)
{
// No need to generate stubs if this is a relocatable link.
gold_assert(!parameters->options().relocatable());
stub_group_size = std::max(stub_group_size, cortex_a8_group_size);
}
- group_sections(layout, stub_group_size, stubs_always_after_branch);
+ group_sections(layout, stub_group_size, stubs_always_after_branch, task);
// Also fix .ARM.exidx section coverage.
Arm_output_section<big_endian>* exidx_output_section = NULL;
if (exidx_output_section != NULL)
{
this->fix_exidx_coverage(layout, input_objects, exidx_output_section,
- symtab);
+ symtab, task);
done_exidx_fixup = true;
}
}
{
Arm_relobj<big_endian>* arm_relobj =
Arm_relobj<big_endian>::as_arm_relobj(*op);
+ // Lock the object so we can read from it. This is only called
+ // single-threaded from Layout::finalize, so it is OK to lock.
+ Task_lock_obj<Object> tl(task, arm_relobj);
arm_relobj->scan_sections_for_stubs(this, symtab, layout);
}
// need to update output sections, so we record all output sections needing
// update above and scan the sections here to find out what sections need
// to be updated.
- for(Layout::Section_list::const_iterator p = layout->section_list().begin();
+ for (Layout::Section_list::const_iterator p = layout->section_list().begin();
p != layout->section_list().end();
++p)
{
// symbols defined in parts of input sections that are discarded by
// relaxation.
if (arm_relobj->output_local_symbol_count_needs_update())
- arm_relobj->update_output_local_symbol_count();
+ {
+ // We need to lock the object's file to update it.
+ Task_lock_obj<Object> tl(task, arm_relobj);
+ arm_relobj->update_output_local_symbol_count();
+ }
}
}
Layout* layout,
const Input_objects* input_objects,
Arm_output_section<big_endian>* exidx_section,
- Symbol_table* symtab)
+ Symbol_table* symtab,
+ const Task* task)
{
// We need to look at all the input sections in output in ascending
// order of of output address. We do that by building a sorted list
typedef typename Arm_output_section<big_endian>::Text_section_list
Text_section_list;
Text_section_list sorted_text_sections;
- for(typename Sorted_output_section_list::iterator p =
+ for (typename Sorted_output_section_list::iterator p =
sorted_output_sections.begin();
p != sorted_output_sections.end();
++p)
}
exidx_section->fix_exidx_coverage(layout, sorted_text_sections, symtab,
- merge_exidx_entries());
+ merge_exidx_entries(), task);
}
Target_selector_arm<false> target_selector_arm;
projects / binutils-gdb.git / commitdiff