2006-08-05 01:10:59 +02:00
|
|
|
// symtab.h -- the gold symbol table -*- C++ -*-
|
|
|
|
|
2016-01-01 12:25:12 +01:00
|
|
|
// Copyright (C) 2006-2016 Free Software Foundation, Inc.
|
2007-09-22 23:02:10 +02: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.
|
|
|
|
|
2006-08-05 01:10:59 +02:00
|
|
|
// Symbol_table
|
|
|
|
// The symbol table.
|
|
|
|
|
2009-10-13 02:39:31 +02:00
|
|
|
#ifndef GOLD_SYMTAB_H
|
|
|
|
#define GOLD_SYMTAB_H
|
|
|
|
|
2006-08-05 01:10:59 +02:00
|
|
|
#include <string>
|
|
|
|
#include <utility>
|
2006-11-03 19:26:11 +01:00
|
|
|
#include <vector>
|
2006-08-05 01:10:59 +02:00
|
|
|
|
|
|
|
#include "elfcpp.h"
|
2007-09-21 09:20:01 +02:00
|
|
|
#include "parameters.h"
|
2006-08-19 00:29:20 +02:00
|
|
|
#include "stringpool.h"
|
2006-11-06 23:46:08 +01:00
|
|
|
#include "object.h"
|
2006-08-05 01:10:59 +02:00
|
|
|
|
|
|
|
namespace gold
|
|
|
|
{
|
|
|
|
|
2008-05-21 23:37:44 +02:00
|
|
|
class Mapfile;
|
2006-08-19 00:29:20 +02:00
|
|
|
class Object;
|
2006-11-06 23:46:08 +01:00
|
|
|
class Relobj;
|
2006-11-14 20:21:05 +01:00
|
|
|
template<int size, bool big_endian>
|
2011-05-24 23:41:10 +02:00
|
|
|
class Sized_relobj_file;
|
2008-09-20 00:54:57 +02:00
|
|
|
template<int size, bool big_endian>
|
|
|
|
class Sized_pluginobj;
|
2006-11-06 23:46:08 +01:00
|
|
|
class Dynobj;
|
2006-11-14 20:21:05 +01:00
|
|
|
template<int size, bool big_endian>
|
|
|
|
class Sized_dynobj;
|
2011-04-12 02:44:48 +02:00
|
|
|
template<int size, bool big_endian>
|
|
|
|
class Sized_incrobj;
|
2006-12-06 01:02:36 +01:00
|
|
|
class Versions;
|
2008-01-16 00:41:28 +01:00
|
|
|
class Version_script_info;
|
2007-11-14 17:53:25 +01:00
|
|
|
class Input_objects;
|
2006-11-03 19:26:11 +01:00
|
|
|
class Output_data;
|
2006-11-29 18:56:40 +01:00
|
|
|
class Output_section;
|
2006-11-03 19:26:11 +01:00
|
|
|
class Output_segment;
|
2006-09-29 21:58:17 +02:00
|
|
|
class Output_file;
|
2008-04-19 20:30:58 +02:00
|
|
|
class Output_symtab_xindex;
|
2009-01-28 03:25:33 +01:00
|
|
|
class Garbage_collection;
|
2009-08-05 22:51:56 +02:00
|
|
|
class Icf;
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
// The base class of an entry in the symbol table. The symbol table
|
* powerpc.cc: Formatting and white space.
(Powerpc_relobj): Rename got2_section_ to special_.
Add opd_ent_shndx_ and opd_ent_off_ vectors.
(Powerpc_relobj::opd_shndx, init_opd, get_opd_ent, set_opd_ent,
scan_opd_relocs, do_read_relocs, opd_ent_ndx): New functions.
(Target_powerpc): Add Address typedef and invalid_address. Use
throughout.
(Target_powerpc::is_branch_reloc): New function.
(Powerpc_relocate_functions): Add Address typedef, use throughout.
(Powerpc_relocate_functions:rela, rela_ua): Correct type used
for dst_mask, value and addend.
(Powerpc_relobj::do_find_special_sections): Find .opd for 64-bit.
(ld_2_1, cror_15_15_15, cror_31_31_31): New insn constants.
(Output_data_glink::do_write): Correct toc base. Don't try to use
uint16_t for 24-bit offset. Use get_output_section_offset and
check return.
(Target_powerpc::Scan::local): Handle more relocs.
(Target_powerpc::do_finalize_sections): Set up DT_PPC64_GLINK.
(Target_powerpc::Relocate::relocate): Correct toc base calculation.
Plug in toc restoring insn after plt calls. Translate branches
to function descriptor symbols to corresponding entry point.
(Target_powerpc::relocate_for_relocatable): Check return from
get_output_section_offset.
* symtab.h: Comment typo.
2012-08-18 13:12:50 +02:00
|
|
|
// can have a lot of entries, so we don't want this class too big.
|
2006-08-19 00:29:20 +02:00
|
|
|
// Size dependent fields can be found in the template class
|
|
|
|
// Sized_symbol. Targets may support their own derived classes.
|
2006-08-05 01:10:59 +02:00
|
|
|
|
|
|
|
class Symbol
|
|
|
|
{
|
|
|
|
public:
|
2006-11-03 19:26:11 +01:00
|
|
|
// Because we want the class to be small, we don't use any virtual
|
|
|
|
// functions. But because symbols can be defined in different
|
|
|
|
// places, we need to classify them. This enum is the different
|
|
|
|
// sources of symbols we support.
|
|
|
|
enum Source
|
|
|
|
{
|
2006-11-06 23:46:08 +01:00
|
|
|
// Symbol defined in a relocatable or dynamic input file--this is
|
|
|
|
// the most common case.
|
2006-11-03 19:26:11 +01:00
|
|
|
FROM_OBJECT,
|
|
|
|
// Symbol defined in an Output_data, a special section created by
|
|
|
|
// the target.
|
|
|
|
IN_OUTPUT_DATA,
|
|
|
|
// Symbol defined in an Output_segment, with no associated
|
|
|
|
// section.
|
|
|
|
IN_OUTPUT_SEGMENT,
|
|
|
|
// Symbol value is constant.
|
2008-05-07 08:08:01 +02:00
|
|
|
IS_CONSTANT,
|
|
|
|
// Symbol is undefined.
|
|
|
|
IS_UNDEFINED
|
2006-11-03 19:26:11 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
// When the source is IN_OUTPUT_SEGMENT, we need to describe what
|
|
|
|
// the offset means.
|
|
|
|
enum Segment_offset_base
|
|
|
|
{
|
|
|
|
// From the start of the segment.
|
|
|
|
SEGMENT_START,
|
|
|
|
// From the end of the segment.
|
|
|
|
SEGMENT_END,
|
|
|
|
// From the filesz of the segment--i.e., after the loaded bytes
|
|
|
|
// but before the bytes which are allocated but zeroed.
|
|
|
|
SEGMENT_BSS
|
|
|
|
};
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Return the symbol name.
|
|
|
|
const char*
|
|
|
|
name() const
|
|
|
|
{ return this->name_; }
|
|
|
|
|
2007-11-15 02:12:55 +01:00
|
|
|
// Return the (ANSI) demangled version of the name, if
|
|
|
|
// parameters.demangle() is true. Otherwise, return the name. This
|
|
|
|
// is intended to be used only for logging errors, so it's not
|
|
|
|
// super-efficient.
|
|
|
|
std::string
|
|
|
|
demangled_name() const;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Return the symbol version. This will return NULL for an
|
|
|
|
// unversioned symbol.
|
|
|
|
const char*
|
|
|
|
version() const
|
|
|
|
{ return this->version_; }
|
|
|
|
|
2013-03-20 01:25:28 +01:00
|
|
|
void
|
|
|
|
clear_version()
|
|
|
|
{ this->version_ = NULL; }
|
|
|
|
|
2008-01-16 00:41:28 +01:00
|
|
|
// Return whether this version is the default for this symbol name
|
|
|
|
// (eg, "foo@@V2" is a default version; "foo@V1" is not). Only
|
|
|
|
// meaningful for versioned symbols.
|
|
|
|
bool
|
|
|
|
is_default() const
|
|
|
|
{
|
|
|
|
gold_assert(this->version_ != NULL);
|
|
|
|
return this->is_def_;
|
|
|
|
}
|
|
|
|
|
2008-03-14 06:57:19 +01:00
|
|
|
// Set that this version is the default for this symbol name.
|
2008-01-16 00:41:28 +01:00
|
|
|
void
|
2008-03-14 06:57:19 +01:00
|
|
|
set_is_default()
|
|
|
|
{ this->is_def_ = true; }
|
2008-01-16 00:41:28 +01:00
|
|
|
|
Fix symbol versioning problems in PR 18703.
If a symbol is defined with ".symver foo,foo@VER", the assembler
creates two symbols in the object: one unversioned, and one with
the (non-default) version "VER". If foo is listed in a version
script, gold would then make the first of those symbols the
default version, and would ignore the second symbol as a
duplicate, without making it a non-default version. While this is
arguably reasonable behavior, it doesn't match Gnu ld behavior,
so this patch fixes that by allowing the second definition to
override the first by resetting the "default version" indication.
Several test cases from the Gnu ld testsuite also exposed another
related problem, where a symbol defined with ".symver foo,foo@",
placed into a shared library, is not handled properly by gold.
This patch also fixes that case, binding the symbol to the base
version.
gold/
PR gold/18703
* dynobj.cc (Versions::record_version): Handle symbol defined with
base version.
(Versions::symbol_section_contents): Likewise.
* symtab.h (Symbol::set_is_not_default): New class method.
(Symbol_table::resolve): Add is_default_version parameter.
(Symbol_table::should_override): Likewise.
* resolve.cc (Symbol_table::resolve): Add is_default_version parameter,
and pass to should_override. Adjust all callers and explicit
instantiations.
(Symbol_table::should_override): Add is_default_value parameter;
allow default version in a dynamic object to override existing
definition from same object.
* symtab.cc (Symbol_table::add_from_object): Handle case where same
symbol is defined as unversioned and non-default version in the same
object.
* testsuite/Makefile.am (ver_test_13): New test case.
* testsuite/Makefile.in: Regenerate.
* testsuite/ver_test_4.cc: Add test for symbol with base version.
* testsuite/ver_test_4.sh: Likewise.
* testsuite/ver_test_13.c: New source file.
* testsuite/ver_test_13.script: New version script.
* testsuite/ver_test_13.sh: New test case.
2015-07-28 00:09:08 +02:00
|
|
|
// Set that this version is not the default for this symbol name.
|
|
|
|
void
|
|
|
|
set_is_not_default()
|
|
|
|
{ this->is_def_ = false; }
|
|
|
|
|
2011-06-28 07:39:45 +02:00
|
|
|
// Return the symbol's name as name@version (or name@@version).
|
|
|
|
std::string
|
|
|
|
versioned_name() const;
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Return the symbol source.
|
|
|
|
Source
|
|
|
|
source() const
|
|
|
|
{ return this->source_; }
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Return the object with which this symbol is associated.
|
|
|
|
Object*
|
|
|
|
object() const
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(this->source_ == FROM_OBJECT);
|
2006-11-03 19:26:11 +01:00
|
|
|
return this->u_.from_object.object;
|
|
|
|
}
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
// Return the index of the section in the input relocatable or
|
|
|
|
// dynamic object file.
|
2006-11-03 19:26:11 +01:00
|
|
|
unsigned int
|
2008-04-19 20:30:58 +02:00
|
|
|
shndx(bool* is_ordinary) const
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(this->source_ == FROM_OBJECT);
|
2008-04-19 20:30:58 +02:00
|
|
|
*is_ordinary = this->is_ordinary_shndx_;
|
2006-12-01 17:51:25 +01:00
|
|
|
return this->u_.from_object.shndx;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return the output data section with which this symbol is
|
|
|
|
// associated, if the symbol was specially defined with respect to
|
|
|
|
// an output data section.
|
|
|
|
Output_data*
|
|
|
|
output_data() const
|
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(this->source_ == IN_OUTPUT_DATA);
|
2006-11-03 19:26:11 +01:00
|
|
|
return this->u_.in_output_data.output_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this symbol was defined with respect to an output data
|
|
|
|
// section, return whether the value is an offset from end.
|
|
|
|
bool
|
|
|
|
offset_is_from_end() const
|
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(this->source_ == IN_OUTPUT_DATA);
|
2006-11-03 19:26:11 +01:00
|
|
|
return this->u_.in_output_data.offset_is_from_end;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the output segment with which this symbol is associated,
|
|
|
|
// if the symbol was specially defined with respect to an output
|
|
|
|
// segment.
|
|
|
|
Output_segment*
|
|
|
|
output_segment() const
|
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(this->source_ == IN_OUTPUT_SEGMENT);
|
2006-11-03 19:26:11 +01:00
|
|
|
return this->u_.in_output_segment.output_segment;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this symbol was defined with respect to an output segment,
|
|
|
|
// return the offset base.
|
|
|
|
Segment_offset_base
|
|
|
|
offset_base() const
|
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(this->source_ == IN_OUTPUT_SEGMENT);
|
2006-11-03 19:26:11 +01:00
|
|
|
return this->u_.in_output_segment.offset_base;
|
|
|
|
}
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
// Return the symbol binding.
|
|
|
|
elfcpp::STB
|
|
|
|
binding() const
|
|
|
|
{ return this->binding_; }
|
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Return the symbol type.
|
|
|
|
elfcpp::STT
|
|
|
|
type() const
|
|
|
|
{ return this->type_; }
|
|
|
|
|
Fix --defsym to copy symbol attributes.
Alan Modra committed a patch to Gnu ld to fix a problem encountered on
PPC where the --defsym option wasn't copying the st_other bits to the
newly-defined symbol.
https://sourceware.org/ml/binutils/2014-07/msg00094.html
Gold has the same problem, and additionally wasn't copying the symbol type.
This patch fixes both problems, by copying the symbol type, visibility, and
the remaining st_other bits to the new symbol for --defsym=sym1=sym2
assignments.
gold/
* expression.cc (struct Expression::Expression_eval_info): Add
new fields type_pointer, vis_pointer, and nonvis_pointer.
(Expression::eval_maybe_dot): Add type_pointer, vis_pointer, and
nonvis_pointer parameters. Adjust all calls.
(Symbol_expression::value): Update type, visibility, and nonvis bits
in caller.
* script.cc (Symbol_assignment::sized_finalize): Update type,
visibility, and remaining st_other bits for new symbol.
* script.h: (Expression::eval_maybe_dot): Add type_pointer,
vis_pointer, and nonvis_pointer parameters.
* symtab.h (Symbol::set_type): New method.
* testsuite/Makefile.am (defsym_test): New test.
* testsuite/Makefile.in: Regenerate.
* testsuite/defsym_test.c: New file.
* testsuite/defsym_test.sh: New file.
2014-07-09 07:34:27 +02:00
|
|
|
// Set the symbol type.
|
|
|
|
void
|
|
|
|
set_type(elfcpp::STT type)
|
|
|
|
{ this->type_ = type; }
|
|
|
|
|
2009-12-07 18:14:55 +01:00
|
|
|
// Return true for function symbol.
|
|
|
|
bool
|
|
|
|
is_func() const
|
|
|
|
{
|
|
|
|
return (this->type_ == elfcpp::STT_FUNC
|
|
|
|
|| this->type_ == elfcpp::STT_GNU_IFUNC);
|
|
|
|
}
|
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Return the symbol visibility.
|
|
|
|
elfcpp::STV
|
|
|
|
visibility() const
|
|
|
|
{ return this->visibility_; }
|
|
|
|
|
2009-02-27 20:57:46 +01:00
|
|
|
// Set the visibility.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_visibility(elfcpp::STV visibility)
|
|
|
|
{ this->visibility_ = visibility; }
|
2009-02-27 20:57:46 +01:00
|
|
|
|
|
|
|
// Override symbol visibility.
|
|
|
|
void
|
|
|
|
override_visibility(elfcpp::STV);
|
|
|
|
|
2010-07-09 03:34:31 +02:00
|
|
|
// Set whether the symbol was originally a weak undef or a regular undef
|
2014-04-02 23:21:14 +02:00
|
|
|
// when resolved by a dynamic def or by a special symbol.
|
2010-07-09 03:34:31 +02:00
|
|
|
inline void
|
|
|
|
set_undef_binding(elfcpp::STB bind)
|
|
|
|
{
|
|
|
|
if (!this->undef_binding_set_ || this->undef_binding_weak_)
|
|
|
|
{
|
|
|
|
this->undef_binding_weak_ = bind == elfcpp::STB_WEAK;
|
|
|
|
this->undef_binding_set_ = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-02 23:21:14 +02:00
|
|
|
// Return TRUE if a weak undef was resolved by a dynamic def or
|
|
|
|
// by a special symbol.
|
2010-07-09 03:34:31 +02:00
|
|
|
inline bool
|
|
|
|
is_undef_binding_weak() const
|
|
|
|
{ return this->undef_binding_weak_; }
|
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Return the non-visibility part of the st_other field.
|
|
|
|
unsigned char
|
2006-11-03 19:26:11 +01:00
|
|
|
nonvis() const
|
|
|
|
{ return this->nonvis_; }
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2014-03-10 21:38:20 +01:00
|
|
|
// Set the non-visibility part of the st_other field.
|
|
|
|
void
|
|
|
|
set_nonvis(unsigned int nonvis)
|
|
|
|
{ this->nonvis_ = nonvis; }
|
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Return whether this symbol is a forwarder. This will never be
|
|
|
|
// true of a symbol found in the hash table, but may be true of
|
|
|
|
// symbol pointers attached to object files.
|
|
|
|
bool
|
|
|
|
is_forwarder() const
|
|
|
|
{ return this->is_forwarder_; }
|
|
|
|
|
|
|
|
// Mark this symbol as a forwarder.
|
|
|
|
void
|
|
|
|
set_forwarder()
|
|
|
|
{ this->is_forwarder_ = true; }
|
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// Return whether this symbol has an alias in the weak aliases table
|
|
|
|
// in Symbol_table.
|
|
|
|
bool
|
|
|
|
has_alias() const
|
|
|
|
{ return this->has_alias_; }
|
|
|
|
|
|
|
|
// Mark this symbol as having an alias.
|
|
|
|
void
|
|
|
|
set_has_alias()
|
|
|
|
{ this->has_alias_ = true; }
|
|
|
|
|
2006-11-16 01:38:25 +01:00
|
|
|
// Return whether this symbol needs an entry in the dynamic symbol
|
|
|
|
// table.
|
|
|
|
bool
|
|
|
|
needs_dynsym_entry() const
|
2007-08-29 07:48:24 +02:00
|
|
|
{
|
|
|
|
return (this->needs_dynsym_entry_
|
2009-12-30 08:40:01 +01:00
|
|
|
|| (this->in_reg()
|
|
|
|
&& this->in_dyn()
|
|
|
|
&& this->is_externally_visible()));
|
2007-08-29 07:48:24 +02:00
|
|
|
}
|
2006-11-16 01:38:25 +01:00
|
|
|
|
|
|
|
// Mark this symbol as needing an entry in the dynamic symbol table.
|
|
|
|
void
|
|
|
|
set_needs_dynsym_entry()
|
|
|
|
{ this->needs_dynsym_entry_ = true; }
|
|
|
|
|
2007-10-17 01:23:08 +02:00
|
|
|
// Return whether this symbol should be added to the dynamic symbol
|
|
|
|
// table.
|
|
|
|
bool
|
2010-04-20 23:13:30 +02:00
|
|
|
should_add_dynsym_entry(Symbol_table*) const;
|
2007-10-17 01:23:08 +02:00
|
|
|
|
2006-12-06 07:28:56 +01:00
|
|
|
// Return whether this symbol has been seen in a regular object.
|
|
|
|
bool
|
|
|
|
in_reg() const
|
|
|
|
{ return this->in_reg_; }
|
|
|
|
|
|
|
|
// Mark this symbol as having been seen in a regular object.
|
|
|
|
void
|
|
|
|
set_in_reg()
|
|
|
|
{ this->in_reg_ = true; }
|
|
|
|
|
2007-08-29 05:42:51 +02:00
|
|
|
// Return whether this symbol has been seen in a dynamic object.
|
|
|
|
bool
|
|
|
|
in_dyn() const
|
|
|
|
{ return this->in_dyn_; }
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
// Mark this symbol as having been seen in a dynamic object.
|
2006-09-07 23:21:41 +02:00
|
|
|
void
|
|
|
|
set_in_dyn()
|
|
|
|
{ this->in_dyn_ = true; }
|
|
|
|
|
2008-09-20 00:54:57 +02:00
|
|
|
// Return whether this symbol has been seen in a real ELF object.
|
|
|
|
// (IN_REG will return TRUE if the symbol has been seen in either
|
|
|
|
// a real ELF object or an object claimed by a plugin.)
|
|
|
|
bool
|
|
|
|
in_real_elf() const
|
|
|
|
{ return this->in_real_elf_; }
|
|
|
|
|
|
|
|
// Mark this symbol as having been seen in a real ELF object.
|
|
|
|
void
|
|
|
|
set_in_real_elf()
|
|
|
|
{ this->in_real_elf_ = true; }
|
|
|
|
|
2010-01-09 01:13:48 +01:00
|
|
|
// Return whether this symbol was defined in a section that was
|
|
|
|
// discarded from the link. This is used to control some error
|
|
|
|
// reporting.
|
|
|
|
bool
|
|
|
|
is_defined_in_discarded_section() const
|
|
|
|
{ return this->is_defined_in_discarded_section_; }
|
|
|
|
|
|
|
|
// Mark this symbol as having been defined in a discarded section.
|
|
|
|
void
|
|
|
|
set_is_defined_in_discarded_section()
|
|
|
|
{ this->is_defined_in_discarded_section_ = true; }
|
|
|
|
|
2006-11-16 01:38:25 +01:00
|
|
|
// Return the index of this symbol in the output file symbol table.
|
|
|
|
// A value of -1U means that this symbol is not going into the
|
|
|
|
// output file. This starts out as zero, and is set to a non-zero
|
|
|
|
// value by Symbol_table::finalize. It is an error to ask for the
|
|
|
|
// symbol table index before it has been set.
|
|
|
|
unsigned int
|
|
|
|
symtab_index() const
|
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(this->symtab_index_ != 0);
|
2006-11-16 01:38:25 +01:00
|
|
|
return this->symtab_index_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the index of the symbol in the output file symbol table.
|
|
|
|
void
|
|
|
|
set_symtab_index(unsigned int index)
|
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(index != 0);
|
2006-11-16 01:38:25 +01:00
|
|
|
this->symtab_index_ = index;
|
|
|
|
}
|
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
// Return whether this symbol already has an index in the output
|
|
|
|
// file symbol table.
|
|
|
|
bool
|
|
|
|
has_symtab_index() const
|
|
|
|
{ return this->symtab_index_ != 0; }
|
|
|
|
|
2006-11-16 01:38:25 +01:00
|
|
|
// Return the index of this symbol in the dynamic symbol table. A
|
|
|
|
// value of -1U means that this symbol is not going into the dynamic
|
|
|
|
// symbol table. This starts out as zero, and is set to a non-zero
|
|
|
|
// during Layout::finalize. It is an error to ask for the dynamic
|
|
|
|
// symbol table index before it has been set.
|
|
|
|
unsigned int
|
|
|
|
dynsym_index() const
|
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(this->dynsym_index_ != 0);
|
2006-11-16 01:38:25 +01:00
|
|
|
return this->dynsym_index_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the index of the symbol in the dynamic symbol table.
|
|
|
|
void
|
|
|
|
set_dynsym_index(unsigned int index)
|
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(index != 0);
|
2006-11-16 01:38:25 +01:00
|
|
|
this->dynsym_index_ = index;
|
|
|
|
}
|
|
|
|
|
2006-12-01 17:51:25 +01:00
|
|
|
// Return whether this symbol already has an index in the dynamic
|
|
|
|
// symbol table.
|
|
|
|
bool
|
|
|
|
has_dynsym_index() const
|
|
|
|
{ return this->dynsym_index_ != 0; }
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Return whether this symbol has an entry in the GOT section.
|
2007-11-14 23:31:02 +01:00
|
|
|
// For a TLS symbol, this GOT entry will hold its tp-relative offset.
|
2006-10-20 22:40:49 +02:00
|
|
|
bool
|
2008-03-25 19:37:16 +01:00
|
|
|
has_got_offset(unsigned int got_type) const
|
|
|
|
{ return this->got_offsets_.get_offset(got_type) != -1U; }
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
// Return the offset into the GOT section of this symbol.
|
|
|
|
unsigned int
|
2008-03-25 19:37:16 +01:00
|
|
|
got_offset(unsigned int got_type) const
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
unsigned int got_offset = this->got_offsets_.get_offset(got_type);
|
|
|
|
gold_assert(got_offset != -1U);
|
|
|
|
return got_offset;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Set the GOT offset of this symbol.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_got_offset(unsigned int got_type, unsigned int got_offset)
|
|
|
|
{ this->got_offsets_.set_offset(got_type, got_offset); }
|
2007-11-14 23:31:02 +01:00
|
|
|
|
2010-08-13 00:15:00 +02:00
|
|
|
// Return the GOT offset list.
|
|
|
|
const Got_offset_list*
|
|
|
|
got_offset_list() const
|
|
|
|
{ return this->got_offsets_.get_list(); }
|
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
// Return whether this symbol has an entry in the PLT section.
|
2006-11-03 19:26:11 +01:00
|
|
|
bool
|
2006-11-29 18:56:40 +01:00
|
|
|
has_plt_offset() const
|
2010-01-09 01:13:48 +01:00
|
|
|
{ return this->plt_offset_ != -1U; }
|
2006-11-29 18:56:40 +01:00
|
|
|
|
|
|
|
// Return the offset into the PLT section of this symbol.
|
|
|
|
unsigned int
|
|
|
|
plt_offset() const
|
|
|
|
{
|
|
|
|
gold_assert(this->has_plt_offset());
|
|
|
|
return this->plt_offset_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the PLT offset of this symbol.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_plt_offset(unsigned int plt_offset)
|
2006-11-29 18:56:40 +01:00
|
|
|
{
|
2010-01-09 01:13:48 +01:00
|
|
|
gold_assert(plt_offset != -1U);
|
2009-12-14 20:53:05 +01:00
|
|
|
this->plt_offset_ = plt_offset;
|
2006-11-29 18:56:40 +01:00
|
|
|
}
|
|
|
|
|
2007-09-23 07:31:48 +02:00
|
|
|
// Return whether this dynamic symbol needs a special value in the
|
|
|
|
// dynamic symbol table.
|
|
|
|
bool
|
|
|
|
needs_dynsym_value() const
|
|
|
|
{ return this->needs_dynsym_value_; }
|
|
|
|
|
|
|
|
// Set that this dynamic symbol needs a special value in the dynamic
|
|
|
|
// symbol table.
|
|
|
|
void
|
|
|
|
set_needs_dynsym_value()
|
|
|
|
{
|
|
|
|
gold_assert(this->object()->is_dynamic());
|
|
|
|
this->needs_dynsym_value_ = true;
|
|
|
|
}
|
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
// Return true if the final value of this symbol is known at link
|
|
|
|
// time.
|
|
|
|
bool
|
2007-09-28 08:36:25 +02:00
|
|
|
final_value_is_known() const;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2009-06-22 08:51:53 +02:00
|
|
|
// Return true if SHNDX represents a common symbol. This depends on
|
|
|
|
// the target.
|
|
|
|
static bool
|
|
|
|
is_common_shndx(unsigned int shndx);
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
// Return whether this is a defined symbol (not undefined or
|
|
|
|
// common).
|
|
|
|
bool
|
|
|
|
is_defined() const
|
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
|
|
|
if (this->source_ != FROM_OBJECT)
|
2008-05-07 08:08:01 +02:00
|
|
|
return this->source_ != IS_UNDEFINED;
|
2009-12-14 20:53:05 +01:00
|
|
|
unsigned int shndx = this->shndx(&is_ordinary);
|
2008-04-19 20:30:58 +02:00
|
|
|
return (is_ordinary
|
2009-12-14 20:53:05 +01:00
|
|
|
? shndx != elfcpp::SHN_UNDEF
|
|
|
|
: !Symbol::is_common_shndx(shndx));
|
2006-11-29 18:56:40 +01:00
|
|
|
}
|
|
|
|
|
2006-12-06 01:02:36 +01:00
|
|
|
// Return true if this symbol is from a dynamic object.
|
2006-11-29 18:56:40 +01:00
|
|
|
bool
|
2006-12-06 01:02:36 +01:00
|
|
|
is_from_dynobj() const
|
2006-11-29 18:56:40 +01:00
|
|
|
{
|
2006-12-06 01:02:36 +01:00
|
|
|
return this->source_ == FROM_OBJECT && this->object()->is_dynamic();
|
2006-11-06 23:46:08 +01:00
|
|
|
}
|
|
|
|
|
2010-06-10 19:20:27 +02:00
|
|
|
// Return whether this is a placeholder symbol from a plugin object.
|
|
|
|
bool
|
|
|
|
is_placeholder() const
|
|
|
|
{
|
|
|
|
return this->source_ == FROM_OBJECT && this->object()->pluginobj() != NULL;
|
|
|
|
}
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Return whether this is an undefined symbol.
|
|
|
|
bool
|
|
|
|
is_undefined() const
|
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
2008-05-07 08:08:01 +02:00
|
|
|
return ((this->source_ == FROM_OBJECT
|
|
|
|
&& this->shndx(&is_ordinary) == elfcpp::SHN_UNDEF
|
|
|
|
&& is_ordinary)
|
|
|
|
|| this->source_ == IS_UNDEFINED);
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
2008-04-04 19:24:47 +02:00
|
|
|
// Return whether this is a weak undefined symbol.
|
|
|
|
bool
|
|
|
|
is_weak_undefined() const
|
2014-04-02 23:21:14 +02:00
|
|
|
{
|
|
|
|
return (this->is_undefined()
|
|
|
|
&& (this->binding() == elfcpp::STB_WEAK
|
2015-04-23 22:56:40 +02:00
|
|
|
|| this->is_undef_binding_weak()
|
|
|
|
|| parameters->options().weak_unresolved_symbols()));
|
2014-04-02 23:21:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return whether this is a strong undefined symbol.
|
|
|
|
bool
|
|
|
|
is_strong_undefined() const
|
|
|
|
{
|
|
|
|
return (this->is_undefined()
|
|
|
|
&& this->binding() != elfcpp::STB_WEAK
|
2015-04-23 22:56:40 +02:00
|
|
|
&& !this->is_undef_binding_weak()
|
|
|
|
&& !parameters->options().weak_unresolved_symbols());
|
2014-04-02 23:21:14 +02:00
|
|
|
}
|
2008-04-04 19:24:47 +02:00
|
|
|
|
|
|
|
// Return whether this is an absolute symbol.
|
|
|
|
bool
|
|
|
|
is_absolute() const
|
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
2008-05-07 08:08:01 +02:00
|
|
|
return ((this->source_ == FROM_OBJECT
|
|
|
|
&& this->shndx(&is_ordinary) == elfcpp::SHN_ABS
|
|
|
|
&& !is_ordinary)
|
|
|
|
|| this->source_ == IS_CONSTANT);
|
2008-04-04 19:24:47 +02:00
|
|
|
}
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Return whether this is a common symbol.
|
|
|
|
bool
|
|
|
|
is_common() const
|
|
|
|
{
|
2009-06-22 08:51:53 +02:00
|
|
|
if (this->source_ != FROM_OBJECT)
|
|
|
|
return false;
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
2009-12-14 20:53:05 +01:00
|
|
|
unsigned int shndx = this->shndx(&is_ordinary);
|
|
|
|
return !is_ordinary && Symbol::is_common_shndx(shndx);
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-08-22 07:06:38 +02:00
|
|
|
// Return whether this symbol can be seen outside this object.
|
|
|
|
bool
|
|
|
|
is_externally_visible() const
|
|
|
|
{
|
2011-07-23 00:38:42 +02:00
|
|
|
return ((this->visibility_ == elfcpp::STV_DEFAULT
|
|
|
|
|| this->visibility_ == elfcpp::STV_PROTECTED)
|
|
|
|
&& !this->is_forced_local_);
|
2007-08-22 07:06:38 +02:00
|
|
|
}
|
|
|
|
|
2007-10-17 01:23:08 +02:00
|
|
|
// Return true if this symbol can be preempted by a definition in
|
|
|
|
// another link unit.
|
|
|
|
bool
|
|
|
|
is_preemptible() const
|
|
|
|
{
|
2007-11-12 18:51:55 +01:00
|
|
|
// It doesn't make sense to ask whether a symbol defined in
|
|
|
|
// another object is preemptible.
|
|
|
|
gold_assert(!this->is_from_dynobj());
|
|
|
|
|
2008-02-08 23:49:22 +01:00
|
|
|
// It doesn't make sense to ask whether an undefined symbol
|
|
|
|
// is preemptible.
|
|
|
|
gold_assert(!this->is_undefined());
|
|
|
|
|
2008-05-06 19:46:31 +02:00
|
|
|
// If a symbol does not have default visibility, it can not be
|
|
|
|
// seen outside this link unit and therefore is not preemptible.
|
|
|
|
if (this->visibility_ != elfcpp::STV_DEFAULT)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If this symbol has been forced to be a local symbol by a
|
|
|
|
// version script, then it is not visible outside this link unit
|
|
|
|
// and is not preemptible.
|
|
|
|
if (this->is_forced_local_)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If we are not producing a shared library, then nothing is
|
|
|
|
// preemptible.
|
|
|
|
if (!parameters->options().shared())
|
|
|
|
return false;
|
|
|
|
|
2014-02-05 23:01:52 +01:00
|
|
|
// If the symbol was named in a --dynamic-list script, it is preemptible.
|
|
|
|
if (parameters->options().in_dynamic_list(this->name()))
|
|
|
|
return true;
|
|
|
|
|
Fix --dynamic-list so that symbols not in the list are still exported.
In PR 13577, the complaint was that -Bsymbolic was overriding the binding
behavior for symbols listed in the --dynamic-list by setting the DT_SYMBOLIC
tag in the dynamic table. In reading the Gnu ld manual, I decided that
--dynamic-list should be mutually exclusive of -Bsymbolic, and modified
gold so that --dynamic-list would treat symbols listed as preemptible,
and all other symbols as internally bound. I was wrong.
PR 16992 shows that with --dynamic-list (and not -Bsymbolic), a symbol
not listed in the dynamic list is being internally bound within the
shared library, but because it's still in the dynamic symbol table, we
expose it to a COPY relocation, and things go really bad from there.
(I can reproduce the same failure, simply by turning on -Bsymbolic-functions
with the Gnu linker. Even though the symbol is bound internally, it's
still exported to the dynamic symbol table, and is exposed to a COPY
relocation.)
I've backed out part of the fix for PR 13577, and -Bsymbolic (or
-Bsymbolic-functions) can now be used with --dynamic-list, but if the
two are used together, we do not set DT_SYMBOLIC or DF_SYMBOLIC
(this matches Gnu ld behavior). We now treat symbols listed in the
dynamic list as premptible, but we do not automatically treat symbols
not listed there as non-premptible.
gold/
PR gold/13577
PR gold/16992
* layout.cc (Layout::finish_dynamic_section): Don't set DT_SYMBOLIC or
DF_SYMBOLIC if --dynamic-list option is used.
* options.cc (General_options::finalize): --dynamic-list is not
mutually exclusive with -Bsymbolic.
* symtab.h (Symbol::is_preemptible): Don't exclude dynamic symbols not
listed in --dynamic-list.
* testsuite/Makefile.am (dynamic_list_lib2.so): Add
-Bsymbolic-functions.
* testsuite/Makefile.in: Regenerate.
2015-02-17 07:15:12 +01:00
|
|
|
// If the user used -Bsymbolic, then nothing (else) is preemptible.
|
|
|
|
if (parameters->options().Bsymbolic())
|
2008-05-06 19:46:31 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// If the user used -Bsymbolic-functions, then functions are not
|
|
|
|
// preemptible. We explicitly check for not being STT_OBJECT,
|
|
|
|
// rather than for being STT_FUNC, because that is what the GNU
|
|
|
|
// linker does.
|
|
|
|
if (this->type() != elfcpp::STT_OBJECT
|
|
|
|
&& parameters->options().Bsymbolic_functions())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Otherwise the symbol is preemptible.
|
|
|
|
return true;
|
2007-10-17 01:23:08 +02:00
|
|
|
}
|
|
|
|
|
2007-11-09 20:45:08 +01:00
|
|
|
// Return true if this symbol is a function that needs a PLT entry.
|
|
|
|
bool
|
|
|
|
needs_plt_entry() const
|
|
|
|
{
|
2009-03-25 02:34:25 +01:00
|
|
|
// An undefined symbol from an executable does not need a PLT entry.
|
|
|
|
if (this->is_undefined() && !parameters->options().shared())
|
|
|
|
return false;
|
|
|
|
|
2010-08-20 00:50:16 +02:00
|
|
|
// An STT_GNU_IFUNC symbol always needs a PLT entry, even when
|
|
|
|
// doing a static link.
|
|
|
|
if (this->type() == elfcpp::STT_GNU_IFUNC)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// We only need a PLT entry for a function.
|
|
|
|
if (!this->is_func())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If we're doing a static link or a -pie link, we don't create
|
|
|
|
// PLT entries.
|
|
|
|
if (parameters->doing_static_link()
|
|
|
|
|| parameters->options().pie())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// We need a PLT entry if the function is defined in a dynamic
|
|
|
|
// object, or is undefined when building a shared object, or if it
|
|
|
|
// is subject to pre-emption.
|
|
|
|
return (this->is_from_dynobj()
|
|
|
|
|| this->is_undefined()
|
|
|
|
|| this->is_preemptible());
|
2007-11-09 20:45:08 +01:00
|
|
|
}
|
|
|
|
|
2008-01-23 08:15:59 +01:00
|
|
|
// When determining whether a reference to a symbol needs a dynamic
|
|
|
|
// relocation, we need to know several things about the reference.
|
2010-11-11 11:43:30 +01:00
|
|
|
// These flags may be or'ed together. 0 means that the symbol
|
|
|
|
// isn't referenced at all.
|
2008-01-23 08:15:59 +01:00
|
|
|
enum Reference_flags
|
|
|
|
{
|
2010-11-11 11:43:30 +01:00
|
|
|
// A reference to the symbol's absolute address. This includes
|
|
|
|
// references that cause an absolute address to be stored in the GOT.
|
2008-01-23 08:15:59 +01:00
|
|
|
ABSOLUTE_REF = 1,
|
2010-11-11 11:43:30 +01:00
|
|
|
// A reference that calculates the offset of the symbol from some
|
|
|
|
// anchor point, such as the PC or GOT.
|
|
|
|
RELATIVE_REF = 2,
|
|
|
|
// A TLS-related reference.
|
|
|
|
TLS_REF = 4,
|
|
|
|
// A reference that can always be treated as a function call.
|
2013-11-01 06:39:56 +01:00
|
|
|
FUNCTION_CALL = 8,
|
|
|
|
// When set, says that dynamic relocations are needed even if a
|
|
|
|
// symbol has a plt entry.
|
|
|
|
FUNC_DESC_ABI = 16,
|
2008-01-23 08:15:59 +01:00
|
|
|
};
|
|
|
|
|
2007-11-09 20:45:08 +01:00
|
|
|
// Given a direct absolute or pc-relative static relocation against
|
|
|
|
// the global symbol, this function returns whether a dynamic relocation
|
|
|
|
// is needed.
|
|
|
|
|
|
|
|
bool
|
2008-01-23 08:15:59 +01:00
|
|
|
needs_dynamic_reloc(int flags) const
|
2007-11-09 20:45:08 +01:00
|
|
|
{
|
2008-02-08 23:49:22 +01:00
|
|
|
// No dynamic relocations in a static link!
|
|
|
|
if (parameters->doing_static_link())
|
|
|
|
return false;
|
|
|
|
|
2009-03-25 02:34:25 +01:00
|
|
|
// A reference to an undefined symbol from an executable should be
|
2008-04-17 02:14:36 +02:00
|
|
|
// statically resolved to 0, and does not need a dynamic relocation.
|
|
|
|
// This matches gnu ld behavior.
|
2009-03-25 02:34:25 +01:00
|
|
|
if (this->is_undefined() && !parameters->options().shared())
|
2008-04-17 02:14:36 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// A reference to an absolute symbol does not need a dynamic relocation.
|
|
|
|
if (this->is_absolute())
|
2008-04-04 19:24:47 +02:00
|
|
|
return false;
|
|
|
|
|
2007-11-09 20:45:08 +01:00
|
|
|
// An absolute reference within a position-independent output file
|
2008-01-23 08:15:59 +01:00
|
|
|
// will need a dynamic relocation.
|
|
|
|
if ((flags & ABSOLUTE_REF)
|
2008-02-28 01:18:24 +01:00
|
|
|
&& parameters->options().output_is_position_independent())
|
2007-11-09 20:45:08 +01:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// A function call that can branch to a local PLT entry does not need
|
2010-11-11 11:43:30 +01:00
|
|
|
// a dynamic relocation.
|
|
|
|
if ((flags & FUNCTION_CALL) && this->has_plt_offset())
|
2007-11-09 20:45:08 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// A reference to any PLT entry in a non-position-independent executable
|
|
|
|
// does not need a dynamic relocation.
|
2013-11-01 06:39:56 +01:00
|
|
|
if (!(flags & FUNC_DESC_ABI)
|
|
|
|
&& !parameters->options().output_is_position_independent()
|
2007-11-09 20:45:08 +01:00
|
|
|
&& this->has_plt_offset())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// A reference to a symbol defined in a dynamic object or to a
|
|
|
|
// symbol that is preemptible will need a dynamic relocation.
|
2008-02-08 23:49:22 +01:00
|
|
|
if (this->is_from_dynobj()
|
|
|
|
|| this->is_undefined()
|
|
|
|
|| this->is_preemptible())
|
2007-11-09 20:45:08 +01:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// For all other cases, return FALSE.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-08-05 00:22:13 +02:00
|
|
|
// Whether we should use the PLT offset associated with a symbol for
|
2010-11-11 11:43:30 +01:00
|
|
|
// a relocation. FLAGS is a set of Reference_flags.
|
2008-08-05 00:22:13 +02:00
|
|
|
|
|
|
|
bool
|
2010-11-11 11:43:30 +01:00
|
|
|
use_plt_offset(int flags) const
|
2008-08-05 00:22:13 +02:00
|
|
|
{
|
|
|
|
// If the symbol doesn't have a PLT offset, then naturally we
|
|
|
|
// don't want to use it.
|
|
|
|
if (!this->has_plt_offset())
|
|
|
|
return false;
|
|
|
|
|
2010-08-20 00:50:16 +02:00
|
|
|
// For a STT_GNU_IFUNC symbol we always have to use the PLT entry.
|
|
|
|
if (this->type() == elfcpp::STT_GNU_IFUNC)
|
|
|
|
return true;
|
|
|
|
|
2008-08-05 00:22:13 +02:00
|
|
|
// If we are going to generate a dynamic relocation, then we will
|
|
|
|
// wind up using that, so no need to use the PLT entry.
|
2010-11-11 11:43:30 +01:00
|
|
|
if (this->needs_dynamic_reloc(flags))
|
2008-08-05 00:22:13 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// If the symbol is from a dynamic object, we need to use the PLT
|
|
|
|
// entry.
|
|
|
|
if (this->is_from_dynobj())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// If we are generating a shared object, and this symbol is
|
|
|
|
// undefined or preemptible, we need to use the PLT entry.
|
|
|
|
if (parameters->options().shared()
|
|
|
|
&& (this->is_undefined() || this->is_preemptible()))
|
|
|
|
return true;
|
|
|
|
|
2010-11-11 11:43:30 +01:00
|
|
|
// If this is a call to a weak undefined symbol, we need to use
|
|
|
|
// the PLT entry; the symbol may be defined by a library loaded
|
|
|
|
// at runtime.
|
|
|
|
if ((flags & FUNCTION_CALL) && this->is_weak_undefined())
|
2008-08-05 00:22:13 +02:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// Otherwise we can use the regular definition.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2007-11-09 20:45:08 +01:00
|
|
|
// Given a direct absolute static relocation against
|
|
|
|
// the global symbol, where a dynamic relocation is needed, this
|
|
|
|
// function returns whether a relative dynamic relocation can be used.
|
|
|
|
// The caller must determine separately whether the static relocation
|
|
|
|
// is compatible with a relative relocation.
|
|
|
|
|
|
|
|
bool
|
|
|
|
can_use_relative_reloc(bool is_function_call) const
|
|
|
|
{
|
|
|
|
// A function call that can branch to a local PLT entry can
|
|
|
|
// use a RELATIVE relocation.
|
|
|
|
if (is_function_call && this->has_plt_offset())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// A reference to a symbol defined in a dynamic object or to a
|
2010-12-14 20:03:30 +01:00
|
|
|
// symbol that is preemptible can not use a RELATIVE relocation.
|
2008-02-08 23:49:22 +01:00
|
|
|
if (this->is_from_dynobj()
|
|
|
|
|| this->is_undefined()
|
|
|
|
|| this->is_preemptible())
|
2007-11-09 20:45:08 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// For all other cases, return TRUE.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
// Return the output section where this symbol is defined. Return
|
|
|
|
// NULL if the symbol has an absolute value.
|
|
|
|
Output_section*
|
|
|
|
output_section() const;
|
|
|
|
|
|
|
|
// Set the symbol's output section. This is used for symbols
|
|
|
|
// defined in scripts. This should only be called after the symbol
|
|
|
|
// table has been finalized.
|
|
|
|
void
|
|
|
|
set_output_section(Output_section*);
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2014-04-02 23:21:14 +02:00
|
|
|
// Set the symbol's output segment. This is used for pre-defined
|
|
|
|
// symbols whose segments aren't known until after layout is done
|
|
|
|
// (e.g., __ehdr_start).
|
|
|
|
void
|
|
|
|
set_output_segment(Output_segment*, Segment_offset_base);
|
|
|
|
|
|
|
|
// Set the symbol to undefined. This is used for pre-defined
|
|
|
|
// symbols whose segments aren't known until after layout is done
|
|
|
|
// (e.g., __ehdr_start).
|
|
|
|
void
|
|
|
|
set_undefined();
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
// Return whether there should be a warning for references to this
|
|
|
|
// symbol.
|
|
|
|
bool
|
|
|
|
has_warning() const
|
|
|
|
{ return this->has_warning_; }
|
|
|
|
|
|
|
|
// Mark this symbol as having a warning.
|
|
|
|
void
|
|
|
|
set_has_warning()
|
|
|
|
{ this->has_warning_ = true; }
|
|
|
|
|
2007-10-23 01:08:22 +02:00
|
|
|
// Return whether this symbol is defined by a COPY reloc from a
|
|
|
|
// dynamic object.
|
|
|
|
bool
|
|
|
|
is_copied_from_dynobj() const
|
|
|
|
{ return this->is_copied_from_dynobj_; }
|
|
|
|
|
|
|
|
// Mark this symbol as defined by a COPY reloc.
|
|
|
|
void
|
|
|
|
set_is_copied_from_dynobj()
|
|
|
|
{ this->is_copied_from_dynobj_ = true; }
|
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
// Return whether this symbol is forced to visibility STB_LOCAL
|
|
|
|
// by a "local:" entry in a version script.
|
|
|
|
bool
|
|
|
|
is_forced_local() const
|
|
|
|
{ return this->is_forced_local_; }
|
|
|
|
|
|
|
|
// Mark this symbol as forced to STB_LOCAL visibility.
|
|
|
|
void
|
|
|
|
set_is_forced_local()
|
|
|
|
{ this->is_forced_local_ = true; }
|
|
|
|
|
2009-10-01 02:58:38 +02:00
|
|
|
// Return true if this may need a COPY relocation.
|
|
|
|
// References from an executable object to non-function symbols
|
|
|
|
// defined in a dynamic object may need a COPY relocation.
|
|
|
|
bool
|
|
|
|
may_need_copy_reloc() const
|
|
|
|
{
|
2014-05-13 19:51:48 +02:00
|
|
|
return (parameters->options().copyreloc()
|
2009-10-01 02:58:38 +02:00
|
|
|
&& this->is_from_dynobj()
|
2009-12-07 18:14:55 +01:00
|
|
|
&& !this->is_func());
|
2009-10-01 02:58:38 +02:00
|
|
|
}
|
|
|
|
|
2011-06-08 06:05:25 +02:00
|
|
|
// Return true if this symbol was predefined by the linker.
|
|
|
|
bool
|
|
|
|
is_predefined() const
|
|
|
|
{ return this->is_predefined_; }
|
|
|
|
|
2013-05-21 23:14:40 +02:00
|
|
|
// Return true if this is a C++ vtable symbol.
|
|
|
|
bool
|
|
|
|
is_cxx_vtable() const
|
|
|
|
{ return is_prefix_of("_ZTV", this->name_); }
|
|
|
|
|
2016-05-19 23:58:18 +02:00
|
|
|
// Return true if this symbol is protected in a shared object.
|
|
|
|
// This is not the same as checking if visibility() == elfcpp::STV_PROTECTED,
|
|
|
|
// because the visibility_ field reflects the symbol's visibility from
|
|
|
|
// outside the shared object.
|
|
|
|
bool
|
|
|
|
is_protected() const
|
|
|
|
{ return this->is_protected_; }
|
|
|
|
|
|
|
|
// Mark this symbol as protected in a shared object.
|
|
|
|
void
|
|
|
|
set_is_protected()
|
|
|
|
{ this->is_protected_ = true; }
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
protected:
|
|
|
|
// Instances of this class should always be created at a specific
|
|
|
|
// size.
|
|
|
|
Symbol()
|
2006-11-06 23:46:08 +01:00
|
|
|
{ memset(this, 0, sizeof *this); }
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Initialize the general fields.
|
|
|
|
void
|
|
|
|
init_fields(const char* name, const char* version,
|
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility, unsigned char nonvis);
|
|
|
|
|
2008-04-19 20:30:58 +02:00
|
|
|
// Initialize fields from an ELF symbol in OBJECT. ST_SHNDX is the
|
|
|
|
// section index, IS_ORDINARY is whether it is a normal section
|
|
|
|
// index rather than a special code.
|
2006-08-19 00:29:20 +02:00
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2010-08-25 10:36:54 +02:00
|
|
|
init_base_object(const char* name, const char* version, Object* object,
|
2008-05-07 08:08:01 +02:00
|
|
|
const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
|
|
|
|
bool is_ordinary);
|
2006-08-05 01:10:59 +02:00
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Initialize fields for an Output_data.
|
|
|
|
void
|
2008-05-08 20:44:33 +02:00
|
|
|
init_base_output_data(const char* name, const char* version, Output_data*,
|
|
|
|
elfcpp::STT, elfcpp::STB, elfcpp::STV,
|
2011-06-08 06:05:25 +02:00
|
|
|
unsigned char nonvis, bool offset_is_from_end,
|
|
|
|
bool is_predefined);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
// Initialize fields for an Output_segment.
|
|
|
|
void
|
2008-05-08 20:44:33 +02:00
|
|
|
init_base_output_segment(const char* name, const char* version,
|
|
|
|
Output_segment* os, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding, elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis,
|
2011-06-08 06:05:25 +02:00
|
|
|
Segment_offset_base offset_base,
|
|
|
|
bool is_predefined);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
// Initialize fields for a constant.
|
|
|
|
void
|
2008-05-08 20:44:33 +02:00
|
|
|
init_base_constant(const char* name, const char* version, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding, elfcpp::STV visibility,
|
2011-06-08 06:05:25 +02:00
|
|
|
unsigned char nonvis, bool is_predefined);
|
2008-05-07 08:08:01 +02:00
|
|
|
|
|
|
|
// Initialize fields for an undefined symbol.
|
|
|
|
void
|
2008-05-08 20:44:33 +02:00
|
|
|
init_base_undefined(const char* name, const char* version, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding, elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Override existing symbol.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2008-04-19 20:30:58 +02:00
|
|
|
override_base(const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
|
|
|
|
bool is_ordinary, Object* object, const char* version);
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
// Override existing symbol with a special symbol.
|
|
|
|
void
|
|
|
|
override_base_with_special(const Symbol* from);
|
|
|
|
|
2008-05-08 20:44:33 +02:00
|
|
|
// Override symbol version.
|
|
|
|
void
|
|
|
|
override_version(const char* version);
|
|
|
|
|
2007-11-22 01:05:51 +01:00
|
|
|
// Allocate a common symbol by giving it a location in the output
|
|
|
|
// file.
|
|
|
|
void
|
|
|
|
allocate_base_common(Output_data*);
|
|
|
|
|
2006-08-05 01:10:59 +02:00
|
|
|
private:
|
2006-08-19 00:29:20 +02:00
|
|
|
Symbol(const Symbol&);
|
|
|
|
Symbol& operator=(const Symbol&);
|
|
|
|
|
|
|
|
// Symbol name (expected to point into a Stringpool).
|
|
|
|
const char* name_;
|
|
|
|
// Symbol version (expected to point into a Stringpool). This may
|
|
|
|
// be NULL.
|
2006-08-05 01:10:59 +02:00
|
|
|
const char* version_;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
union
|
|
|
|
{
|
|
|
|
// This struct is used if SOURCE_ == FROM_OBJECT.
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
// Object in which symbol is defined, or in which it was first
|
|
|
|
// seen.
|
|
|
|
Object* object;
|
|
|
|
// Section number in object_ in which symbol is defined.
|
2006-12-01 17:51:25 +01:00
|
|
|
unsigned int shndx;
|
2006-11-03 19:26:11 +01:00
|
|
|
} from_object;
|
|
|
|
|
|
|
|
// This struct is used if SOURCE_ == IN_OUTPUT_DATA.
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
// Output_data in which symbol is defined. Before
|
|
|
|
// Layout::finalize the symbol's value is an offset within the
|
|
|
|
// Output_data.
|
|
|
|
Output_data* output_data;
|
|
|
|
// True if the offset is from the end, false if the offset is
|
|
|
|
// from the beginning.
|
|
|
|
bool offset_is_from_end;
|
|
|
|
} in_output_data;
|
|
|
|
|
|
|
|
// This struct is used if SOURCE_ == IN_OUTPUT_SEGMENT.
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
// Output_segment in which the symbol is defined. Before
|
|
|
|
// Layout::finalize the symbol's value is an offset.
|
|
|
|
Output_segment* output_segment;
|
|
|
|
// The base to use for the offset before Layout::finalize.
|
|
|
|
Segment_offset_base offset_base;
|
|
|
|
} in_output_segment;
|
|
|
|
} u_;
|
|
|
|
|
2006-11-16 01:38:25 +01:00
|
|
|
// The index of this symbol in the output file. If the symbol is
|
|
|
|
// not going into the output file, this value is -1U. This field
|
|
|
|
// starts as always holding zero. It is set to a non-zero value by
|
|
|
|
// Symbol_table::finalize.
|
|
|
|
unsigned int symtab_index_;
|
|
|
|
|
|
|
|
// The index of this symbol in the dynamic symbol table. If the
|
|
|
|
// symbol is not going into the dynamic symbol table, this value is
|
|
|
|
// -1U. This field starts as always holding zero. It is set to a
|
|
|
|
// non-zero value during Layout::finalize.
|
|
|
|
unsigned int dynsym_index_;
|
|
|
|
|
2010-01-09 01:13:48 +01:00
|
|
|
// The GOT section entries for this symbol. A symbol may have more
|
|
|
|
// than one GOT offset (e.g., when mixing modules compiled with two
|
|
|
|
// different TLS models), but will usually have at most one.
|
2008-03-25 19:37:16 +01:00
|
|
|
Got_offset_list got_offsets_;
|
2007-11-14 23:31:02 +01:00
|
|
|
|
2010-01-09 01:13:48 +01:00
|
|
|
// If this symbol has an entry in the PLT section, then this is the
|
|
|
|
// offset from the start of the PLT section. This is -1U if there
|
|
|
|
// is no PLT entry.
|
2006-11-29 18:56:40 +01:00
|
|
|
unsigned int plt_offset_;
|
|
|
|
|
2008-04-19 20:30:58 +02:00
|
|
|
// Symbol type (bits 0 to 3).
|
2006-08-05 01:10:59 +02:00
|
|
|
elfcpp::STT type_ : 4;
|
2008-04-19 20:30:58 +02:00
|
|
|
// Symbol binding (bits 4 to 7).
|
2006-08-05 01:10:59 +02:00
|
|
|
elfcpp::STB binding_ : 4;
|
2008-04-19 20:30:58 +02:00
|
|
|
// Symbol visibility (bits 8 to 9).
|
2006-08-19 00:29:20 +02:00
|
|
|
elfcpp::STV visibility_ : 2;
|
2008-04-19 20:30:58 +02:00
|
|
|
// Rest of symbol st_other field (bits 10 to 15).
|
2006-11-03 19:26:11 +01:00
|
|
|
unsigned int nonvis_ : 6;
|
2008-04-19 20:30:58 +02:00
|
|
|
// The type of symbol (bits 16 to 18).
|
2006-11-06 23:46:08 +01:00
|
|
|
Source source_ : 3;
|
2010-01-09 01:13:48 +01:00
|
|
|
// True if this is the default version of the symbol (bit 19).
|
2006-09-07 23:21:41 +02:00
|
|
|
bool is_def_ : 1;
|
2006-08-19 00:29:20 +02:00
|
|
|
// True if this symbol really forwards to another symbol. This is
|
|
|
|
// used when we discover after the fact that two different entries
|
|
|
|
// in the hash table really refer to the same symbol. This will
|
|
|
|
// never be set for a symbol found in the hash table, but may be set
|
|
|
|
// for a symbol found in the list of symbols attached to an Object.
|
|
|
|
// It forwards to the symbol found in the forwarders_ map of
|
2010-01-09 01:13:48 +01:00
|
|
|
// Symbol_table (bit 20).
|
2006-09-07 23:21:41 +02:00
|
|
|
bool is_forwarder_ : 1;
|
2007-10-14 17:35:27 +02:00
|
|
|
// True if the symbol has an alias in the weak_aliases table in
|
2010-01-09 01:13:48 +01:00
|
|
|
// Symbol_table (bit 21).
|
2007-10-14 17:35:27 +02:00
|
|
|
bool has_alias_ : 1;
|
2008-04-19 20:30:58 +02:00
|
|
|
// True if this symbol needs to be in the dynamic symbol table (bit
|
2010-01-09 01:13:48 +01:00
|
|
|
// 22).
|
2006-11-16 01:38:25 +01:00
|
|
|
bool needs_dynsym_entry_ : 1;
|
2010-01-09 01:13:48 +01:00
|
|
|
// True if we've seen this symbol in a regular object (bit 23).
|
2006-12-06 07:28:56 +01:00
|
|
|
bool in_reg_ : 1;
|
2010-01-09 01:13:48 +01:00
|
|
|
// True if we've seen this symbol in a dynamic object (bit 24).
|
2006-09-07 23:21:41 +02:00
|
|
|
bool in_dyn_ : 1;
|
2007-09-23 07:31:48 +02:00
|
|
|
// True if this is a dynamic symbol which needs a special value in
|
2010-01-09 01:13:48 +01:00
|
|
|
// the dynamic symbol table (bit 25).
|
2007-09-23 07:31:48 +02:00
|
|
|
bool needs_dynsym_value_ : 1;
|
2010-01-09 01:13:48 +01:00
|
|
|
// True if there is a warning for this symbol (bit 26).
|
2006-11-06 23:46:08 +01:00
|
|
|
bool has_warning_ : 1;
|
2007-10-23 01:08:22 +02:00
|
|
|
// True if we are using a COPY reloc for this symbol, so that the
|
2010-01-09 01:13:48 +01:00
|
|
|
// real definition lives in a dynamic object (bit 27).
|
2007-10-23 01:08:22 +02:00
|
|
|
bool is_copied_from_dynobj_ : 1;
|
2008-01-24 01:15:00 +01:00
|
|
|
// True if this symbol was forced to local visibility by a version
|
2010-01-09 01:13:48 +01:00
|
|
|
// script (bit 28).
|
2008-01-24 01:15:00 +01:00
|
|
|
bool is_forced_local_ : 1;
|
2008-04-19 20:30:58 +02:00
|
|
|
// True if the field u_.from_object.shndx is an ordinary section
|
|
|
|
// index, not one of the special codes from SHN_LORESERVE to
|
2010-01-09 01:13:48 +01:00
|
|
|
// SHN_HIRESERVE (bit 29).
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary_shndx_ : 1;
|
2011-10-18 02:25:53 +02:00
|
|
|
// True if we've seen this symbol in a "real" ELF object (bit 30).
|
|
|
|
// If the symbol has been seen in a relocatable, non-IR, object file,
|
|
|
|
// it's known to be referenced from outside the IR. A reference from
|
|
|
|
// a dynamic object doesn't count as a "real" ELF, and we'll simply
|
|
|
|
// mark the symbol as "visible" from outside the IR. The compiler
|
|
|
|
// can use this distinction to guide its handling of COMDAT symbols.
|
2008-09-20 00:54:57 +02:00
|
|
|
bool in_real_elf_ : 1;
|
2010-01-09 01:13:48 +01:00
|
|
|
// True if this symbol is defined in a section which was discarded
|
|
|
|
// (bit 31).
|
|
|
|
bool is_defined_in_discarded_section_ : 1;
|
2010-07-09 03:34:31 +02:00
|
|
|
// True if UNDEF_BINDING_WEAK_ has been set (bit 32).
|
|
|
|
bool undef_binding_set_ : 1;
|
|
|
|
// True if this symbol was a weak undef resolved by a dynamic def
|
2014-04-02 23:21:14 +02:00
|
|
|
// or by a special symbol (bit 33).
|
2010-07-09 03:34:31 +02:00
|
|
|
bool undef_binding_weak_ : 1;
|
2011-06-08 06:05:25 +02:00
|
|
|
// True if this symbol is a predefined linker symbol (bit 34).
|
|
|
|
bool is_predefined_ : 1;
|
2016-05-19 23:58:18 +02:00
|
|
|
// True if this symbol has protected visibility in a shared object (bit 35).
|
|
|
|
// The visibility_ field will be STV_DEFAULT in this case because we
|
|
|
|
// must treat it as such from outside the shared object.
|
|
|
|
bool is_protected_ : 1;
|
2006-08-05 01:10:59 +02:00
|
|
|
};
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// The parts of a symbol which are size specific. Using a template
|
|
|
|
// derived class like this helps us use less space on a 32-bit system.
|
2006-08-05 01:10:59 +02:00
|
|
|
|
|
|
|
template<int size>
|
2006-08-19 00:29:20 +02:00
|
|
|
class Sized_symbol : public Symbol
|
|
|
|
{
|
|
|
|
public:
|
2006-09-07 23:21:41 +02:00
|
|
|
typedef typename elfcpp::Elf_types<size>::Elf_Addr Value_type;
|
|
|
|
typedef typename elfcpp::Elf_types<size>::Elf_WXword Size_type;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
Sized_symbol()
|
|
|
|
{ }
|
|
|
|
|
2008-04-19 20:30:58 +02:00
|
|
|
// Initialize fields from an ELF symbol in OBJECT. ST_SHNDX is the
|
|
|
|
// section index, IS_ORDINARY is whether it is a normal section
|
|
|
|
// index rather than a special code.
|
2006-08-19 00:29:20 +02:00
|
|
|
template<bool big_endian>
|
|
|
|
void
|
2010-08-25 10:36:54 +02:00
|
|
|
init_object(const char* name, const char* version, Object* object,
|
2008-05-07 08:08:01 +02:00
|
|
|
const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
|
|
|
|
bool is_ordinary);
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Initialize fields for an Output_data.
|
|
|
|
void
|
2008-05-08 20:44:33 +02:00
|
|
|
init_output_data(const char* name, const char* version, Output_data*,
|
|
|
|
Value_type value, Size_type symsize, elfcpp::STT,
|
|
|
|
elfcpp::STB, elfcpp::STV, unsigned char nonvis,
|
2011-06-08 06:05:25 +02:00
|
|
|
bool offset_is_from_end, bool is_predefined);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
// Initialize fields for an Output_segment.
|
|
|
|
void
|
2008-05-08 20:44:33 +02:00
|
|
|
init_output_segment(const char* name, const char* version, Output_segment*,
|
|
|
|
Value_type value, Size_type symsize, elfcpp::STT,
|
|
|
|
elfcpp::STB, elfcpp::STV, unsigned char nonvis,
|
2011-06-08 06:05:25 +02:00
|
|
|
Segment_offset_base offset_base, bool is_predefined);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
// Initialize fields for a constant.
|
|
|
|
void
|
2008-05-08 20:44:33 +02:00
|
|
|
init_constant(const char* name, const char* version, Value_type value,
|
|
|
|
Size_type symsize, elfcpp::STT, elfcpp::STB, elfcpp::STV,
|
2011-06-08 06:05:25 +02:00
|
|
|
unsigned char nonvis, bool is_predefined);
|
2008-05-07 08:08:01 +02:00
|
|
|
|
|
|
|
// Initialize fields for an undefined symbol.
|
|
|
|
void
|
2016-02-05 01:55:39 +01:00
|
|
|
init_undefined(const char* name, const char* version, Value_type value,
|
|
|
|
elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Override existing symbol.
|
|
|
|
template<bool big_endian>
|
|
|
|
void
|
2008-04-19 20:30:58 +02:00
|
|
|
override(const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
|
|
|
|
bool is_ordinary, Object* object, const char* version);
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
// Override existing symbol with a special symbol.
|
|
|
|
void
|
|
|
|
override_with_special(const Sized_symbol<size>*);
|
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Return the symbol's value.
|
|
|
|
Value_type
|
|
|
|
value() const
|
|
|
|
{ return this->value_; }
|
|
|
|
|
|
|
|
// Return the symbol's size (we can't call this 'size' because that
|
|
|
|
// is a template parameter).
|
|
|
|
Size_type
|
|
|
|
symsize() const
|
2006-11-03 19:26:11 +01:00
|
|
|
{ return this->symsize_; }
|
|
|
|
|
|
|
|
// Set the symbol size. This is used when resolving common symbols.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_symsize(Size_type symsize)
|
|
|
|
{ this->symsize_ = symsize; }
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-09-28 00:53:42 +02:00
|
|
|
// Set the symbol value. This is called when we store the final
|
|
|
|
// values of the symbols into the symbol table.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_value(Value_type value)
|
|
|
|
{ this->value_ = value; }
|
2006-09-28 00:53:42 +02:00
|
|
|
|
2007-11-22 01:05:51 +01:00
|
|
|
// Allocate a common symbol by giving it a location in the output
|
|
|
|
// file.
|
|
|
|
void
|
|
|
|
allocate_common(Output_data*, Value_type value);
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
private:
|
|
|
|
Sized_symbol(const Sized_symbol&);
|
|
|
|
Sized_symbol& operator=(const Sized_symbol&);
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Symbol value. Before Layout::finalize this is the offset in the
|
|
|
|
// input section. This is set to the final value during
|
|
|
|
// Layout::finalize.
|
2006-09-07 23:21:41 +02:00
|
|
|
Value_type value_;
|
2006-08-19 00:29:20 +02:00
|
|
|
// Symbol size.
|
2006-11-03 19:26:11 +01:00
|
|
|
Size_type symsize_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// A struct describing a symbol defined by the linker, where the value
|
|
|
|
// of the symbol is defined based on an output section. This is used
|
|
|
|
// for symbols defined by the linker, like "_init_array_start".
|
|
|
|
|
|
|
|
struct Define_symbol_in_section
|
|
|
|
{
|
|
|
|
// The symbol name.
|
|
|
|
const char* name;
|
|
|
|
// The name of the output section with which this symbol should be
|
|
|
|
// associated. If there is no output section with that name, the
|
|
|
|
// symbol will be defined as zero.
|
|
|
|
const char* output_section;
|
|
|
|
// The offset of the symbol within the output section. This is an
|
|
|
|
// offset from the start of the output section, unless start_at_end
|
|
|
|
// is true, in which case this is an offset from the end of the
|
|
|
|
// output section.
|
|
|
|
uint64_t value;
|
|
|
|
// The size of the symbol.
|
|
|
|
uint64_t size;
|
|
|
|
// The symbol type.
|
|
|
|
elfcpp::STT type;
|
|
|
|
// The symbol binding.
|
|
|
|
elfcpp::STB binding;
|
|
|
|
// The symbol visibility.
|
|
|
|
elfcpp::STV visibility;
|
|
|
|
// The rest of the st_other field.
|
|
|
|
unsigned char nonvis;
|
|
|
|
// If true, the value field is an offset from the end of the output
|
|
|
|
// section.
|
|
|
|
bool offset_is_from_end;
|
|
|
|
// If true, this symbol is defined only if we see a reference to it.
|
|
|
|
bool only_if_ref;
|
|
|
|
};
|
|
|
|
|
|
|
|
// A struct describing a symbol defined by the linker, where the value
|
|
|
|
// of the symbol is defined based on a segment. This is used for
|
|
|
|
// symbols defined by the linker, like "_end". We describe the
|
|
|
|
// segment with which the symbol should be associated by its
|
|
|
|
// characteristics. If no segment meets these characteristics, the
|
|
|
|
// symbol will be defined as zero. If there is more than one segment
|
|
|
|
// which meets these characteristics, we will use the first one.
|
|
|
|
|
|
|
|
struct Define_symbol_in_segment
|
|
|
|
{
|
|
|
|
// The symbol name.
|
|
|
|
const char* name;
|
|
|
|
// The segment type where the symbol should be defined, typically
|
|
|
|
// PT_LOAD.
|
|
|
|
elfcpp::PT segment_type;
|
|
|
|
// Bitmask of segment flags which must be set.
|
|
|
|
elfcpp::PF segment_flags_set;
|
|
|
|
// Bitmask of segment flags which must be clear.
|
|
|
|
elfcpp::PF segment_flags_clear;
|
|
|
|
// The offset of the symbol within the segment. The offset is
|
|
|
|
// calculated from the position set by offset_base.
|
|
|
|
uint64_t value;
|
|
|
|
// The size of the symbol.
|
|
|
|
uint64_t size;
|
|
|
|
// The symbol type.
|
|
|
|
elfcpp::STT type;
|
|
|
|
// The symbol binding.
|
|
|
|
elfcpp::STB binding;
|
|
|
|
// The symbol visibility.
|
|
|
|
elfcpp::STV visibility;
|
|
|
|
// The rest of the st_other field.
|
|
|
|
unsigned char nonvis;
|
|
|
|
// The base from which we compute the offset.
|
|
|
|
Symbol::Segment_offset_base offset_base;
|
|
|
|
// If true, this symbol is defined only if we see a reference to it.
|
|
|
|
bool only_if_ref;
|
2006-08-19 00:29:20 +02:00
|
|
|
};
|
|
|
|
|
2013-03-11 00:08:18 +01:00
|
|
|
// Specify an object/section/offset location. Used by ODR code.
|
|
|
|
|
|
|
|
struct Symbol_location
|
|
|
|
{
|
|
|
|
// Object where the symbol is defined.
|
|
|
|
Object* object;
|
|
|
|
// Section-in-object where the symbol is defined.
|
|
|
|
unsigned int shndx;
|
|
|
|
// For relocatable objects, offset-in-section where the symbol is defined.
|
|
|
|
// For dynamic objects, address where the symbol is defined.
|
|
|
|
off_t offset;
|
|
|
|
bool operator==(const Symbol_location& that) const
|
|
|
|
{
|
|
|
|
return (this->object == that.object
|
|
|
|
&& this->shndx == that.shndx
|
|
|
|
&& this->offset == that.offset);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
// This class manages warnings. Warnings are a GNU extension. When
|
|
|
|
// we see a section named .gnu.warning.SYM in an object file, and if
|
|
|
|
// we wind using the definition of SYM from that object file, then we
|
|
|
|
// will issue a warning for any relocation against SYM from a
|
|
|
|
// different object file. The text of the warning is the contents of
|
|
|
|
// the section. This is not precisely the definition used by the old
|
|
|
|
// GNU linker; the old GNU linker treated an occurrence of
|
|
|
|
// .gnu.warning.SYM as defining a warning symbol. A warning symbol
|
|
|
|
// would trigger a warning on any reference. However, it was
|
|
|
|
// inconsistent in that a warning in a dynamic object only triggered
|
|
|
|
// if there was no definition in a regular object. This linker is
|
|
|
|
// different in that we only issue a warning if we use the symbol
|
|
|
|
// definition from the same object file as the warning section.
|
|
|
|
|
|
|
|
class Warnings
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Warnings()
|
|
|
|
: warnings_()
|
|
|
|
{ }
|
|
|
|
|
2008-01-03 00:48:49 +01:00
|
|
|
// Add a warning for symbol NAME in object OBJ. WARNING is the text
|
|
|
|
// of the warning.
|
2006-11-06 23:46:08 +01:00
|
|
|
void
|
|
|
|
add_warning(Symbol_table* symtab, const char* name, Object* obj,
|
2008-01-03 00:48:49 +01:00
|
|
|
const std::string& warning);
|
2006-11-06 23:46:08 +01:00
|
|
|
|
|
|
|
// For each symbol for which we should give a warning, make a note
|
|
|
|
// on the symbol.
|
|
|
|
void
|
2008-01-03 00:48:49 +01:00
|
|
|
note_warnings(Symbol_table* symtab);
|
2006-11-06 23:46:08 +01:00
|
|
|
|
2007-10-14 08:49:14 +02:00
|
|
|
// Issue a warning for a reference to SYM at RELINFO's location.
|
|
|
|
template<int size, bool big_endian>
|
2006-11-06 23:46:08 +01:00
|
|
|
void
|
2007-10-14 08:49:14 +02:00
|
|
|
issue_warning(const Symbol* sym, const Relocate_info<size, big_endian>*,
|
|
|
|
size_t relnum, off_t reloffset) const;
|
2006-11-06 23:46:08 +01:00
|
|
|
|
|
|
|
private:
|
|
|
|
Warnings(const Warnings&);
|
|
|
|
Warnings& operator=(const Warnings&);
|
|
|
|
|
|
|
|
// What we need to know to get the warning text.
|
|
|
|
struct Warning_location
|
|
|
|
{
|
|
|
|
// The object the warning is in.
|
|
|
|
Object* object;
|
2008-01-03 00:48:49 +01:00
|
|
|
// The warning text.
|
2006-11-06 23:46:08 +01:00
|
|
|
std::string text;
|
|
|
|
|
|
|
|
Warning_location()
|
2008-01-03 00:48:49 +01:00
|
|
|
: object(NULL), text()
|
2006-11-06 23:46:08 +01:00
|
|
|
{ }
|
|
|
|
|
|
|
|
void
|
2008-01-03 00:48:49 +01:00
|
|
|
set(Object* o, const std::string& t)
|
2006-11-06 23:46:08 +01:00
|
|
|
{
|
|
|
|
this->object = o;
|
2008-01-03 00:48:49 +01:00
|
|
|
this->text = t;
|
2006-11-06 23:46:08 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// A mapping from warning symbol names (canonicalized in
|
2007-11-13 21:02:32 +01:00
|
|
|
// Symbol_table's namepool_ field) to warning information.
|
2006-11-06 23:46:08 +01:00
|
|
|
typedef Unordered_map<const char*, Warning_location> Warning_table;
|
|
|
|
|
|
|
|
Warning_table warnings_;
|
|
|
|
};
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// The main linker symbol table.
|
|
|
|
|
2006-08-05 01:10:59 +02:00
|
|
|
class Symbol_table
|
|
|
|
{
|
|
|
|
public:
|
2009-12-29 01:31:48 +01:00
|
|
|
// The different places where a symbol definition can come from.
|
|
|
|
enum Defined
|
|
|
|
{
|
|
|
|
// Defined in an object file--the normal case.
|
|
|
|
OBJECT,
|
|
|
|
// Defined for a COPY reloc.
|
|
|
|
COPY,
|
|
|
|
// Defined on the command line using --defsym.
|
|
|
|
DEFSYM,
|
|
|
|
// Defined (so to speak) on the command line using -u.
|
|
|
|
UNDEFINED,
|
|
|
|
// Defined in a linker script.
|
|
|
|
SCRIPT,
|
|
|
|
// Predefined by the linker.
|
|
|
|
PREDEFINED,
|
2011-06-08 06:05:25 +02:00
|
|
|
// Defined by the linker during an incremental base link, but not
|
|
|
|
// a predefined symbol (e.g., common, defined in script).
|
|
|
|
INCREMENTAL_BASE,
|
2009-12-29 01:31:48 +01:00
|
|
|
};
|
|
|
|
|
2009-12-31 02:57:55 +01:00
|
|
|
// The order in which we sort common symbols.
|
|
|
|
enum Sort_commons_order
|
|
|
|
{
|
|
|
|
SORT_COMMONS_BY_SIZE_DESCENDING,
|
|
|
|
SORT_COMMONS_BY_ALIGNMENT_DESCENDING,
|
|
|
|
SORT_COMMONS_BY_ALIGNMENT_ASCENDING
|
|
|
|
};
|
|
|
|
|
2010-12-14 20:03:30 +01:00
|
|
|
// COUNT is an estimate of how many symbols will be inserted in the
|
2007-12-14 06:24:17 +01:00
|
|
|
// symbol table. It's ok to put 0 if you don't know; a correct
|
|
|
|
// guess will just save some CPU by reducing hashtable resizes.
|
2008-01-16 00:41:28 +01:00
|
|
|
Symbol_table(unsigned int count, const Version_script_info& version_script);
|
2006-08-05 01:10:59 +02:00
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
~Symbol_table();
|
2006-08-05 01:10:59 +02:00
|
|
|
|
2009-08-05 22:51:56 +02:00
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_icf(Icf* icf)
|
|
|
|
{ this->icf_ = icf;}
|
2009-08-05 22:51:56 +02:00
|
|
|
|
|
|
|
Icf*
|
|
|
|
icf() const
|
|
|
|
{ return this->icf_; }
|
|
|
|
|
|
|
|
// Returns true if ICF determined that this is a duplicate section.
|
|
|
|
bool
|
2015-05-02 17:40:09 +02:00
|
|
|
is_section_folded(Relobj* obj, unsigned int shndx) const;
|
2009-08-05 22:51:56 +02:00
|
|
|
|
2009-01-28 03:25:33 +01:00
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_gc(Garbage_collection* gc)
|
|
|
|
{ this->gc_ = gc; }
|
2009-01-28 03:25:33 +01:00
|
|
|
|
|
|
|
Garbage_collection*
|
2009-08-05 22:51:56 +02:00
|
|
|
gc() const
|
2009-01-28 03:25:33 +01:00
|
|
|
{ return this->gc_; }
|
|
|
|
|
|
|
|
// During garbage collection, this keeps undefined symbols.
|
|
|
|
void
|
2010-08-02 15:34:33 +02:00
|
|
|
gc_mark_undef_symbols(Layout*);
|
2009-01-28 03:25:33 +01:00
|
|
|
|
2011-10-31 22:36:54 +01:00
|
|
|
// This tells garbage collection that this symbol is referenced.
|
2009-01-28 03:25:33 +01:00
|
|
|
void
|
2011-10-31 22:36:54 +01:00
|
|
|
gc_mark_symbol(Symbol* sym);
|
2009-01-28 03:25:33 +01:00
|
|
|
|
|
|
|
// During garbage collection, this keeps sections that correspond to
|
|
|
|
// symbols seen in dynamic objects.
|
|
|
|
inline void
|
|
|
|
gc_mark_dyn_syms(Symbol* sym);
|
|
|
|
|
2006-11-14 20:21:05 +01:00
|
|
|
// Add COUNT external symbols from the relocatable object RELOBJ to
|
2008-04-19 20:30:58 +02:00
|
|
|
// the symbol table. SYMS is the symbols, SYMNDX_OFFSET is the
|
|
|
|
// offset in the symbol table of the first symbol, SYM_NAMES is
|
|
|
|
// their names, SYM_NAME_SIZE is the size of SYM_NAMES. This sets
|
2008-07-23 00:08:43 +02:00
|
|
|
// SYMPOINTERS to point to the symbols in the symbol table. It sets
|
|
|
|
// *DEFINED to the number of defined symbols.
|
2006-08-19 00:29:20 +02:00
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2011-05-24 23:41:10 +02:00
|
|
|
add_from_relobj(Sized_relobj_file<size, big_endian>* relobj,
|
2006-11-14 20:21:05 +01:00
|
|
|
const unsigned char* syms, size_t count,
|
2008-04-19 20:30:58 +02:00
|
|
|
size_t symndx_offset, const char* sym_names,
|
|
|
|
size_t sym_name_size,
|
2011-05-24 23:41:10 +02:00
|
|
|
typename Sized_relobj_file<size, big_endian>::Symbols*,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2008-09-20 00:54:57 +02:00
|
|
|
|
|
|
|
// Add one external symbol from the plugin object OBJ to the symbol table.
|
|
|
|
// Returns a pointer to the resolved symbol in the symbol table.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
Symbol*
|
|
|
|
add_from_pluginobj(Sized_pluginobj<size, big_endian>* obj,
|
|
|
|
const char* name, const char* ver,
|
|
|
|
elfcpp::Sym<size, big_endian>* sym);
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2006-11-14 20:21:05 +01:00
|
|
|
// Add COUNT dynamic symbols from the dynamic object DYNOBJ to the
|
|
|
|
// symbol table. SYMS is the symbols. SYM_NAMES is their names.
|
|
|
|
// SYM_NAME_SIZE is the size of SYM_NAMES. The other parameters are
|
|
|
|
// symbol version data.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
add_from_dynobj(Sized_dynobj<size, big_endian>* dynobj,
|
|
|
|
const unsigned char* syms, size_t count,
|
|
|
|
const char* sym_names, size_t sym_name_size,
|
|
|
|
const unsigned char* versym, size_t versym_size,
|
2008-07-23 00:08:43 +02:00
|
|
|
const std::vector<const char*>*,
|
2011-05-24 23:41:10 +02:00
|
|
|
typename Sized_relobj_file<size, big_endian>::Symbols*,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2011-04-12 02:44:48 +02:00
|
|
|
// Add one external symbol from the incremental object OBJ to the symbol
|
|
|
|
// table. Returns a pointer to the resolved symbol in the symbol table.
|
|
|
|
template<int size, bool big_endian>
|
2011-06-08 05:50:12 +02:00
|
|
|
Sized_symbol<size>*
|
2011-04-12 02:44:48 +02:00
|
|
|
add_from_incrobj(Object* obj, const char* name,
|
|
|
|
const char* ver, elfcpp::Sym<size, big_endian>* sym);
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Define a special symbol based on an Output_data. It is a
|
|
|
|
// multiple definition error if this symbol is already defined.
|
2006-12-06 01:02:36 +01:00
|
|
|
Symbol*
|
2009-12-29 01:31:48 +01:00
|
|
|
define_in_output_data(const char* name, const char* version, Defined,
|
2006-12-06 01:02:36 +01:00
|
|
|
Output_data*, uint64_t value, uint64_t symsize,
|
2006-11-03 19:26:11 +01:00
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility, unsigned char nonvis,
|
|
|
|
bool offset_is_from_end, bool only_if_ref);
|
|
|
|
|
|
|
|
// Define a special symbol based on an Output_segment. It is a
|
|
|
|
// multiple definition error if this symbol is already defined.
|
2006-12-06 01:02:36 +01:00
|
|
|
Symbol*
|
2009-12-29 01:31:48 +01:00
|
|
|
define_in_output_segment(const char* name, const char* version, Defined,
|
2008-01-26 02:17:45 +01:00
|
|
|
Output_segment*, uint64_t value, uint64_t symsize,
|
2006-11-03 19:26:11 +01:00
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility, unsigned char nonvis,
|
|
|
|
Symbol::Segment_offset_base, bool only_if_ref);
|
|
|
|
|
|
|
|
// Define a special symbol with a constant value. It is a multiple
|
|
|
|
// definition error if this symbol is already defined.
|
2006-12-06 01:02:36 +01:00
|
|
|
Symbol*
|
2009-12-29 01:31:48 +01:00
|
|
|
define_as_constant(const char* name, const char* version, Defined,
|
2006-12-06 01:02:36 +01:00
|
|
|
uint64_t value, uint64_t symsize, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding, elfcpp::STV visibility,
|
2008-02-13 02:20:38 +01:00
|
|
|
unsigned char nonvis, bool only_if_ref,
|
|
|
|
bool force_override);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Define a set of symbols in output sections. If ONLY_IF_REF is
|
|
|
|
// true, only define them if they are referenced.
|
2006-11-03 19:26:11 +01:00
|
|
|
void
|
2008-02-04 06:43:05 +01:00
|
|
|
define_symbols(const Layout*, int count, const Define_symbol_in_section*,
|
|
|
|
bool only_if_ref);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
// Define a set of symbols in output segments. If ONLY_IF_REF is
|
|
|
|
// true, only defined them if they are referenced.
|
2006-11-03 19:26:11 +01:00
|
|
|
void
|
2008-02-04 06:43:05 +01:00
|
|
|
define_symbols(const Layout*, int count, const Define_symbol_in_segment*,
|
|
|
|
bool only_if_ref);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2016-02-05 01:55:39 +01:00
|
|
|
// Add a target-specific global symbol.
|
|
|
|
// (Used by SPARC backend to add STT_SPARC_REGISTER symbols.)
|
|
|
|
void
|
|
|
|
add_target_global_symbol(Symbol* sym)
|
|
|
|
{ this->target_symbols_.push_back(sym); }
|
|
|
|
|
2007-10-23 01:08:22 +02:00
|
|
|
// Define SYM using a COPY reloc. POSD is the Output_data where the
|
|
|
|
// symbol should be defined--typically a .dyn.bss section. VALUE is
|
|
|
|
// the offset within POSD.
|
|
|
|
template<int size>
|
|
|
|
void
|
2008-01-26 02:17:45 +01:00
|
|
|
define_with_copy_reloc(Sized_symbol<size>* sym, Output_data* posd,
|
2007-12-20 22:21:24 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr);
|
2007-10-23 01:08:22 +02:00
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
// Look up a symbol.
|
|
|
|
Symbol*
|
|
|
|
lookup(const char*, const char* version = NULL) const;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Return the real symbol associated with the forwarder symbol FROM.
|
2006-08-05 01:10:59 +02:00
|
|
|
Symbol*
|
2006-11-16 01:38:25 +01:00
|
|
|
resolve_forwards(const Symbol* from) const;
|
2006-08-05 01:10:59 +02:00
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// Return the sized version of a symbol in this table.
|
|
|
|
template<int size>
|
|
|
|
Sized_symbol<size>*
|
2008-02-29 20:19:17 +01:00
|
|
|
get_sized_symbol(Symbol*) const;
|
2006-09-07 23:21:41 +02:00
|
|
|
|
|
|
|
template<int size>
|
|
|
|
const Sized_symbol<size>*
|
2008-02-29 20:19:17 +01:00
|
|
|
get_sized_symbol(const Symbol*) const;
|
2006-09-26 23:00:34 +02:00
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Return the count of undefined symbols seen.
|
2010-02-12 04:23:26 +01:00
|
|
|
size_t
|
2006-11-03 19:26:11 +01:00
|
|
|
saw_undefined() const
|
|
|
|
{ return this->saw_undefined_; }
|
|
|
|
|
|
|
|
// Allocate the common symbols
|
|
|
|
void
|
2008-05-21 23:37:44 +02:00
|
|
|
allocate_commons(Layout*, Mapfile*);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-01-03 00:48:49 +01:00
|
|
|
// Add a warning for symbol NAME in object OBJ. WARNING is the text
|
|
|
|
// of the warning.
|
2006-11-06 23:46:08 +01:00
|
|
|
void
|
2008-01-03 00:48:49 +01:00
|
|
|
add_warning(const char* name, Object* obj, const std::string& warning)
|
|
|
|
{ this->warnings_.add_warning(this, name, obj, warning); }
|
2006-11-06 23:46:08 +01:00
|
|
|
|
|
|
|
// Canonicalize a symbol name for use in the hash table.
|
|
|
|
const char*
|
|
|
|
canonicalize_name(const char* name)
|
2007-10-12 08:06:34 +02:00
|
|
|
{ return this->namepool_.add(name, true, NULL); }
|
2006-11-06 23:46:08 +01:00
|
|
|
|
|
|
|
// Possibly issue a warning for a reference to SYM at LOCATION which
|
|
|
|
// is in OBJ.
|
2007-10-14 08:49:14 +02:00
|
|
|
template<int size, bool big_endian>
|
2006-11-06 23:46:08 +01:00
|
|
|
void
|
2007-10-14 08:49:14 +02:00
|
|
|
issue_warning(const Symbol* sym,
|
|
|
|
const Relocate_info<size, big_endian>* relinfo,
|
|
|
|
size_t relnum, off_t reloffset) const
|
|
|
|
{ this->warnings_.issue_warning(sym, relinfo, relnum, reloffset); }
|
2006-11-06 23:46:08 +01:00
|
|
|
|
2007-11-13 21:02:32 +01:00
|
|
|
// Check candidate_odr_violations_ to find symbols with the same name
|
|
|
|
// but apparently different definitions (different source-file/line-no).
|
|
|
|
void
|
2007-12-14 20:00:21 +01:00
|
|
|
detect_odr_violations(const Task*, const char* output_file_name) const;
|
2007-11-13 21:02:32 +01:00
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
// Add any undefined symbols named on the command line to the symbol
|
|
|
|
// table.
|
|
|
|
void
|
2010-08-02 15:34:33 +02:00
|
|
|
add_undefined_symbols_from_command_line(Layout*);
|
2008-05-07 08:08:01 +02:00
|
|
|
|
2007-10-23 01:08:22 +02:00
|
|
|
// SYM is defined using a COPY reloc. Return the dynamic object
|
|
|
|
// where the original definition was found.
|
|
|
|
Dynobj*
|
|
|
|
get_copy_source(const Symbol* sym) const;
|
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
// Set the dynamic symbol indexes. INDEX is the index of the first
|
|
|
|
// global dynamic symbol. Pointers to the symbols are stored into
|
|
|
|
// the vector. The names are stored into the Stringpool. This
|
|
|
|
// returns an updated dynamic symbol index.
|
|
|
|
unsigned int
|
2008-01-26 02:17:45 +01:00
|
|
|
set_dynsym_indexes(unsigned int index, std::vector<Symbol*>*,
|
|
|
|
Stringpool*, Versions*);
|
2006-11-29 18:56:40 +01:00
|
|
|
|
2006-09-28 00:53:42 +02:00
|
|
|
// Finalize the symbol table after we have set the final addresses
|
2006-11-16 01:38:25 +01:00
|
|
|
// of all the input sections. This sets the final symbol indexes,
|
2008-01-24 01:15:00 +01:00
|
|
|
// values and adds the names to *POOL. *PLOCAL_SYMCOUNT is the
|
|
|
|
// index of the first global symbol. OFF is the file offset of the
|
|
|
|
// global symbol table, DYNOFF is the offset of the globals in the
|
|
|
|
// dynamic symbol table, DYN_GLOBAL_INDEX is the index of the first
|
|
|
|
// global dynamic symbol, and DYNCOUNT is the number of global
|
|
|
|
// dynamic symbols. This records the parameters, and returns the
|
|
|
|
// new file offset. It updates *PLOCAL_SYMCOUNT if it created any
|
|
|
|
// local symbols.
|
2006-09-28 00:53:42 +02:00
|
|
|
off_t
|
2008-01-24 01:15:00 +01:00
|
|
|
finalize(off_t off, off_t dynoff, size_t dyn_global_index, size_t dyncount,
|
2010-08-25 10:36:54 +02:00
|
|
|
Stringpool* pool, unsigned int* plocal_symcount);
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2011-04-12 02:44:48 +02:00
|
|
|
// Set the final file offset of the symbol table.
|
|
|
|
void
|
|
|
|
set_file_offset(off_t off)
|
|
|
|
{ this->offset_ = off; }
|
|
|
|
|
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
|
|
|
// Status code of Symbol_table::compute_final_value.
|
|
|
|
enum Compute_final_value_status
|
|
|
|
{
|
|
|
|
// No error.
|
|
|
|
CFVS_OK,
|
2010-12-14 20:03:30 +01:00
|
|
|
// Unsupported symbol 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
|
|
|
CFVS_UNSUPPORTED_SYMBOL_SECTION,
|
|
|
|
// No output section.
|
|
|
|
CFVS_NO_OUTPUT_SECTION
|
|
|
|
};
|
|
|
|
|
|
|
|
// Compute the final value of SYM and store status in location PSTATUS.
|
|
|
|
// During relaxation, this may be called multiple times for a symbol to
|
|
|
|
// compute its would-be final value in each relaxation pass.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
typename Sized_symbol<size>::Value_type
|
|
|
|
compute_final_value(const Sized_symbol<size>* sym,
|
|
|
|
Compute_final_value_status* pstatus) const;
|
|
|
|
|
2010-08-13 00:01:11 +02:00
|
|
|
// Return the index of the first global symbol.
|
|
|
|
unsigned int
|
|
|
|
first_global_index() const
|
|
|
|
{ return this->first_global_index_; }
|
|
|
|
|
|
|
|
// Return the total number of symbols in the symbol table.
|
|
|
|
unsigned int
|
|
|
|
output_count() const
|
|
|
|
{ return this->output_count_; }
|
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
// Write out the global symbols.
|
|
|
|
void
|
2009-02-28 05:39:57 +01:00
|
|
|
write_globals(const Stringpool*, const Stringpool*,
|
2008-04-19 20:30:58 +02:00
|
|
|
Output_symtab_xindex*, Output_symtab_xindex*,
|
2006-12-01 17:51:25 +01:00
|
|
|
Output_file*) const;
|
2006-09-29 21:58:17 +02:00
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
// Write out a section symbol. Return the updated offset.
|
|
|
|
void
|
2008-04-19 20:30:58 +02:00
|
|
|
write_section_symbol(const Output_section*, Output_symtab_xindex*,
|
|
|
|
Output_file*, off_t) const;
|
2006-11-29 18:56:40 +01:00
|
|
|
|
2010-08-13 00:15:00 +02:00
|
|
|
// Loop over all symbols, applying the function F to each.
|
|
|
|
template<int size, typename F>
|
|
|
|
void
|
|
|
|
for_all_symbols(F f) const
|
|
|
|
{
|
|
|
|
for (Symbol_table_type::const_iterator p = this->table_.begin();
|
|
|
|
p != this->table_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
|
|
|
|
f(sym);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-05 00:11:35 +01:00
|
|
|
// Dump statistical information to stderr.
|
|
|
|
void
|
|
|
|
print_stats() const;
|
|
|
|
|
2008-01-16 00:41:28 +01:00
|
|
|
// Return the version script information.
|
|
|
|
const Version_script_info&
|
|
|
|
version_script() const
|
|
|
|
{ return version_script_; }
|
|
|
|
|
2006-08-05 01:10:59 +02:00
|
|
|
private:
|
|
|
|
Symbol_table(const Symbol_table&);
|
|
|
|
Symbol_table& operator=(const Symbol_table&);
|
|
|
|
|
2008-04-17 09:12:00 +02:00
|
|
|
// The type of the list of common symbols.
|
|
|
|
typedef std::vector<Symbol*> Commons_type;
|
|
|
|
|
2009-03-17 08:07:21 +01:00
|
|
|
// The type of the symbol hash table.
|
|
|
|
|
|
|
|
typedef std::pair<Stringpool::Key, Stringpool::Key> Symbol_table_key;
|
|
|
|
|
2010-10-02 11:35:20 +02:00
|
|
|
// The hash function. The key values are Stringpool keys.
|
2009-03-17 08:07:21 +01:00
|
|
|
struct Symbol_table_hash
|
|
|
|
{
|
2010-10-02 11:35:20 +02:00
|
|
|
inline size_t
|
|
|
|
operator()(const Symbol_table_key& key) const
|
|
|
|
{
|
|
|
|
return key.first ^ key.second;
|
|
|
|
}
|
2009-03-17 08:07:21 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
struct Symbol_table_eq
|
|
|
|
{
|
|
|
|
bool
|
|
|
|
operator()(const Symbol_table_key&, const Symbol_table_key&) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef Unordered_map<Symbol_table_key, Symbol*, Symbol_table_hash,
|
|
|
|
Symbol_table_eq> Symbol_table_type;
|
|
|
|
|
2011-03-10 02:31:33 +01:00
|
|
|
// A map from symbol name (as a pointer into the namepool) to all
|
|
|
|
// the locations the symbols is (weakly) defined (and certain other
|
|
|
|
// conditions are met). This map will be used later to detect
|
|
|
|
// possible One Definition Rule (ODR) violations.
|
|
|
|
struct Symbol_location_hash
|
|
|
|
{
|
|
|
|
size_t operator()(const Symbol_location& loc) const
|
|
|
|
{ return reinterpret_cast<uintptr_t>(loc.object) ^ loc.offset ^ loc.shndx; }
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef Unordered_map<const char*,
|
|
|
|
Unordered_set<Symbol_location, Symbol_location_hash> >
|
|
|
|
Odr_map;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Make FROM a forwarder symbol to TO.
|
|
|
|
void
|
|
|
|
make_forwarder(Symbol* from, Symbol* to);
|
|
|
|
|
|
|
|
// Add a symbol.
|
|
|
|
template<int size, bool big_endian>
|
2007-10-14 17:35:27 +02:00
|
|
|
Sized_symbol<size>*
|
2010-08-25 10:36:54 +02:00
|
|
|
add_from_object(Object*, const char* name, Stringpool::Key name_key,
|
|
|
|
const char* version, Stringpool::Key version_key,
|
2007-11-13 21:02:32 +01:00
|
|
|
bool def, const elfcpp::Sym<size, big_endian>& sym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx, bool is_ordinary,
|
|
|
|
unsigned int orig_st_shndx);
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2009-03-17 08:07:21 +01:00
|
|
|
// Define a default symbol.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
define_default_version(Sized_symbol<size>*, bool,
|
|
|
|
Symbol_table_type::iterator);
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Resolve symbols.
|
|
|
|
template<int size, bool big_endian>
|
2007-10-14 17:35:27 +02:00
|
|
|
void
|
2006-09-07 23:21:41 +02:00
|
|
|
resolve(Sized_symbol<size>* to,
|
|
|
|
const elfcpp::Sym<size, big_endian>& sym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx, bool is_ordinary,
|
|
|
|
unsigned int orig_st_shndx,
|
Fix symbol versioning problems in PR 18703.
If a symbol is defined with ".symver foo,foo@VER", the assembler
creates two symbols in the object: one unversioned, and one with
the (non-default) version "VER". If foo is listed in a version
script, gold would then make the first of those symbols the
default version, and would ignore the second symbol as a
duplicate, without making it a non-default version. While this is
arguably reasonable behavior, it doesn't match Gnu ld behavior,
so this patch fixes that by allowing the second definition to
override the first by resetting the "default version" indication.
Several test cases from the Gnu ld testsuite also exposed another
related problem, where a symbol defined with ".symver foo,foo@",
placed into a shared library, is not handled properly by gold.
This patch also fixes that case, binding the symbol to the base
version.
gold/
PR gold/18703
* dynobj.cc (Versions::record_version): Handle symbol defined with
base version.
(Versions::symbol_section_contents): Likewise.
* symtab.h (Symbol::set_is_not_default): New class method.
(Symbol_table::resolve): Add is_default_version parameter.
(Symbol_table::should_override): Likewise.
* resolve.cc (Symbol_table::resolve): Add is_default_version parameter,
and pass to should_override. Adjust all callers and explicit
instantiations.
(Symbol_table::should_override): Add is_default_value parameter;
allow default version in a dynamic object to override existing
definition from same object.
* symtab.cc (Symbol_table::add_from_object): Handle case where same
symbol is defined as unversioned and non-default version in the same
object.
* testsuite/Makefile.am (ver_test_13): New test case.
* testsuite/Makefile.in: Regenerate.
* testsuite/ver_test_4.cc: Add test for symbol with base version.
* testsuite/ver_test_4.sh: Likewise.
* testsuite/ver_test_13.c: New source file.
* testsuite/ver_test_13.script: New version script.
* testsuite/ver_test_13.sh: New test case.
2015-07-28 00:09:08 +02:00
|
|
|
Object*, const char* version,
|
|
|
|
bool is_default_version);
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
template<int size, bool big_endian>
|
2007-10-14 17:35:27 +02:00
|
|
|
void
|
2008-07-23 16:36:09 +02:00
|
|
|
resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from);
|
2006-12-06 01:02:36 +01:00
|
|
|
|
2009-02-27 20:57:46 +01:00
|
|
|
// Record that a symbol is forced to be local by a version script or
|
|
|
|
// by visibility.
|
2008-01-24 01:15:00 +01:00
|
|
|
void
|
|
|
|
force_local(Symbol*);
|
|
|
|
|
2008-04-09 02:48:13 +02:00
|
|
|
// Adjust NAME and *NAME_KEY for wrapping.
|
|
|
|
const char*
|
2009-10-01 00:21:13 +02:00
|
|
|
wrap_symbol(const char* name, Stringpool::Key* name_key);
|
2008-04-09 02:48:13 +02:00
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
// Whether we should override a symbol, based on flags in
|
|
|
|
// resolve.cc.
|
|
|
|
static bool
|
2011-07-09 01:49:11 +02:00
|
|
|
should_override(const Symbol*, unsigned int, elfcpp::STT, Defined,
|
Fix symbol versioning problems in PR 18703.
If a symbol is defined with ".symver foo,foo@VER", the assembler
creates two symbols in the object: one unversioned, and one with
the (non-default) version "VER". If foo is listed in a version
script, gold would then make the first of those symbols the
default version, and would ignore the second symbol as a
duplicate, without making it a non-default version. While this is
arguably reasonable behavior, it doesn't match Gnu ld behavior,
so this patch fixes that by allowing the second definition to
override the first by resetting the "default version" indication.
Several test cases from the Gnu ld testsuite also exposed another
related problem, where a symbol defined with ".symver foo,foo@",
placed into a shared library, is not handled properly by gold.
This patch also fixes that case, binding the symbol to the base
version.
gold/
PR gold/18703
* dynobj.cc (Versions::record_version): Handle symbol defined with
base version.
(Versions::symbol_section_contents): Likewise.
* symtab.h (Symbol::set_is_not_default): New class method.
(Symbol_table::resolve): Add is_default_version parameter.
(Symbol_table::should_override): Likewise.
* resolve.cc (Symbol_table::resolve): Add is_default_version parameter,
and pass to should_override. Adjust all callers and explicit
instantiations.
(Symbol_table::should_override): Add is_default_value parameter;
allow default version in a dynamic object to override existing
definition from same object.
* symtab.cc (Symbol_table::add_from_object): Handle case where same
symbol is defined as unversioned and non-default version in the same
object.
* testsuite/Makefile.am (ver_test_13): New test case.
* testsuite/Makefile.in: Regenerate.
* testsuite/ver_test_4.cc: Add test for symbol with base version.
* testsuite/ver_test_4.sh: Likewise.
* testsuite/ver_test_13.c: New source file.
* testsuite/ver_test_13.script: New version script.
* testsuite/ver_test_13.sh: New test case.
2015-07-28 00:09:08 +02:00
|
|
|
Object*, bool*, bool*, bool);
|
2007-09-19 08:02:29 +02:00
|
|
|
|
2009-11-04 02:24:41 +01:00
|
|
|
// Report a problem in symbol resolution.
|
|
|
|
static void
|
|
|
|
report_resolve_problem(bool is_error, const char* msg, const Symbol* to,
|
2009-12-29 01:31:48 +01:00
|
|
|
Defined, Object* object);
|
2009-11-04 02:24:41 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// Override a symbol.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
override(Sized_symbol<size>* tosym,
|
|
|
|
const elfcpp::Sym<size, big_endian>& fromsym,
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_shndx, bool is_ordinary,
|
2007-10-14 17:35:27 +02:00
|
|
|
Object* object, const char* version);
|
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
// Whether we should override a symbol with a special symbol which
|
|
|
|
// is automatically defined by the linker.
|
|
|
|
static bool
|
2011-07-09 01:49:11 +02:00
|
|
|
should_override_with_special(const Symbol*, elfcpp::STT, Defined);
|
2007-09-19 08:02:29 +02:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// Override a symbol with a special symbol.
|
|
|
|
template<int size>
|
|
|
|
void
|
|
|
|
override_with_special(Sized_symbol<size>* tosym,
|
|
|
|
const Sized_symbol<size>* fromsym);
|
|
|
|
|
|
|
|
// Record all weak alias sets for a dynamic object.
|
|
|
|
template<int size>
|
|
|
|
void
|
|
|
|
record_weak_aliases(std::vector<Sized_symbol<size>*>*);
|
|
|
|
|
2006-12-06 01:02:36 +01:00
|
|
|
// Define a special symbol.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
Sized_symbol<size>*
|
2008-01-26 02:17:45 +01:00
|
|
|
define_special_symbol(const char** pname, const char** pversion,
|
2009-03-17 08:07:21 +01:00
|
|
|
bool only_if_ref, Sized_symbol<size>** poldsym,
|
|
|
|
bool* resolve_oldsym);
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Define a symbol in an Output_data, sized version.
|
|
|
|
template<int size>
|
2006-12-06 01:02:36 +01:00
|
|
|
Sized_symbol<size>*
|
2009-12-29 01:31:48 +01:00
|
|
|
do_define_in_output_data(const char* name, const char* version, Defined,
|
|
|
|
Output_data*,
|
2006-11-03 19:26:11 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_WXword ssize,
|
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility, unsigned char nonvis,
|
|
|
|
bool offset_is_from_end, bool only_if_ref);
|
|
|
|
|
|
|
|
// Define a symbol in an Output_segment, sized version.
|
|
|
|
template<int size>
|
2006-12-06 01:02:36 +01:00
|
|
|
Sized_symbol<size>*
|
2006-11-03 19:26:11 +01:00
|
|
|
do_define_in_output_segment(
|
2009-12-29 01:31:48 +01:00
|
|
|
const char* name, const char* version, Defined, Output_segment* os,
|
2006-11-03 19:26:11 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_WXword ssize,
|
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility, unsigned char nonvis,
|
|
|
|
Symbol::Segment_offset_base offset_base, bool only_if_ref);
|
|
|
|
|
|
|
|
// Define a symbol as a constant, sized version.
|
|
|
|
template<int size>
|
2006-12-06 01:02:36 +01:00
|
|
|
Sized_symbol<size>*
|
2006-11-03 19:26:11 +01:00
|
|
|
do_define_as_constant(
|
2009-12-29 01:31:48 +01:00
|
|
|
const char* name, const char* version, Defined,
|
2006-11-03 19:26:11 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_WXword ssize,
|
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility, unsigned char nonvis,
|
2008-02-13 02:20:38 +01:00
|
|
|
bool only_if_ref, bool force_override);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
// Add any undefined symbols named on the command line to the symbol
|
|
|
|
// table, sized version.
|
|
|
|
template<int size>
|
|
|
|
void
|
2010-08-02 15:34:33 +02:00
|
|
|
do_add_undefined_symbols_from_command_line(Layout*);
|
|
|
|
|
|
|
|
// Add one undefined symbol.
|
|
|
|
template<int size>
|
|
|
|
void
|
|
|
|
add_undefined_symbol_from_command_line(const char* name);
|
2008-05-07 08:08:01 +02:00
|
|
|
|
2009-06-22 08:51:53 +02:00
|
|
|
// Types of common symbols.
|
|
|
|
|
|
|
|
enum Commons_section_type
|
|
|
|
{
|
|
|
|
COMMONS_NORMAL,
|
|
|
|
COMMONS_TLS,
|
|
|
|
COMMONS_SMALL,
|
|
|
|
COMMONS_LARGE
|
|
|
|
};
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Allocate the common symbols, sized version.
|
|
|
|
template<int size>
|
|
|
|
void
|
2009-12-31 02:57:55 +01:00
|
|
|
do_allocate_commons(Layout*, Mapfile*, Sort_commons_order);
|
2008-04-17 09:12:00 +02:00
|
|
|
|
|
|
|
// Allocate the common symbols from one list.
|
|
|
|
template<int size>
|
|
|
|
void
|
2009-06-22 08:51:53 +02:00
|
|
|
do_allocate_commons_list(Layout*, Commons_section_type, Commons_type*,
|
2009-12-31 02:57:55 +01:00
|
|
|
Mapfile*, Sort_commons_order);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2011-03-10 02:31:33 +01:00
|
|
|
// Returns all of the lines attached to LOC, not just the one the
|
|
|
|
// instruction actually came from. This helps the ODR checker avoid
|
|
|
|
// false positives.
|
|
|
|
static std::vector<std::string>
|
|
|
|
linenos_from_loc(const Task* task, const Symbol_location& loc);
|
|
|
|
|
2007-11-13 21:02:32 +01:00
|
|
|
// Implement detect_odr_violations.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
sized_detect_odr_violations() const;
|
|
|
|
|
2006-09-28 00:53:42 +02:00
|
|
|
// Finalize symbols specialized for size.
|
|
|
|
template<int size>
|
|
|
|
off_t
|
2008-01-24 01:15:00 +01:00
|
|
|
sized_finalize(off_t, Stringpool*, unsigned int*);
|
|
|
|
|
|
|
|
// Finalize a symbol. Return whether it should be added to the
|
|
|
|
// symbol table.
|
|
|
|
template<int size>
|
|
|
|
bool
|
|
|
|
sized_finalize_symbol(Symbol*);
|
|
|
|
|
|
|
|
// Add a symbol the final symtab by setting its index.
|
|
|
|
template<int size>
|
|
|
|
void
|
|
|
|
add_to_final_symtab(Symbol*, Stringpool*, unsigned int* pindex, off_t* poff);
|
2006-09-28 00:53:42 +02:00
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
// Write globals specialized for size and endianness.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2009-02-28 05:39:57 +01:00
|
|
|
sized_write_globals(const Stringpool*, const Stringpool*,
|
|
|
|
Output_symtab_xindex*, Output_symtab_xindex*,
|
|
|
|
Output_file*) const;
|
2006-12-01 17:51:25 +01:00
|
|
|
|
|
|
|
// Write out a symbol to P.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2007-09-23 07:31:48 +02:00
|
|
|
sized_write_symbol(Sized_symbol<size>*,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr value,
|
2010-07-09 03:34:31 +02:00
|
|
|
unsigned int shndx, elfcpp::STB,
|
2008-02-29 20:19:17 +01:00
|
|
|
const Stringpool*, unsigned char* p) const;
|
2006-09-29 21:58:17 +02:00
|
|
|
|
2007-11-14 17:53:25 +01:00
|
|
|
// Possibly warn about an undefined symbol from a dynamic object.
|
|
|
|
void
|
2009-02-28 05:39:57 +01:00
|
|
|
warn_about_undefined_dynobj_symbol(Symbol*) const;
|
2007-11-14 17:53:25 +01:00
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
// Write out a section symbol, specialized for size and endianness.
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2008-04-19 20:30:58 +02:00
|
|
|
sized_write_section_symbol(const Output_section*, Output_symtab_xindex*,
|
|
|
|
Output_file*, off_t) const;
|
2006-11-29 18:56:40 +01:00
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
// The type of the list of symbols which have been forced local.
|
|
|
|
typedef std::vector<Symbol*> Forced_locals;
|
|
|
|
|
2007-10-23 01:08:22 +02:00
|
|
|
// A map from symbols with COPY relocs to the dynamic objects where
|
|
|
|
// they are defined.
|
|
|
|
typedef Unordered_map<const Symbol*, Dynobj*> Copied_symbol_dynobjs;
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// We increment this every time we see a new undefined symbol, for
|
|
|
|
// use in archive groups.
|
2010-02-12 04:23:26 +01:00
|
|
|
size_t saw_undefined_;
|
2006-11-16 01:38:25 +01:00
|
|
|
// The index of the first global symbol in the output file.
|
|
|
|
unsigned int first_global_index_;
|
2006-09-28 00:53:42 +02:00
|
|
|
// The file offset within the output symtab section where we should
|
|
|
|
// write the table.
|
|
|
|
off_t offset_;
|
2006-09-29 21:58:17 +02:00
|
|
|
// The number of global symbols we want to write out.
|
2008-01-24 01:15:00 +01:00
|
|
|
unsigned int output_count_;
|
2006-12-01 17:51:25 +01:00
|
|
|
// The file offset of the global dynamic symbols, or 0 if none.
|
|
|
|
off_t dynamic_offset_;
|
|
|
|
// The index of the first global dynamic symbol.
|
|
|
|
unsigned int first_dynamic_global_index_;
|
|
|
|
// The number of global dynamic symbols, or 0 if none.
|
2008-01-24 01:15:00 +01:00
|
|
|
unsigned int dynamic_count_;
|
2006-09-26 23:00:34 +02:00
|
|
|
// The symbol hash table.
|
2006-08-19 00:29:20 +02:00
|
|
|
Symbol_table_type table_;
|
2006-09-26 23:00:34 +02:00
|
|
|
// A pool of symbol names. This is used for all global symbols.
|
|
|
|
// Entries in the hash table point into this pool.
|
2006-08-19 00:29:20 +02:00
|
|
|
Stringpool namepool_;
|
|
|
|
// Forwarding symbols.
|
2006-11-16 01:38:25 +01:00
|
|
|
Unordered_map<const Symbol*, Symbol*> forwarders_;
|
2007-10-14 17:35:27 +02:00
|
|
|
// Weak aliases. A symbol in this list points to the next alias.
|
|
|
|
// The aliases point to each other in a circular list.
|
|
|
|
Unordered_map<Symbol*, Symbol*> weak_aliases_;
|
2006-11-03 19:26:11 +01:00
|
|
|
// We don't expect there to be very many common symbols, so we keep
|
|
|
|
// a list of them. When we find a common symbol we add it to this
|
|
|
|
// list. It is possible that by the time we process the list the
|
|
|
|
// symbol is no longer a common symbol. It may also have become a
|
|
|
|
// forwarder.
|
|
|
|
Commons_type commons_;
|
2008-04-17 09:12:00 +02:00
|
|
|
// This is like the commons_ field, except that it holds TLS common
|
|
|
|
// symbols.
|
|
|
|
Commons_type tls_commons_;
|
2009-06-22 08:51:53 +02:00
|
|
|
// This is for small common symbols.
|
|
|
|
Commons_type small_commons_;
|
|
|
|
// This is for large common symbols.
|
|
|
|
Commons_type large_commons_;
|
2008-01-24 01:15:00 +01:00
|
|
|
// A list of symbols which have been forced to be local. We don't
|
|
|
|
// expect there to be very many of them, so we keep a list of them
|
|
|
|
// rather than walking the whole table to find them.
|
|
|
|
Forced_locals forced_locals_;
|
2006-11-06 23:46:08 +01:00
|
|
|
// Manage symbol warnings.
|
|
|
|
Warnings warnings_;
|
2007-11-13 21:02:32 +01:00
|
|
|
// Manage potential One Definition Rule (ODR) violations.
|
|
|
|
Odr_map candidate_odr_violations_;
|
|
|
|
|
2007-10-23 01:08:22 +02:00
|
|
|
// When we emit a COPY reloc for a symbol, we define it in an
|
|
|
|
// Output_data. When it's time to emit version information for it,
|
|
|
|
// we need to know the dynamic object in which we found the original
|
|
|
|
// definition. This maps symbols with COPY relocs to the dynamic
|
|
|
|
// object where they were defined.
|
|
|
|
Copied_symbol_dynobjs copied_symbol_dynobjs_;
|
2008-01-16 00:41:28 +01:00
|
|
|
// Information parsed from the version script, if any.
|
|
|
|
const Version_script_info& version_script_;
|
2009-01-28 03:25:33 +01:00
|
|
|
Garbage_collection* gc_;
|
2009-08-05 22:51:56 +02:00
|
|
|
Icf* icf_;
|
2016-02-05 01:55:39 +01:00
|
|
|
// Target-specific symbols, if any.
|
|
|
|
std::vector<Symbol*> target_symbols_;
|
2006-08-05 01:10:59 +02:00
|
|
|
};
|
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
// We inline get_sized_symbol for efficiency.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
Sized_symbol<size>*
|
2008-02-29 20:19:17 +01:00
|
|
|
Symbol_table::get_sized_symbol(Symbol* sym) const
|
2006-09-07 23:21:41 +02:00
|
|
|
{
|
2008-02-28 01:18:24 +01:00
|
|
|
gold_assert(size == parameters->target().get_size());
|
2006-09-07 23:21:41 +02:00
|
|
|
return static_cast<Sized_symbol<size>*>(sym);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
const Sized_symbol<size>*
|
2008-02-29 20:19:17 +01:00
|
|
|
Symbol_table::get_sized_symbol(const Symbol* sym) const
|
2006-09-07 23:21:41 +02:00
|
|
|
{
|
2008-02-28 01:18:24 +01:00
|
|
|
gold_assert(size == parameters->target().get_size());
|
2006-09-07 23:21:41 +02:00
|
|
|
return static_cast<const Sized_symbol<size>*>(sym);
|
|
|
|
}
|
|
|
|
|
2006-08-05 01:10:59 +02:00
|
|
|
} // End namespace gold.
|
|
|
|
|
|
|
|
#endif // !defined(GOLD_SYMTAB_H)
|