// reloc.cc -- relocate input files for gold.
-// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2006-2016 Free Software Foundation, Inc.
// This file is part of gold.
void
Read_relocs::locks(Task_locker* tl)
{
- tl->add(this, this->object_->token());
+ Task_token* token = this->object_->token();
+ if (token != NULL)
+ tl->add(this, token);
}
// Read the relocations and then start a Scan_relocs_task.
void
Scan_relocs::locks(Task_locker* tl)
{
- tl->add(this, this->object_->token());
+ Task_token* token = this->object_->token();
+ if (token != NULL)
+ tl->add(this, token);
tl->add(this, this->next_blocker_);
}
if (this->input_sections_blocker_ != NULL)
tl->add(this, this->input_sections_blocker_);
tl->add(this, this->final_blocker_);
- tl->add(this, this->object_->token());
+ Task_token* token = this->object_->token();
+ if (token != NULL)
+ tl->add(this, token);
}
// Run the task.
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd)
+Sized_relobj_file<size, big_endian>::do_read_relocs(Read_relocs_data* rd)
{
rd->relocs.clear();
rd->relocs.reserve(shnum / 2);
const Output_sections& out_sections(this->output_sections());
- const std::vector<Address>& out_offsets(this->section_offsets_);
+ const std::vector<Address>& out_offsets(this->section_offsets());
const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(),
shnum * This::shdr_size,
if (!is_section_allocated
&& !parameters->options().relocatable()
&& !parameters->options().emit_relocs()
- && !parameters->options().incremental())
+ && !parameters->incremental())
continue;
if (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_)
off_t sh_size = shdr.get_sh_size();
+ if (sh_size == 0)
+ continue;
+
unsigned int reloc_size;
if (sh_type == elfcpp::SHT_REL)
reloc_size = elfcpp::Elf_sizes<size>::rel_size;
}
// Process the relocs to generate mappings from source sections to referenced
-// sections. This is used during garbage colletion to determine garbage
+// sections. This is used during garbage collection to determine garbage
// sections.
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::do_gc_process_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd)
+Sized_relobj_file<size, big_endian>::do_gc_process_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd)
{
Sized_target<size, big_endian>* target =
parameters->sized_target<size, big_endian>();
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::do_scan_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd)
+Sized_relobj_file<size, big_endian>::do_scan_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd)
{
Sized_target<size, big_endian>* target =
parameters->sized_target<size, big_endian>();
// For incremental links, finalize the allocation of relocations.
if (layout->incremental_inputs() != NULL)
- this->finalize_incremental_relocs(layout);
+ this->finalize_incremental_relocs(layout, true);
if (rd->local_symbols != NULL)
{
}
}
-// This is a strategy class we use when scanning for --emit-relocs.
-
-template<int sh_type>
-class Emit_relocs_strategy
-{
- public:
- // A local non-section symbol.
- inline Relocatable_relocs::Reloc_strategy
- local_non_section_strategy(unsigned int, Relobj*, unsigned int)
- { return Relocatable_relocs::RELOC_COPY; }
-
- // A local section symbol.
- inline Relocatable_relocs::Reloc_strategy
- local_section_strategy(unsigned int, Relobj*)
- {
- if (sh_type == elfcpp::SHT_RELA)
- return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA;
- else
- {
- // The addend is stored in the section contents. Since this
- // is not a relocatable link, we are going to apply the
- // relocation contents to the section as usual. This means
- // that we have no way to record the original addend. If the
- // original addend is not zero, there is basically no way for
- // the user to handle this correctly. Caveat emptor.
- return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_0;
- }
- }
-
- // A global symbol.
- inline Relocatable_relocs::Reloc_strategy
- global_strategy(unsigned int, Relobj*, unsigned int)
- { return Relocatable_relocs::RELOC_COPY; }
-};
-
// Scan the input relocations for --emit-relocs.
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::emit_relocs_scan(
+Sized_relobj_file<size, big_endian>::emit_relocs_scan(
Symbol_table* symtab,
Layout* layout,
const unsigned char* plocal_syms,
const Read_relocs_data::Relocs_list::iterator& p)
{
+ Sized_target<size, big_endian>* target =
+ parameters->sized_target<size, big_endian>();
+
Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx);
gold_assert(rr != NULL);
rr->set_reloc_count(p->reloc_count);
-
- if (p->sh_type == elfcpp::SHT_REL)
- this->emit_relocs_scan_reltype<elfcpp::SHT_REL>(symtab, layout,
- plocal_syms, p, rr);
- else
- {
- gold_assert(p->sh_type == elfcpp::SHT_RELA);
- this->emit_relocs_scan_reltype<elfcpp::SHT_RELA>(symtab, layout,
- plocal_syms, p, rr);
- }
-}
-
-// Scan the input relocation for --emit-relocs, templatized on the
-// type of the relocation section.
-
-template<int size, bool big_endian>
-template<int sh_type>
-void
-Sized_relobj<size, big_endian>::emit_relocs_scan_reltype(
- Symbol_table* symtab,
- Layout* layout,
- const unsigned char* plocal_syms,
- const Read_relocs_data::Relocs_list::iterator& p,
- Relocatable_relocs* rr)
-{
- scan_relocatable_relocs<size, big_endian, sh_type,
- Emit_relocs_strategy<sh_type> >(
+ target->emit_relocs_scan(
symtab,
layout,
this,
p->data_shndx,
+ p->sh_type,
p->contents->data(),
p->reloc_count,
p->output_section,
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::incremental_relocs_scan(
+Sized_relobj_file<size, big_endian>::incremental_relocs_scan(
const Read_relocs_data::Relocs_list::iterator& p)
{
if (p->sh_type == elfcpp::SHT_REL)
}
}
-// Scan the input relocation for --emit-relocs, templatized on the
+// Scan the input relocation for --incremental, templatized on the
// type of the relocation section.
template<int size, bool big_endian>
template<int sh_type>
void
-Sized_relobj<size, big_endian>::incremental_relocs_scan_reltype(
+Sized_relobj_file<size, big_endian>::incremental_relocs_scan_reltype(
const Read_relocs_data::Relocs_list::iterator& p)
{
typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reltype;
reloc.get_r_offset()))
continue;
- typename elfcpp::Elf_types<size>::Elf_WXword r_info =
- reloc.get_r_info();
+ // FIXME: Some targets have a non-standard r_info field.
+ typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info();
const unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
if (r_sym >= this->local_symbol_count_)
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::do_relocate(const Symbol_table* symtab,
- const Layout* layout,
- Output_file* of)
+Sized_relobj_file<size, big_endian>::do_relocate(const Symbol_table* symtab,
+ const Layout* layout,
+ Output_file* of)
{
unsigned int shnum = this->shnum();
// section data to the output file. The second one applies
// relocations.
- this->write_sections(pshdrs, of, &views);
+ this->write_sections(layout, pshdrs, of, &views);
// To speed up relocations, we set up hash tables for fast lookup of
// input offsets to output addresses.
this->initialize_input_to_output_maps();
+ // Make the views available through get_output_view() for the duration
+ // of this routine. This RAII class will reset output_views_ to NULL
+ // when the views go out of scope.
+ struct Set_output_views
+ {
+ Set_output_views(const Views** ppviews, const Views* pviews)
+ {
+ ppviews_ = ppviews;
+ *ppviews = pviews;
+ }
+
+ ~Set_output_views()
+ { *ppviews_ = NULL; }
+
+ const Views** ppviews_;
+ };
+ Set_output_views set_output_views(&this->output_views_, &views);
+
// Apply relocations.
this->relocate_sections(symtab, layout, pshdrs, of, &views);
{
if (views[i].view != NULL)
{
+ if (views[i].is_ctors_reverse_view)
+ this->reverse_words(views[i].view, views[i].view_size);
if (!views[i].is_postprocessing_view)
{
if (views[i].is_input_output_view)
// Write out the local symbols.
this->write_local_symbols(of, layout->sympool(), layout->dynpool(),
- layout->symtab_xindex(), layout->dynsym_xindex());
-
- // We should no longer need the local symbol values.
- this->clear_local_symbols();
+ layout->symtab_xindex(), layout->dynsym_xindex(),
+ layout->symtab_section_offset());
}
// Sort a Read_multiple vector by file offset.
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs,
- Output_file* of,
- Views* pviews)
+Sized_relobj_file<size, big_endian>::write_sections(const Layout* layout,
+ const unsigned char* pshdrs,
+ Output_file* of,
+ Views* pviews)
{
unsigned int shnum = this->shnum();
const Output_sections& out_sections(this->output_sections());
- const std::vector<Address>& out_offsets(this->section_offsets_);
+ const std::vector<Address>& out_offsets(this->section_offsets());
File_read::Read_multiple rm;
bool is_sorted = true;
pvs->address = posd->address();
pvs->is_input_output_view = false;
pvs->is_postprocessing_view = false;
+ pvs->is_ctors_reverse_view = false;
continue;
}
// Read and decompress the section.
section_size_type len;
const unsigned char* p = this->section_contents(i, &len, false);
- if (!decompress_input_section(p, len, view, view_size))
+ if (!decompress_input_section(p, len, view, view_size,
+ size, big_endian,
+ shdr.get_sh_flags()))
this->error(_("could not decompress section %s"),
this->section_name(i).c_str());
}
pvs->view_size = view_size;
pvs->is_input_output_view = output_offset == invalid_address;
pvs->is_postprocessing_view = os->requires_postprocessing();
+ pvs->is_ctors_reverse_view =
+ (!parameters->options().relocatable()
+ && view_size > size / 8
+ && (strcmp(os->name(), ".init_array") == 0
+ || strcmp(os->name(), ".fini_array") == 0)
+ && layout->is_ctors_in_init_array(this, i));
}
// Actually read the data.
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::do_relocate_sections(
+Sized_relobj_file<size, big_endian>::do_relocate_sections(
const Symbol_table* symtab,
const Layout* layout,
const unsigned char* pshdrs,
parameters->sized_target<size, big_endian>();
const Output_sections& out_sections(this->output_sections());
- const std::vector<Address>& out_offsets(this->section_offsets_);
+ const std::vector<Address>& out_offsets(this->section_offsets());
Relocate_info<size, big_endian> relinfo;
relinfo.symtab = symtab;
if ((data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0)
this->split_stack_adjust(symtab, pshdrs, sh_type, index,
prelocs, reloc_count, view, view_size,
- &reloc_map);
+ &reloc_map, target);
}
+ Relocatable_relocs* rr = NULL;
+ if (parameters->options().emit_relocs()
+ || parameters->options().relocatable())
+ rr = this->relocatable_relocs(i);
+ relinfo.rr = rr;
+
if (!parameters->options().relocatable())
{
target->relocate_section(&relinfo, sh_type, prelocs, reloc_count, os,
output_offset == invalid_address,
view, address, view_size, reloc_map);
if (parameters->options().emit_relocs())
- this->emit_relocs(&relinfo, i, sh_type, prelocs, reloc_count,
- os, output_offset, view, address, view_size,
- (*pviews)[i].view, (*pviews)[i].view_size);
- if (parameters->options().incremental())
+ target->relocate_relocs(&relinfo, sh_type, prelocs, reloc_count,
+ os, output_offset,
+ view, address, view_size,
+ (*pviews)[i].view,
+ (*pviews)[i].view_size);
+ if (parameters->incremental())
this->incremental_relocs_write(&relinfo, sh_type, prelocs,
reloc_count, os, output_offset, of);
}
else
- {
- Relocatable_relocs* rr = this->relocatable_relocs(i);
- target->relocate_for_relocatable(&relinfo, sh_type, prelocs,
- reloc_count, os, output_offset, rr,
- view, address, view_size,
- (*pviews)[i].view,
- (*pviews)[i].view_size);
- }
+ target->relocate_relocs(&relinfo, sh_type, prelocs, reloc_count,
+ os, output_offset,
+ view, address, view_size,
+ (*pviews)[i].view,
+ (*pviews)[i].view_size);
}
}
-// Emit the relocs for --emit-relocs.
+// Return the output view for section SHNDX.
template<int size, bool big_endian>
-void
-Sized_relobj<size, big_endian>::emit_relocs(
- const Relocate_info<size, big_endian>* relinfo,
- unsigned int i,
- unsigned int sh_type,
- const unsigned char* prelocs,
- size_t reloc_count,
- Output_section* output_section,
- typename elfcpp::Elf_types<size>::Elf_Addr offset_in_output_section,
- unsigned char* view,
- typename elfcpp::Elf_types<size>::Elf_Addr address,
- section_size_type view_size,
- unsigned char* reloc_view,
- section_size_type reloc_view_size)
-{
- if (sh_type == elfcpp::SHT_REL)
- this->emit_relocs_reltype<elfcpp::SHT_REL>(relinfo, i, prelocs,
- reloc_count, output_section,
- offset_in_output_section,
- view, address, view_size,
- reloc_view, reloc_view_size);
- else
- {
- gold_assert(sh_type == elfcpp::SHT_RELA);
- this->emit_relocs_reltype<elfcpp::SHT_RELA>(relinfo, i, prelocs,
- reloc_count, output_section,
- offset_in_output_section,
- view, address, view_size,
- reloc_view, reloc_view_size);
- }
-}
-
-// Emit the relocs for --emit-relocs, templatized on the type of the
-// relocation section.
-
-template<int size, bool big_endian>
-template<int sh_type>
-void
-Sized_relobj<size, big_endian>::emit_relocs_reltype(
- const Relocate_info<size, big_endian>* relinfo,
- unsigned int i,
- const unsigned char* prelocs,
- size_t reloc_count,
- Output_section* output_section,
- typename elfcpp::Elf_types<size>::Elf_Addr offset_in_output_section,
- unsigned char* view,
- typename elfcpp::Elf_types<size>::Elf_Addr address,
- section_size_type view_size,
- unsigned char* reloc_view,
- section_size_type reloc_view_size)
+unsigned char*
+Sized_relobj_file<size, big_endian>::do_get_output_view(
+ unsigned int shndx,
+ section_size_type* plen) const
{
- const Relocatable_relocs* rr = this->relocatable_relocs(i);
- relocate_for_relocatable<size, big_endian, sh_type>(
- relinfo,
- prelocs,
- reloc_count,
- output_section,
- offset_in_output_section,
- rr,
- view,
- address,
- view_size,
- reloc_view,
- reloc_view_size);
+ gold_assert(this->output_views_ != NULL);
+ gold_assert(shndx < this->output_views_->size());
+ const View_size& v = (*this->output_views_)[shndx];
+ *plen = v.view_size;
+ return v.view;
}
// Write the incremental relocs.
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::incremental_relocs_write(
+Sized_relobj_file<size, big_endian>::incremental_relocs_write(
const Relocate_info<size, big_endian>* relinfo,
unsigned int sh_type,
const unsigned char* prelocs,
template<int size, bool big_endian>
template<int sh_type>
void
-Sized_relobj<size, big_endian>::incremental_relocs_write_reltype(
+Sized_relobj_file<size, big_endian>::incremental_relocs_write_reltype(
const Relocate_info<size, big_endian>* relinfo,
const unsigned char* prelocs,
size_t reloc_count,
const unsigned int reloc_size =
Reloc_types<sh_type, size, big_endian>::reloc_size;
const unsigned int sizeof_addr = size / 8;
- const unsigned int incr_reloc_size = 8 + 2 * sizeof_addr;
+ const unsigned int incr_reloc_size =
+ Incremental_relocs_reader<size, big_endian>::reloc_size;
unsigned int out_shndx = output_section->out_shndx();
{
Reloc reloc(prelocs);
+ // FIXME: Some targets have a non-standard r_info field.
typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info();
const unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
const unsigned int r_type = elfcpp::elf_r_type<size>(r_info);
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::initialize_input_to_output_maps()
+Sized_relobj_file<size, big_endian>::initialize_input_to_output_maps()
{
const unsigned int loccount = this->local_symbol_count_;
for (unsigned int i = 1; i < loccount; ++i)
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::free_input_to_output_maps()
+Sized_relobj_file<size, big_endian>::free_input_to_output_maps()
{
const unsigned int loccount = this->local_symbol_count_;
for (unsigned int i = 1; i < loccount; ++i)
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::split_stack_adjust(
+Sized_relobj_file<size, big_endian>::split_stack_adjust(
const Symbol_table* symtab,
const unsigned char* pshdrs,
unsigned int sh_type,
size_t reloc_count,
unsigned char* view,
section_size_type view_size,
- Reloc_symbol_changes** reloc_map)
+ Reloc_symbol_changes** reloc_map,
+ const Sized_target<size, big_endian>* target)
{
if (sh_type == elfcpp::SHT_REL)
this->split_stack_adjust_reltype<elfcpp::SHT_REL>(symtab, pshdrs, shndx,
prelocs, reloc_count,
view, view_size,
- reloc_map);
+ reloc_map, target);
else
{
gold_assert(sh_type == elfcpp::SHT_RELA);
this->split_stack_adjust_reltype<elfcpp::SHT_RELA>(symtab, pshdrs, shndx,
prelocs, reloc_count,
view, view_size,
- reloc_map);
+ reloc_map, target);
}
}
template<int size, bool big_endian>
template<int sh_type>
void
-Sized_relobj<size, big_endian>::split_stack_adjust_reltype(
+Sized_relobj_file<size, big_endian>::split_stack_adjust_reltype(
const Symbol_table* symtab,
const unsigned char* pshdrs,
unsigned int shndx,
size_t reloc_count,
unsigned char* view,
section_size_type view_size,
- Reloc_symbol_changes** reloc_map)
+ Reloc_symbol_changes** reloc_map,
+ const Sized_target<size, big_endian>* target)
{
typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reltype;
const int reloc_size = Reloc_types<sh_type, size, big_endian>::reloc_size;
const unsigned char* pr = prelocs;
for (size_t i = 0; i < reloc_count; ++i, pr += reloc_size)
{
- Reltype reloc(pr);
-
- typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info();
- unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
+ // Some supported targets have a non-standard r_info field.
+ // If this call is too slow, we can move this routine to
+ // target-reloc.h and templatize it on Classify_reloc.
+ unsigned int r_sym = target->get_r_sym(pr);
if (r_sym < local_count)
continue;
&& gsym->source() == Symbol::FROM_OBJECT
&& !gsym->object()->uses_split_stack())
{
- unsigned int r_type = elfcpp::elf_r_type<size>(reloc.get_r_info());
- if (parameters->target().is_call_to_non_split(gsym, r_type))
+ if (parameters->target().is_call_to_non_split(gsym, pr, view,
+ view_size))
{
+ Reltype reloc(pr);
section_offset_type offset =
convert_to_section_size_type(reloc.get_r_offset());
non_split_refs.push_back(offset);
std::string from;
std::string to;
parameters->target().calls_non_split(this, shndx, p->first, p->second,
+ prelocs, reloc_count,
view, view_size, &from, &to);
if (!from.empty())
{
{
Reltype reloc(pr);
- typename elfcpp::Elf_types<size>::Elf_WXword r_info =
- reloc.get_r_info();
- unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
+ unsigned int r_sym = target->get_r_sym(pr);
if (r_sym < local_count)
continue;
template<int size, bool big_endian>
void
-Sized_relobj<size, big_endian>::find_functions(
+Sized_relobj_file<size, big_endian>::find_functions(
const unsigned char* pshdrs,
unsigned int shndx,
- Sized_relobj<size, big_endian>::Function_offsets* function_offsets)
+ Sized_relobj_file<size, big_endian>::Function_offsets* function_offsets)
{
// We need to read the symbols to find the functions. If we wanted
// to, we could cache reading the symbols across all sections in the
continue;
bool is_ordinary;
- unsigned int sym_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(),
- &is_ordinary);
- if (!is_ordinary || sym_shndx != shndx)
+ Symbol_location loc;
+ loc.shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(),
+ &is_ordinary);
+ if (!is_ordinary)
+ continue;
+
+ loc.object = this;
+ loc.offset = isym.get_st_value();
+ parameters->target().function_location(&loc);
+
+ if (loc.shndx != shndx)
continue;
section_offset_type value =
- convert_to_section_size_type(isym.get_st_value());
+ convert_to_section_size_type(loc.offset);
section_size_type fnsize =
convert_to_section_size_type(isym.get_st_size());
}
}
+// Reverse the words in a section. Used for .ctors sections mapped to
+// .init_array sections. See ctors_sections_in_init_array in
+// layout.cc.
+
+template<int size, bool big_endian>
+void
+Sized_relobj_file<size, big_endian>::reverse_words(unsigned char* view,
+ section_size_type view_size)
+{
+ typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype;
+ Valtype* vview = reinterpret_cast<Valtype*>(view);
+ section_size_type vview_size = view_size / (size / 8);
+ for (section_size_type i = 0; i < vview_size / 2; ++i)
+ {
+ Valtype tmp = vview[i];
+ vview[i] = vview[vview_size - 1 - i];
+ vview[vview_size - 1 - i] = tmp;
+ }
+}
+
// Class Merged_symbol_value.
template<int size>
const Relobj* object,
unsigned int input_shndx)
{
- Object_merge_map* map = object->merge_map();
- map->initialize_input_to_output_map<size>(input_shndx,
- this->output_start_address_,
- &this->output_addresses_);
+ object->initialize_input_to_output_map<size>(input_shndx,
+ this->output_start_address_,
+ &this->output_addresses_);
}
// Get the output value corresponding to an input offset if we
typename elfcpp::Elf_types<size>::Elf_Addr input_offset) const
{
section_offset_type output_offset;
- bool found = object->merge_map()->get_output_offset(NULL, input_shndx,
- input_offset,
- &output_offset);
+ bool found = object->merge_output_offset(input_shndx, input_offset,
+ &output_offset);
// If this assertion fails, it means that some relocation was
// against a portion of an input merge section which we didn't map
{
if (this->pos_ >= this->len_)
return -1U;
+ Sized_target<size, big_endian>* target
+ = parameters->sized_target<size, big_endian>();
+ return target->get_r_sym(this->prelocs_ + this->pos_);
+}
- // Rel and Rela start out the same, so we can use Rel to find the
- // symbol index.
- elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
- return elfcpp::elf_r_sym<size>(rel.get_r_info());
+// Return the addend of the next reloc, or 0 if there isn't one.
+
+template<int size, bool big_endian>
+uint64_t
+Track_relocs<size, big_endian>::next_addend() const
+{
+ if (this->pos_ >= this->len_)
+ return 0;
+ if (this->reloc_size_ == elfcpp::Elf_sizes<size>::rel_size)
+ return 0;
+ elfcpp::Rela<size, big_endian> rela(this->prelocs_ + this->pos_);
+ return rela.get_r_addend();
}
// Advance to the next reloc whose r_offset is greater than or equal
#ifdef HAVE_TARGET_32_LITTLE
template
void
-Sized_relobj<32, false>::do_read_relocs(Read_relocs_data* rd);
+Sized_relobj_file<32, false>::do_read_relocs(Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_32_BIG
template
void
-Sized_relobj<32, true>::do_read_relocs(Read_relocs_data* rd);
+Sized_relobj_file<32, true>::do_read_relocs(Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_64_LITTLE
template
void
-Sized_relobj<64, false>::do_read_relocs(Read_relocs_data* rd);
+Sized_relobj_file<64, false>::do_read_relocs(Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_64_BIG
template
void
-Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd);
+Sized_relobj_file<64, true>::do_read_relocs(Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_32_LITTLE
template
void
-Sized_relobj<32, false>::do_gc_process_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd);
+Sized_relobj_file<32, false>::do_gc_process_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_32_BIG
template
void
-Sized_relobj<32, true>::do_gc_process_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd);
+Sized_relobj_file<32, true>::do_gc_process_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_64_LITTLE
template
void
-Sized_relobj<64, false>::do_gc_process_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd);
+Sized_relobj_file<64, false>::do_gc_process_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_64_BIG
template
void
-Sized_relobj<64, true>::do_gc_process_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd);
+Sized_relobj_file<64, true>::do_gc_process_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_32_LITTLE
template
void
-Sized_relobj<32, false>::do_scan_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd);
+Sized_relobj_file<32, false>::do_scan_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_32_BIG
template
void
-Sized_relobj<32, true>::do_scan_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd);
+Sized_relobj_file<32, true>::do_scan_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_64_LITTLE
template
void
-Sized_relobj<64, false>::do_scan_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd);
+Sized_relobj_file<64, false>::do_scan_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_64_BIG
template
void
-Sized_relobj<64, true>::do_scan_relocs(Symbol_table* symtab,
- Layout* layout,
- Read_relocs_data* rd);
+Sized_relobj_file<64, true>::do_scan_relocs(Symbol_table* symtab,
+ Layout* layout,
+ Read_relocs_data* rd);
#endif
#ifdef HAVE_TARGET_32_LITTLE
template
void
-Sized_relobj<32, false>::do_relocate(const Symbol_table* symtab,
- const Layout* layout,
- Output_file* of);
+Sized_relobj_file<32, false>::do_relocate(const Symbol_table* symtab,
+ const Layout* layout,
+ Output_file* of);
#endif
#ifdef HAVE_TARGET_32_BIG
template
void
-Sized_relobj<32, true>::do_relocate(const Symbol_table* symtab,
- const Layout* layout,
- Output_file* of);
+Sized_relobj_file<32, true>::do_relocate(const Symbol_table* symtab,
+ const Layout* layout,
+ Output_file* of);
#endif
#ifdef HAVE_TARGET_64_LITTLE
template
void
-Sized_relobj<64, false>::do_relocate(const Symbol_table* symtab,
- const Layout* layout,
- Output_file* of);
+Sized_relobj_file<64, false>::do_relocate(const Symbol_table* symtab,
+ const Layout* layout,
+ Output_file* of);
#endif
#ifdef HAVE_TARGET_64_BIG
template
void
-Sized_relobj<64, true>::do_relocate(const Symbol_table* symtab,
- const Layout* layout,
- Output_file* of);
+Sized_relobj_file<64, true>::do_relocate(const Symbol_table* symtab,
+ const Layout* layout,
+ Output_file* of);
#endif
#ifdef HAVE_TARGET_32_LITTLE
template
void
-Sized_relobj<32, false>::do_relocate_sections(
+Sized_relobj_file<32, false>::do_relocate_sections(
const Symbol_table* symtab,
const Layout* layout,
const unsigned char* pshdrs,
Output_file* of,
Views* pviews);
+
+template
+unsigned char*
+Sized_relobj_file<32, false>::do_get_output_view(
+ unsigned int shndx,
+ section_size_type* plen) const;
#endif
#ifdef HAVE_TARGET_32_BIG
template
void
-Sized_relobj<32, true>::do_relocate_sections(
+Sized_relobj_file<32, true>::do_relocate_sections(
const Symbol_table* symtab,
const Layout* layout,
const unsigned char* pshdrs,
Output_file* of,
Views* pviews);
+
+template
+unsigned char*
+Sized_relobj_file<32, true>::do_get_output_view(
+ unsigned int shndx,
+ section_size_type* plen) const;
#endif
#ifdef HAVE_TARGET_64_LITTLE
template
void
-Sized_relobj<64, false>::do_relocate_sections(
+Sized_relobj_file<64, false>::do_relocate_sections(
const Symbol_table* symtab,
const Layout* layout,
const unsigned char* pshdrs,
Output_file* of,
Views* pviews);
+
+template
+unsigned char*
+Sized_relobj_file<64, false>::do_get_output_view(
+ unsigned int shndx,
+ section_size_type* plen) const;
#endif
#ifdef HAVE_TARGET_64_BIG
template
void
-Sized_relobj<64, true>::do_relocate_sections(
+Sized_relobj_file<64, true>::do_relocate_sections(
const Symbol_table* symtab,
const Layout* layout,
const unsigned char* pshdrs,
Output_file* of,
Views* pviews);
+
+template
+unsigned char*
+Sized_relobj_file<64, true>::do_get_output_view(
+ unsigned int shndx,
+ section_size_type* plen) const;
#endif
#ifdef HAVE_TARGET_32_LITTLE
template
void
-Sized_relobj<32, false>::initialize_input_to_output_maps();
+Sized_relobj_file<32, false>::initialize_input_to_output_maps();
template
void
-Sized_relobj<32, false>::free_input_to_output_maps();
+Sized_relobj_file<32, false>::free_input_to_output_maps();
#endif
#ifdef HAVE_TARGET_32_BIG
template
void
-Sized_relobj<32, true>::initialize_input_to_output_maps();
+Sized_relobj_file<32, true>::initialize_input_to_output_maps();
template
void
-Sized_relobj<32, true>::free_input_to_output_maps();
+Sized_relobj_file<32, true>::free_input_to_output_maps();
#endif
#ifdef HAVE_TARGET_64_LITTLE
template
void
-Sized_relobj<64, false>::initialize_input_to_output_maps();
+Sized_relobj_file<64, false>::initialize_input_to_output_maps();
template
void
-Sized_relobj<64, false>::free_input_to_output_maps();
+Sized_relobj_file<64, false>::free_input_to_output_maps();
#endif
#ifdef HAVE_TARGET_64_BIG
template
void
-Sized_relobj<64, true>::initialize_input_to_output_maps();
+Sized_relobj_file<64, true>::initialize_input_to_output_maps();
template
void
-Sized_relobj<64, true>::free_input_to_output_maps();
+Sized_relobj_file<64, true>::free_input_to_output_maps();
#endif
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
projects / binutils.git / blobdiff