// target-reloc.h -- target specific relocation support -*- C++ -*-
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+// Copyright (C) 2006-2015 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
//
// FIXME: We should issue a warning if this is an
// allocated section; is this the best place to do it?
- //
+ //
// FIXME: The old GNU linker would in some cases look
// for the linkonce section which caused this section to
// be discarded, and, if the other section was the same
CB_WARNING // Print a warning.
};
-// Decide what the linker should do for relocations that refer to discarded
-// comdat sections. This decision is based on the name of the section being
-// relocated.
-
-inline Comdat_behavior
-get_comdat_behavior(const char* name)
+class Default_comdat_behavior
{
- if (Layout::is_debug_info_section(name))
- return CB_PRETEND;
- if (strcmp(name, ".eh_frame") == 0
- || strcmp(name, ".gcc_except_table") == 0)
- return CB_IGNORE;
- return CB_WARNING;
-}
+ public:
+ // Decide what the linker should do for relocations that refer to
+ // discarded comdat sections. This decision is based on the name of
+ // the section being relocated.
+
+ inline Comdat_behavior
+ get(const char* name)
+ {
+ if (Layout::is_debug_info_section(name))
+ return CB_PRETEND;
+ if (strcmp(name, ".eh_frame") == 0
+ || strcmp(name, ".gcc_except_table") == 0)
+ return CB_IGNORE;
+ return CB_WARNING;
+ }
+};
// Give an error for a symbol with non-default visibility which is not
// defined locally.
return false;
// We don't report weak symbols.
- if (sym->binding() == elfcpp::STB_WEAK)
+ if (sym->is_weak_undefined())
return false;
// We don't report symbols defined in discarded sections.
return false;
}
+ // If the symbol is hidden, report it.
+ if (sym->visibility() == elfcpp::STV_HIDDEN)
+ return true;
+
// When creating a shared library, only report unresolved symbols if
// -z defs was used.
if (parameters->options().shared() && !parameters->options().defs())
// a single function, relocate(), which implements the machine
// specific part of a relocation.
+// The template parameter Relocate_comdat_behavior is a class type
+// which provides a single function, get(), which determines what the
+// linker should do for relocations that refer to discarded comdat
+// sections.
+
// SIZE is the ELF size: 32 or 64. BIG_ENDIAN is the endianness of
// the data. SH_TYPE is the section type: SHT_REL or SHT_RELA.
// RELOCATE implements operator() to do a relocation.
// relocation.
template<int size, bool big_endian, typename Target_type, int sh_type,
- typename Relocate>
+ typename Relocate,
+ typename Relocate_comdat_behavior>
inline void
relocate_section(
const Relocate_info<size, big_endian>* relinfo,
typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reltype;
const int reloc_size = Reloc_types<sh_type, size, big_endian>::reloc_size;
Relocate relocate;
+ Relocate_comdat_behavior relocate_comdat_behavior;
Sized_relobj_file<size, big_endian>* object = relinfo->object;
unsigned int local_count = object->local_symbol_count();
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_type = elfcpp::elf_r_type<size>(r_info);
const Sized_symbol<size>* sym;
// If the local symbol belongs to a section we are discarding,
// and that section is a debug section, try to find the
// corresponding kept section and map this symbol to its
- // counterpart in the kept section. The symbol must not
+ // counterpart in the kept section. The symbol must not
// correspond to a section we are folding.
bool is_ordinary;
shndx = psymval->input_shndx(&is_ordinary);
if (comdat_behavior == CB_UNDETERMINED)
{
std::string name = object->section_name(relinfo->data_shndx);
- comdat_behavior = get_comdat_behavior(name.c_str());
+ comdat_behavior = relocate_comdat_behavior.get(name.c_str());
}
if (comdat_behavior == CB_PRETEND)
{
psymval = &symval2;
}
- if (!relocate.relocate(relinfo, target, output_section, i, reloc,
- r_type, sym, psymval, view + offset,
- view_address + offset, view_size))
+ // If OFFSET is out of range, still let the target decide to
+ // ignore the relocation. Pass in NULL as the VIEW argument so
+ // that it can return quickly without trashing an invalid memory
+ // address.
+ unsigned char *v = view + offset;
+ if (offset < 0 || static_cast<section_size_type>(offset) >= view_size)
+ v = NULL;
+
+ if (!relocate.relocate(relinfo, sh_type, target, output_section,
+ i, prelocs, sym, psymval,
+ v, view_address + offset, view_size))
continue;
- if (offset < 0 || static_cast<section_size_type>(offset) >= view_size)
+ if (v == NULL)
{
gold_error_at_location(relinfo, i, offset,
_("reloc has bad offset %zu"),
gold_undefined_symbol_at_location(sym, relinfo, i, offset);
else if (sym != NULL
&& sym->visibility() != elfcpp::STV_DEFAULT
- && (sym->is_undefined() || sym->is_from_dynobj()))
+ && (sym->is_strong_undefined() || sym->is_from_dynobj()))
visibility_error(sym);
if (sym != NULL && sym->has_warning())
// Construct the ELF relocation in a temporary buffer.
const int reloc_size = elfcpp::Elf_sizes<size>::rela_size;
unsigned char relbuf[reloc_size];
- elfcpp::Rela<size, big_endian> rel(relbuf);
elfcpp::Rela_write<size, big_endian> orel(relbuf);
orel.put_r_offset(r_offset);
orel.put_r_info(elfcpp::elf_r_info<size>(0, r_type));
symval.set_is_ifunc_symbol();
Relocate relocate;
- relocate.relocate(relinfo, target, NULL, -1U, rel, r_type, sym, &symval,
+ relocate.relocate(relinfo, elfcpp::SHT_RELA, target, NULL,
+ -1U, relbuf, sym, &symval,
view + r_offset, address + r_offset, view_size);
}
const unsigned char* prelocs,
size_t reloc_count,
Output_section* output_section,
- typename elfcpp::Elf_types<size>::Elf_Addr offset_in_output_section,
- const Relocatable_relocs* rr,
+ typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
unsigned char* view,
typename elfcpp::Elf_types<size>::Elf_Addr view_address,
section_size_type view_size,
for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)
{
- Relocatable_relocs::Reloc_strategy strategy = rr->strategy(i);
+ Relocatable_relocs::Reloc_strategy strategy = relinfo->rr->strategy(i);
if (strategy == Relocatable_relocs::RELOC_DISCARD)
continue;
// Get the new symbol index.
+ Output_section* os = NULL;
unsigned int new_symndx;
if (r_sym < local_count)
{
unsigned int shndx =
object->local_symbol_input_shndx(r_sym, &is_ordinary);
gold_assert(is_ordinary);
- Output_section* os = object->output_section(shndx);
+ os = object->output_section(shndx);
gold_assert(os != NULL);
gold_assert(os->needs_symtab_index());
new_symndx = os->symtab_index();
typename elfcpp::Elf_types<size>::Elf_Swxword addend;
addend = Reloc_types<sh_type, size, big_endian>::
get_reloc_addend(&reloc);
- addend = psymval->value(object, addend);
+ gold_assert(os != NULL);
+ addend = psymval->value(object, addend) - os->address();
Reloc_types<sh_type, size, big_endian>::
set_reloc_addend(&reloc_write, addend);
}
projects / deliverable / binutils-gdb.git / blobdiff