2006-08-19 00:29:20 +02:00
|
|
|
// symtab.cc -- the gold symbol table
|
|
|
|
|
2019-01-01 11:31:27 +01:00
|
|
|
// Copyright (C) 2006-2019 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-19 00:29:20 +02:00
|
|
|
#include "gold.h"
|
|
|
|
|
2008-03-27 00:36:46 +01:00
|
|
|
#include <cstring>
|
2006-08-19 00:29:20 +02:00
|
|
|
#include <stdint.h>
|
2008-03-27 00:36:46 +01:00
|
|
|
#include <algorithm>
|
2007-11-13 21:02:32 +01:00
|
|
|
#include <set>
|
2006-08-19 00:29:20 +02:00
|
|
|
#include <string>
|
|
|
|
#include <utility>
|
2007-11-15 02:12:55 +01:00
|
|
|
#include "demangle.h"
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2009-01-28 03:25:33 +01:00
|
|
|
#include "gc.h"
|
2006-08-19 00:29:20 +02:00
|
|
|
#include "object.h"
|
2007-11-13 21:02:32 +01:00
|
|
|
#include "dwarf_reader.h"
|
2006-11-14 20:21:05 +01:00
|
|
|
#include "dynobj.h"
|
2006-09-28 00:53:42 +02:00
|
|
|
#include "output.h"
|
2006-09-29 21:58:17 +02:00
|
|
|
#include "target.h"
|
2006-11-07 19:51:39 +01:00
|
|
|
#include "workqueue.h"
|
2006-08-19 00:29:20 +02:00
|
|
|
#include "symtab.h"
|
2010-08-02 15:34:33 +02:00
|
|
|
#include "script.h"
|
2008-09-20 00:54:57 +02:00
|
|
|
#include "plugin.h"
|
2011-04-12 02:44:48 +02:00
|
|
|
#include "incremental.h"
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
namespace gold
|
|
|
|
{
|
|
|
|
|
|
|
|
// Class Symbol.
|
|
|
|
|
2017-08-29 08:22:45 +02:00
|
|
|
// Initialize fields in Symbol. This initializes everything except
|
|
|
|
// u1_, u2_ and source_.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::init_fields(const char* name, const char* version,
|
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility, unsigned char nonvis)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->name_ = name;
|
|
|
|
this->version_ = version;
|
2006-11-16 01:38:25 +01:00
|
|
|
this->symtab_index_ = 0;
|
|
|
|
this->dynsym_index_ = 0;
|
2008-03-25 19:37:16 +01:00
|
|
|
this->got_offsets_.init();
|
2010-01-09 01:13:48 +01:00
|
|
|
this->plt_offset_ = -1U;
|
2009-12-14 20:53:05 +01:00
|
|
|
this->type_ = type;
|
|
|
|
this->binding_ = binding;
|
|
|
|
this->visibility_ = visibility;
|
|
|
|
this->nonvis_ = nonvis;
|
2006-09-07 23:21:41 +02:00
|
|
|
this->is_def_ = false;
|
|
|
|
this->is_forwarder_ = false;
|
2007-10-14 17:35:27 +02:00
|
|
|
this->has_alias_ = false;
|
2006-11-16 01:38:25 +01:00
|
|
|
this->needs_dynsym_entry_ = false;
|
2006-12-06 07:28:56 +01:00
|
|
|
this->in_reg_ = false;
|
2006-11-03 19:26:11 +01:00
|
|
|
this->in_dyn_ = false;
|
2006-11-06 23:46:08 +01:00
|
|
|
this->has_warning_ = false;
|
2007-10-23 01:08:22 +02:00
|
|
|
this->is_copied_from_dynobj_ = false;
|
2008-01-24 01:15:00 +01:00
|
|
|
this->is_forced_local_ = false;
|
2008-04-19 20:30:58 +02:00
|
|
|
this->is_ordinary_shndx_ = false;
|
2008-09-20 00:54:57 +02:00
|
|
|
this->in_real_elf_ = false;
|
2010-01-09 01:13:48 +01:00
|
|
|
this->is_defined_in_discarded_section_ = false;
|
2010-07-09 03:34:31 +02:00
|
|
|
this->undef_binding_set_ = false;
|
|
|
|
this->undef_binding_weak_ = false;
|
2011-06-08 06:05:25 +02:00
|
|
|
this->is_predefined_ = false;
|
2016-05-19 23:58:18 +02:00
|
|
|
this->is_protected_ = false;
|
2017-08-28 08:57:33 +02:00
|
|
|
this->non_zero_localentry_ = false;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
2007-11-15 02:12:55 +01:00
|
|
|
// Return the demangled version of the symbol's name, but only
|
|
|
|
// if the --demangle flag was set.
|
|
|
|
|
|
|
|
static std::string
|
2009-12-14 20:53:05 +01:00
|
|
|
demangle(const char* name)
|
2007-11-15 02:12:55 +01:00
|
|
|
{
|
2008-03-24 04:48:29 +01:00
|
|
|
if (!parameters->options().do_demangle())
|
2009-12-14 20:53:05 +01:00
|
|
|
return name;
|
2007-11-16 17:54:19 +01:00
|
|
|
|
2007-11-15 02:12:55 +01:00
|
|
|
// cplus_demangle allocates memory for the result it returns,
|
|
|
|
// and returns NULL if the name is already demangled.
|
2009-12-14 20:53:05 +01:00
|
|
|
char* demangled_name = cplus_demangle(name, DMGL_ANSI | DMGL_PARAMS);
|
2007-11-15 02:12:55 +01:00
|
|
|
if (demangled_name == NULL)
|
2009-12-14 20:53:05 +01:00
|
|
|
return name;
|
2007-11-15 02:12:55 +01:00
|
|
|
|
|
|
|
std::string retval(demangled_name);
|
|
|
|
free(demangled_name);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string
|
|
|
|
Symbol::demangled_name() const
|
|
|
|
{
|
2007-11-16 17:54:19 +01:00
|
|
|
return demangle(this->name());
|
2007-11-15 02:12:55 +01:00
|
|
|
}
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Initialize the fields in the base class Symbol for SYM in OBJECT.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::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>& sym,
|
|
|
|
unsigned int st_shndx, bool is_ordinary)
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->init_fields(name, version, sym.get_st_type(), sym.get_st_bind(),
|
2006-11-03 19:26:11 +01:00
|
|
|
sym.get_st_visibility(), sym.get_st_nonvis());
|
2017-08-29 08:22:45 +02:00
|
|
|
this->u1_.object = object;
|
|
|
|
this->u2_.shndx = st_shndx;
|
2008-04-19 20:30:58 +02:00
|
|
|
this->is_ordinary_shndx_ = is_ordinary;
|
2006-11-03 19:26:11 +01:00
|
|
|
this->source_ = FROM_OBJECT;
|
2009-12-14 20:53:05 +01:00
|
|
|
this->in_reg_ = !object->is_dynamic();
|
|
|
|
this->in_dyn_ = object->is_dynamic();
|
|
|
|
this->in_real_elf_ = object->pluginobj() == NULL;
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Initialize the fields in the base class Symbol for a symbol defined
|
|
|
|
// in an Output_data.
|
|
|
|
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::init_base_output_data(const char* name, const char* version,
|
|
|
|
Output_data* od, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding, elfcpp::STV visibility,
|
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
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->init_fields(name, version, type, binding, visibility, nonvis);
|
2017-08-29 08:22:45 +02:00
|
|
|
this->u1_.output_data = od;
|
|
|
|
this->u2_.offset_is_from_end = offset_is_from_end;
|
2006-11-03 19:26:11 +01:00
|
|
|
this->source_ = IN_OUTPUT_DATA;
|
2006-12-06 07:28:56 +01:00
|
|
|
this->in_reg_ = true;
|
2008-09-20 00:54:57 +02:00
|
|
|
this->in_real_elf_ = true;
|
2011-06-08 06:05:25 +02:00
|
|
|
this->is_predefined_ = is_predefined;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the fields in the base class Symbol for a symbol defined
|
|
|
|
// in an Output_segment.
|
|
|
|
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::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
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->init_fields(name, version, type, binding, visibility, nonvis);
|
2017-08-29 08:22:45 +02:00
|
|
|
this->u1_.output_segment = os;
|
|
|
|
this->u2_.offset_base = offset_base;
|
2006-11-03 19:26:11 +01:00
|
|
|
this->source_ = IN_OUTPUT_SEGMENT;
|
2006-12-06 07:28:56 +01:00
|
|
|
this->in_reg_ = true;
|
2008-09-20 00:54:57 +02:00
|
|
|
this->in_real_elf_ = true;
|
2011-06-08 06:05:25 +02:00
|
|
|
this->is_predefined_ = is_predefined;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the fields in the base class Symbol for a symbol defined
|
|
|
|
// as a constant.
|
|
|
|
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::init_base_constant(const char* name, const char* version,
|
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
2011-06-08 06:05:25 +02:00
|
|
|
elfcpp::STV visibility, unsigned char nonvis,
|
|
|
|
bool is_predefined)
|
2008-05-07 08:08:01 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->init_fields(name, version, type, binding, visibility, nonvis);
|
2008-05-07 08:08:01 +02:00
|
|
|
this->source_ = IS_CONSTANT;
|
|
|
|
this->in_reg_ = true;
|
2008-09-20 00:54:57 +02:00
|
|
|
this->in_real_elf_ = true;
|
2011-06-08 06:05:25 +02:00
|
|
|
this->is_predefined_ = is_predefined;
|
2008-05-07 08:08:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the fields in the base class Symbol for an undefined
|
|
|
|
// symbol.
|
|
|
|
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::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
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->init_fields(name, version, type, binding, visibility, nonvis);
|
2008-08-28 16:51:04 +02:00
|
|
|
this->dynsym_index_ = -1U;
|
2008-05-07 08:08:01 +02:00
|
|
|
this->source_ = IS_UNDEFINED;
|
2006-12-06 07:28:56 +01:00
|
|
|
this->in_reg_ = true;
|
2008-09-20 00:54:57 +02:00
|
|
|
this->in_real_elf_ = true;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
2007-11-22 01:05:51 +01:00
|
|
|
// Allocate a common symbol in the base.
|
|
|
|
|
|
|
|
void
|
|
|
|
Symbol::allocate_base_common(Output_data* od)
|
|
|
|
{
|
|
|
|
gold_assert(this->is_common());
|
|
|
|
this->source_ = IN_OUTPUT_DATA;
|
2017-08-29 08:22:45 +02:00
|
|
|
this->u1_.output_data = od;
|
|
|
|
this->u2_.offset_is_from_end = false;
|
2007-11-22 01:05:51 +01:00
|
|
|
}
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Initialize the fields in Sized_symbol for SYM in OBJECT.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
template<int size>
|
|
|
|
template<bool big_endian>
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Sized_symbol<size>::init_object(const char* name, const char* version,
|
|
|
|
Object* object,
|
2008-05-07 08:08:01 +02:00
|
|
|
const elfcpp::Sym<size, big_endian>& sym,
|
|
|
|
unsigned int st_shndx, bool is_ordinary)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->init_base_object(name, version, object, sym, st_shndx, is_ordinary);
|
2006-08-19 00:29:20 +02:00
|
|
|
this->value_ = sym.get_st_value();
|
2006-11-03 19:26:11 +01:00
|
|
|
this->symsize_ = sym.get_st_size();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the fields in Sized_symbol for a symbol defined in an
|
|
|
|
// Output_data.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Sized_symbol<size>::init_output_data(const char* name, const char* version,
|
|
|
|
Output_data* od, Value_type value,
|
|
|
|
Size_type symsize, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility,
|
|
|
|
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
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->init_base_output_data(name, version, od, type, binding, visibility,
|
2011-06-08 06:05:25 +02:00
|
|
|
nonvis, offset_is_from_end, is_predefined);
|
2009-12-14 20:53:05 +01:00
|
|
|
this->value_ = value;
|
|
|
|
this->symsize_ = symsize;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the fields in Sized_symbol for a symbol defined in an
|
|
|
|
// Output_segment.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Sized_symbol<size>::init_output_segment(const char* name, const char* version,
|
|
|
|
Output_segment* os, Value_type value,
|
|
|
|
Size_type symsize, 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
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->init_base_output_segment(name, version, os, type, binding, visibility,
|
2011-06-08 06:05:25 +02:00
|
|
|
nonvis, offset_base, is_predefined);
|
2009-12-14 20:53:05 +01:00
|
|
|
this->value_ = value;
|
|
|
|
this->symsize_ = symsize;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the fields in Sized_symbol for a symbol defined as a
|
|
|
|
// constant.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Sized_symbol<size>::init_constant(const char* name, const char* version,
|
|
|
|
Value_type value, Size_type symsize,
|
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
2011-06-08 06:05:25 +02:00
|
|
|
elfcpp::STV visibility, unsigned char nonvis,
|
|
|
|
bool is_predefined)
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2011-06-08 06:05:25 +02:00
|
|
|
this->init_base_constant(name, version, type, binding, visibility, nonvis,
|
|
|
|
is_predefined);
|
2009-12-14 20:53:05 +01:00
|
|
|
this->value_ = value;
|
|
|
|
this->symsize_ = symsize;
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
// Initialize the fields in Sized_symbol for an undefined symbol.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Sized_symbol<size>::init_undefined(const char* name, const char* version,
|
2016-02-05 01:55:39 +01:00
|
|
|
Value_type value, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding, elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis)
|
2008-05-07 08:08:01 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->init_base_undefined(name, version, type, binding, visibility, nonvis);
|
2016-02-05 01:55:39 +01:00
|
|
|
this->value_ = value;
|
2008-05-07 08:08:01 +02:00
|
|
|
this->symsize_ = 0;
|
|
|
|
}
|
|
|
|
|
2011-06-28 07:39:45 +02:00
|
|
|
// Return an allocated string holding the symbol's name as
|
|
|
|
// name@version. This is used for relocatable links.
|
|
|
|
|
|
|
|
std::string
|
|
|
|
Symbol::versioned_name() const
|
|
|
|
{
|
|
|
|
gold_assert(this->version_ != NULL);
|
|
|
|
std::string ret = this->name_;
|
|
|
|
ret.push_back('@');
|
|
|
|
if (this->is_def_)
|
|
|
|
ret.push_back('@');
|
|
|
|
ret += this->version_;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-06-22 08:51:53 +02:00
|
|
|
// Return true if SHNDX represents a common symbol.
|
|
|
|
|
|
|
|
bool
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::is_common_shndx(unsigned int shndx)
|
2009-06-22 08:51:53 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
return (shndx == elfcpp::SHN_COMMON
|
|
|
|
|| shndx == parameters->target().small_common_shndx()
|
|
|
|
|| shndx == parameters->target().large_common_shndx());
|
2009-06-22 08:51:53 +02:00
|
|
|
}
|
|
|
|
|
2007-11-22 01:05:51 +01:00
|
|
|
// Allocate a common symbol.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Sized_symbol<size>::allocate_common(Output_data* od, Value_type value)
|
2007-11-22 01:05:51 +01:00
|
|
|
{
|
|
|
|
this->allocate_base_common(od);
|
2009-12-14 20:53:05 +01:00
|
|
|
this->value_ = value;
|
2007-11-22 01:05:51 +01:00
|
|
|
}
|
|
|
|
|
2008-11-06 08:23:31 +01:00
|
|
|
// The ""'s around str ensure str is a string literal, so sizeof works.
|
|
|
|
#define strprefix(var, str) (strncmp(var, str, sizeof("" str "") - 1) == 0)
|
|
|
|
|
2007-10-17 01:23:08 +02:00
|
|
|
// Return true if this symbol should be added to the dynamic symbol
|
|
|
|
// table.
|
|
|
|
|
2014-06-27 03:11:31 +02:00
|
|
|
bool
|
2010-04-20 23:13:30 +02:00
|
|
|
Symbol::should_add_dynsym_entry(Symbol_table* symtab) const
|
2007-10-17 01:23:08 +02:00
|
|
|
{
|
2011-02-18 15:55:33 +01:00
|
|
|
// If the symbol is only present on plugin files, the plugin decided we
|
|
|
|
// don't need it.
|
|
|
|
if (!this->in_real_elf())
|
|
|
|
return false;
|
|
|
|
|
2007-10-17 01:23:08 +02:00
|
|
|
// If the symbol is used by a dynamic relocation, we need to add it.
|
|
|
|
if (this->needs_dynsym_entry())
|
|
|
|
return true;
|
|
|
|
|
2009-01-28 03:25:33 +01:00
|
|
|
// If this symbol's section is not added, the symbol need not be added.
|
|
|
|
// The section may have been GCed. Note that export_dynamic is being
|
|
|
|
// overridden here. This should not be done for shared objects.
|
|
|
|
if (parameters->options().gc_sections()
|
|
|
|
&& !parameters->options().shared()
|
|
|
|
&& this->source() == Symbol::FROM_OBJECT
|
|
|
|
&& !this->object()->is_dynamic())
|
|
|
|
{
|
|
|
|
Relobj* relobj = static_cast<Relobj*>(this->object());
|
|
|
|
bool is_ordinary;
|
2009-12-14 20:53:05 +01:00
|
|
|
unsigned int shndx = this->shndx(&is_ordinary);
|
|
|
|
if (is_ordinary && shndx != elfcpp::SHN_UNDEF
|
2010-04-20 23:13:30 +02:00
|
|
|
&& !relobj->is_section_included(shndx)
|
|
|
|
&& !symtab->is_section_folded(relobj, shndx))
|
2009-01-28 03:25:33 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-04-17 02:28:41 +02:00
|
|
|
// If the symbol was forced dynamic in a --dynamic-list file
|
|
|
|
// or an --export-dynamic-symbol option, add it.
|
2012-05-23 01:50:52 +02:00
|
|
|
if (!this->is_from_dynobj()
|
|
|
|
&& (parameters->options().in_dynamic_list(this->name())
|
|
|
|
|| parameters->options().is_export_dynamic_symbol(this->name())))
|
2012-04-17 02:28:41 +02:00
|
|
|
{
|
|
|
|
if (!this->is_forced_local())
|
|
|
|
return true;
|
|
|
|
gold_warning(_("Cannot export local symbol '%s'"),
|
|
|
|
this->demangled_name().c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
// If the symbol was forced local in a version script, do not add it.
|
|
|
|
if (this->is_forced_local())
|
|
|
|
return false;
|
|
|
|
|
2008-11-06 08:23:31 +01:00
|
|
|
// If dynamic-list-data was specified, add any STT_OBJECT.
|
|
|
|
if (parameters->options().dynamic_list_data()
|
|
|
|
&& !this->is_from_dynobj()
|
|
|
|
&& this->type() == elfcpp::STT_OBJECT)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// If --dynamic-list-cpp-new was specified, add any new/delete symbol.
|
|
|
|
// If --dynamic-list-cpp-typeinfo was specified, add any typeinfo symbols.
|
|
|
|
if ((parameters->options().dynamic_list_cpp_new()
|
|
|
|
|| parameters->options().dynamic_list_cpp_typeinfo())
|
|
|
|
&& !this->is_from_dynobj())
|
|
|
|
{
|
|
|
|
// TODO(csilvers): We could probably figure out if we're an operator
|
|
|
|
// new/delete or typeinfo without the need to demangle.
|
2009-12-14 20:53:05 +01:00
|
|
|
char* demangled_name = cplus_demangle(this->name(),
|
|
|
|
DMGL_ANSI | DMGL_PARAMS);
|
|
|
|
if (demangled_name == NULL)
|
2008-11-06 08:23:31 +01:00
|
|
|
{
|
|
|
|
// Not a C++ symbol, so it can't satisfy these flags
|
|
|
|
}
|
|
|
|
else if (parameters->options().dynamic_list_cpp_new()
|
2009-12-14 20:53:05 +01:00
|
|
|
&& (strprefix(demangled_name, "operator new")
|
|
|
|
|| strprefix(demangled_name, "operator delete")))
|
2008-11-06 08:23:31 +01:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
free(demangled_name);
|
2008-11-06 08:23:31 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else if (parameters->options().dynamic_list_cpp_typeinfo()
|
2009-12-14 20:53:05 +01:00
|
|
|
&& (strprefix(demangled_name, "typeinfo name for")
|
|
|
|
|| strprefix(demangled_name, "typeinfo for")))
|
2008-11-06 08:23:31 +01:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
free(demangled_name);
|
2008-11-06 08:23:31 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
2009-12-14 20:53:05 +01:00
|
|
|
free(demangled_name);
|
2008-11-06 08:23:31 +01:00
|
|
|
}
|
|
|
|
|
2007-10-17 01:23:08 +02:00
|
|
|
// If exporting all symbols or building a shared library,
|
2015-04-21 03:04:07 +02:00
|
|
|
// or the symbol should be globally unique (GNU_UNIQUE),
|
2007-10-17 01:23:08 +02:00
|
|
|
// and the symbol is defined in a regular object and is
|
|
|
|
// externally visible, we need to add it.
|
2015-04-21 03:04:07 +02:00
|
|
|
if ((parameters->options().export_dynamic()
|
|
|
|
|| parameters->options().shared()
|
|
|
|
|| (parameters->options().gnu_unique()
|
|
|
|
&& this->binding() == elfcpp::STB_GNU_UNIQUE))
|
2007-10-17 01:23:08 +02:00
|
|
|
&& !this->is_from_dynobj()
|
2011-06-29 16:43:08 +02:00
|
|
|
&& !this->is_undefined()
|
2007-10-17 01:23:08 +02:00
|
|
|
&& this->is_externally_visible())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2007-09-28 08:36:25 +02:00
|
|
|
// Return true if the final value of this symbol is known at link
|
|
|
|
// time.
|
|
|
|
|
|
|
|
bool
|
|
|
|
Symbol::final_value_is_known() const
|
|
|
|
{
|
|
|
|
// If we are not generating an executable, then no final values are
|
2015-04-10 00:47:13 +02:00
|
|
|
// known, since they will change at runtime, with the exception of
|
|
|
|
// TLS symbols in a position-independent executable.
|
|
|
|
if ((parameters->options().output_is_position_independent()
|
|
|
|
|| parameters->options().relocatable())
|
|
|
|
&& !(this->type() == elfcpp::STT_TLS
|
|
|
|
&& parameters->options().pie()))
|
2007-09-28 08:36:25 +02:00
|
|
|
return false;
|
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
// If the symbol is not from an object file, and is not undefined,
|
|
|
|
// then it is defined, and known.
|
2007-09-28 08:36:25 +02:00
|
|
|
if (this->source_ != FROM_OBJECT)
|
2008-05-07 08:08:01 +02:00
|
|
|
{
|
|
|
|
if (this->source_ != IS_UNDEFINED)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// If the symbol is from a dynamic object, then the final value
|
|
|
|
// is not known.
|
|
|
|
if (this->object()->is_dynamic())
|
|
|
|
return false;
|
2007-09-28 08:36:25 +02:00
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
// If the symbol is not undefined (it is defined or common),
|
|
|
|
// then the final value is known.
|
|
|
|
if (!this->is_undefined())
|
|
|
|
return true;
|
|
|
|
}
|
2007-09-28 08:36:25 +02:00
|
|
|
|
|
|
|
// If the symbol is undefined, then whether the final value is known
|
|
|
|
// depends on whether we are doing a static link. If we are doing a
|
|
|
|
// dynamic link, then the final value could be filled in at runtime.
|
|
|
|
// This could reasonably be the case for a weak undefined symbol.
|
|
|
|
return parameters->doing_static_link();
|
|
|
|
}
|
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
// Return the output section where this symbol is defined.
|
2008-02-04 06:43:05 +01:00
|
|
|
|
2008-02-09 02:22:17 +01:00
|
|
|
Output_section*
|
|
|
|
Symbol::output_section() const
|
2008-02-04 06:43:05 +01:00
|
|
|
{
|
|
|
|
switch (this->source_)
|
|
|
|
{
|
|
|
|
case FROM_OBJECT:
|
2008-02-09 02:22:17 +01:00
|
|
|
{
|
2017-08-29 08:22:45 +02:00
|
|
|
unsigned int shndx = this->u2_.shndx;
|
2009-12-14 20:53:05 +01:00
|
|
|
if (shndx != elfcpp::SHN_UNDEF && this->is_ordinary_shndx_)
|
2008-02-09 02:22:17 +01:00
|
|
|
{
|
2017-08-29 08:22:45 +02:00
|
|
|
gold_assert(!this->u1_.object->is_dynamic());
|
|
|
|
gold_assert(this->u1_.object->pluginobj() == NULL);
|
|
|
|
Relobj* relobj = static_cast<Relobj*>(this->u1_.object);
|
2009-12-14 20:53:05 +01:00
|
|
|
return relobj->output_section(shndx);
|
2008-02-09 02:22:17 +01:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
case IN_OUTPUT_DATA:
|
2017-08-29 08:22:45 +02:00
|
|
|
return this->u1_.output_data->output_section();
|
2008-02-09 02:22:17 +01:00
|
|
|
|
2008-02-04 06:43:05 +01:00
|
|
|
case IN_OUTPUT_SEGMENT:
|
2008-05-07 08:08:01 +02:00
|
|
|
case IS_CONSTANT:
|
|
|
|
case IS_UNDEFINED:
|
2008-02-09 02:22:17 +01:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
|
|
|
Symbol::set_output_section(Output_section* os)
|
|
|
|
{
|
|
|
|
switch (this->source_)
|
|
|
|
{
|
|
|
|
case FROM_OBJECT:
|
|
|
|
case IN_OUTPUT_DATA:
|
|
|
|
gold_assert(this->output_section() == os);
|
|
|
|
break;
|
2008-05-07 08:08:01 +02:00
|
|
|
case IS_CONSTANT:
|
2008-02-09 02:22:17 +01:00
|
|
|
this->source_ = IN_OUTPUT_DATA;
|
2017-08-29 08:22:45 +02:00
|
|
|
this->u1_.output_data = os;
|
|
|
|
this->u2_.offset_is_from_end = false;
|
2008-02-09 02:22:17 +01:00
|
|
|
break;
|
|
|
|
case IN_OUTPUT_SEGMENT:
|
2008-05-07 08:08:01 +02:00
|
|
|
case IS_UNDEFINED:
|
2008-02-04 06:43:05 +01:00
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
Symbol::set_output_segment(Output_segment* os, Segment_offset_base base)
|
|
|
|
{
|
|
|
|
gold_assert(this->is_predefined_);
|
|
|
|
this->source_ = IN_OUTPUT_SEGMENT;
|
2017-08-29 08:22:45 +02:00
|
|
|
this->u1_.output_segment = os;
|
|
|
|
this->u2_.offset_base = base;
|
2014-04-02 23:21:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
|
|
|
Symbol::set_undefined()
|
|
|
|
{
|
|
|
|
this->source_ = IS_UNDEFINED;
|
|
|
|
this->is_predefined_ = false;
|
|
|
|
}
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Class Symbol_table.
|
|
|
|
|
2008-01-16 00:41:28 +01:00
|
|
|
Symbol_table::Symbol_table(unsigned int count,
|
2009-12-14 20:53:05 +01:00
|
|
|
const Version_script_info& version_script)
|
2007-12-14 06:24:17 +01:00
|
|
|
: saw_undefined_(0), offset_(0), table_(count), namepool_(),
|
2009-06-22 08:51:53 +02:00
|
|
|
forwarders_(), commons_(), tls_commons_(), small_commons_(),
|
|
|
|
large_commons_(), forced_locals_(), warnings_(),
|
2016-02-05 01:55:39 +01:00
|
|
|
version_script_(version_script), gc_(NULL), icf_(NULL),
|
|
|
|
target_symbols_()
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2007-12-14 06:24:17 +01:00
|
|
|
namepool_.reserve(count);
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Symbol_table::~Symbol_table()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-12-05 01:48:49 +01:00
|
|
|
// The symbol table key equality function. This is called with
|
|
|
|
// Stringpool keys.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2007-12-05 01:48:49 +01:00
|
|
|
inline bool
|
2006-08-19 00:29:20 +02:00
|
|
|
Symbol_table::Symbol_table_eq::operator()(const Symbol_table_key& k1,
|
|
|
|
const Symbol_table_key& k2) const
|
|
|
|
{
|
|
|
|
return k1.first == k2.first && k1.second == k2.second;
|
|
|
|
}
|
|
|
|
|
2009-08-05 22:51:56 +02:00
|
|
|
bool
|
2015-05-02 17:40:09 +02:00
|
|
|
Symbol_table::is_section_folded(Relobj* obj, unsigned int shndx) const
|
2009-08-05 22:51:56 +02:00
|
|
|
{
|
2009-10-13 23:17:43 +02:00
|
|
|
return (parameters->options().icf_enabled()
|
2009-12-14 20:53:05 +01:00
|
|
|
&& this->icf_->is_section_folded(obj, shndx));
|
2009-08-05 22:51:56 +02:00
|
|
|
}
|
|
|
|
|
2012-04-17 02:28:41 +02:00
|
|
|
// For symbols that have been listed with a -u or --export-dynamic-symbol
|
|
|
|
// option, add them to the work list to avoid gc'ing them.
|
2009-01-28 03:25:33 +01:00
|
|
|
|
|
|
|
void
|
2010-08-02 15:34:33 +02:00
|
|
|
Symbol_table::gc_mark_undef_symbols(Layout* layout)
|
2009-01-28 03:25:33 +01:00
|
|
|
{
|
|
|
|
for (options::String_set::const_iterator p =
|
|
|
|
parameters->options().undefined_begin();
|
|
|
|
p != parameters->options().undefined_end();
|
|
|
|
++p)
|
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* name = p->c_str();
|
|
|
|
Symbol* sym = this->lookup(name);
|
2010-08-25 10:36:54 +02:00
|
|
|
gold_assert(sym != NULL);
|
2009-01-28 03:25:33 +01:00
|
|
|
if (sym->source() == Symbol::FROM_OBJECT
|
|
|
|
&& !sym->object()->is_dynamic())
|
|
|
|
{
|
2012-09-09 05:43:51 +02:00
|
|
|
this->gc_mark_symbol(sym);
|
2009-01-28 03:25:33 +01:00
|
|
|
}
|
|
|
|
}
|
2010-08-02 15:34:33 +02:00
|
|
|
|
2012-04-17 02:28:41 +02:00
|
|
|
for (options::String_set::const_iterator p =
|
|
|
|
parameters->options().export_dynamic_symbol_begin();
|
|
|
|
p != parameters->options().export_dynamic_symbol_end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
const char* name = p->c_str();
|
|
|
|
Symbol* sym = this->lookup(name);
|
2012-08-21 23:41:04 +02:00
|
|
|
// It's not an error if a symbol named by --export-dynamic-symbol
|
|
|
|
// is undefined.
|
|
|
|
if (sym != NULL
|
|
|
|
&& sym->source() == Symbol::FROM_OBJECT
|
2012-04-17 02:28:41 +02:00
|
|
|
&& !sym->object()->is_dynamic())
|
|
|
|
{
|
2012-09-09 05:43:51 +02:00
|
|
|
this->gc_mark_symbol(sym);
|
2012-04-17 02:28:41 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-02 15:34:33 +02:00
|
|
|
for (Script_options::referenced_const_iterator p =
|
|
|
|
layout->script_options()->referenced_begin();
|
|
|
|
p != layout->script_options()->referenced_end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
Symbol* sym = this->lookup(p->c_str());
|
|
|
|
gold_assert(sym != NULL);
|
|
|
|
if (sym->source() == Symbol::FROM_OBJECT
|
|
|
|
&& !sym->object()->is_dynamic())
|
|
|
|
{
|
2012-09-09 05:43:51 +02:00
|
|
|
this->gc_mark_symbol(sym);
|
2010-08-02 15:34:33 +02:00
|
|
|
}
|
|
|
|
}
|
2009-01-28 03:25:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-10-31 22:36:54 +01:00
|
|
|
Symbol_table::gc_mark_symbol(Symbol* sym)
|
2009-01-28 03:25:33 +01:00
|
|
|
{
|
2011-10-31 22:36:54 +01:00
|
|
|
// Add the object and section to the work list.
|
|
|
|
bool is_ordinary;
|
|
|
|
unsigned int shndx = sym->shndx(&is_ordinary);
|
2015-05-02 17:40:09 +02:00
|
|
|
if (is_ordinary && shndx != elfcpp::SHN_UNDEF && !sym->object()->is_dynamic())
|
2009-01-28 03:25:33 +01:00
|
|
|
{
|
2011-10-31 22:36:54 +01:00
|
|
|
gold_assert(this->gc_!= NULL);
|
2015-05-02 17:40:09 +02:00
|
|
|
Relobj* relobj = static_cast<Relobj*>(sym->object());
|
|
|
|
this->gc_->worklist().push_back(Section_id(relobj, shndx));
|
2009-01-28 03:25:33 +01:00
|
|
|
}
|
2012-09-09 05:43:51 +02:00
|
|
|
parameters->target().gc_mark_symbol(this, sym);
|
2009-01-28 03:25:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// When doing garbage collection, keep symbols that have been seen in
|
|
|
|
// dynamic objects.
|
|
|
|
inline void
|
|
|
|
Symbol_table::gc_mark_dyn_syms(Symbol* sym)
|
|
|
|
{
|
|
|
|
if (sym->in_dyn() && sym->source() == Symbol::FROM_OBJECT
|
|
|
|
&& !sym->object()->is_dynamic())
|
2011-10-31 22:36:54 +01:00
|
|
|
this->gc_mark_symbol(sym);
|
2009-01-28 03:25:33 +01:00
|
|
|
}
|
|
|
|
|
2007-11-17 03:49:22 +01:00
|
|
|
// Make TO a symbol which forwards to FROM.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
Symbol_table::make_forwarder(Symbol* from, Symbol* to)
|
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(from != to);
|
|
|
|
gold_assert(!from->is_forwarder() && !to->is_forwarder());
|
2006-08-19 00:29:20 +02:00
|
|
|
this->forwarders_[from] = to;
|
|
|
|
from->set_forwarder();
|
|
|
|
}
|
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
// Resolve the forwards from FROM, returning the real symbol.
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
Symbol*
|
2006-11-16 01:38:25 +01:00
|
|
|
Symbol_table::resolve_forwards(const Symbol* from) const
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(from->is_forwarder());
|
2006-11-16 01:38:25 +01:00
|
|
|
Unordered_map<const Symbol*, Symbol*>::const_iterator p =
|
2006-08-19 00:29:20 +02:00
|
|
|
this->forwarders_.find(from);
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(p != this->forwarders_.end());
|
2006-08-19 00:29:20 +02:00
|
|
|
return p->second;
|
|
|
|
}
|
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
// Look up a symbol by name.
|
|
|
|
|
|
|
|
Symbol*
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol_table::lookup(const char* name, const char* version) const
|
2006-09-29 21:58:17 +02:00
|
|
|
{
|
2006-11-07 05:40:46 +01:00
|
|
|
Stringpool::Key name_key;
|
2009-12-14 20:53:05 +01:00
|
|
|
name = this->namepool_.find(name, &name_key);
|
|
|
|
if (name == NULL)
|
2006-09-29 21:58:17 +02:00
|
|
|
return NULL;
|
2006-11-07 05:40:46 +01:00
|
|
|
|
|
|
|
Stringpool::Key version_key = 0;
|
2009-12-14 20:53:05 +01:00
|
|
|
if (version != NULL)
|
2006-09-29 21:58:17 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
version = this->namepool_.find(version, &version_key);
|
|
|
|
if (version == NULL)
|
2006-09-29 21:58:17 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-11-07 05:40:46 +01:00
|
|
|
Symbol_table_key key(name_key, version_key);
|
2006-09-29 21:58:17 +02:00
|
|
|
Symbol_table::Symbol_table_type::const_iterator p = this->table_.find(key);
|
|
|
|
if (p == this->table_.end())
|
|
|
|
return NULL;
|
|
|
|
return p->second;
|
|
|
|
}
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Resolve a Symbol with another Symbol. This is only used in the
|
|
|
|
// unusual case where there are references to both an unversioned
|
|
|
|
// symbol and a symbol with a version, and we then discover that that
|
2006-09-07 23:21:41 +02:00
|
|
|
// version is the default version. Because this is unusual, we do
|
|
|
|
// this the slow way, by converting back to an ELF symbol.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2006-09-07 23:21:41 +02:00
|
|
|
template<int size, bool big_endian>
|
2006-08-19 00:29:20 +02:00
|
|
|
void
|
2008-07-23 16:36:09 +02:00
|
|
|
Symbol_table::resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2006-09-07 23:21:41 +02:00
|
|
|
unsigned char buf[elfcpp::Elf_sizes<size>::sym_size];
|
|
|
|
elfcpp::Sym_write<size, big_endian> esym(buf);
|
2008-04-19 20:30:58 +02:00
|
|
|
// We don't bother to set the st_name or the st_shndx field.
|
2006-09-07 23:21:41 +02:00
|
|
|
esym.put_st_value(from->value());
|
|
|
|
esym.put_st_size(from->symsize());
|
|
|
|
esym.put_st_info(from->binding(), from->type());
|
2006-11-03 19:26:11 +01:00
|
|
|
esym.put_st_other(from->visibility(), from->nonvis());
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
2009-12-14 20:53:05 +01:00
|
|
|
unsigned int shndx = from->shndx(&is_ordinary);
|
|
|
|
this->resolve(to, esym.sym(), shndx, is_ordinary, shndx, from->object(),
|
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
|
|
|
from->version(), true);
|
2007-08-29 05:42:51 +02:00
|
|
|
if (from->in_reg())
|
|
|
|
to->set_in_reg();
|
|
|
|
if (from->in_dyn())
|
|
|
|
to->set_in_dyn();
|
2009-01-28 03:25:33 +01:00
|
|
|
if (parameters->options().gc_sections())
|
|
|
|
this->gc_mark_dyn_syms(to);
|
2006-08-19 00:29:20 +02: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
|
|
|
|
Symbol_table::force_local(Symbol* sym)
|
|
|
|
{
|
|
|
|
if (!sym->is_defined() && !sym->is_common())
|
|
|
|
return;
|
|
|
|
if (sym->is_forced_local())
|
|
|
|
{
|
|
|
|
// We already got this one.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
sym->set_is_forced_local();
|
|
|
|
this->forced_locals_.push_back(sym);
|
|
|
|
}
|
|
|
|
|
2008-04-09 02:48:13 +02:00
|
|
|
// Adjust NAME for wrapping, and update *NAME_KEY if necessary. This
|
|
|
|
// is only called for undefined symbols, when at least one --wrap
|
|
|
|
// option was used.
|
|
|
|
|
|
|
|
const char*
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol_table::wrap_symbol(const char* name, Stringpool::Key* name_key)
|
2008-04-09 02:48:13 +02:00
|
|
|
{
|
|
|
|
// For some targets, we need to ignore a specific character when
|
|
|
|
// wrapping, and add it back later.
|
|
|
|
char prefix = '\0';
|
2009-12-14 20:53:05 +01:00
|
|
|
if (name[0] == parameters->target().wrap_char())
|
2008-04-09 02:48:13 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
prefix = name[0];
|
|
|
|
++name;
|
2008-04-09 02:48:13 +02:00
|
|
|
}
|
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
if (parameters->options().is_wrap(name))
|
2008-04-09 02:48:13 +02:00
|
|
|
{
|
|
|
|
// Turn NAME into __wrap_NAME.
|
|
|
|
std::string s;
|
|
|
|
if (prefix != '\0')
|
|
|
|
s += prefix;
|
|
|
|
s += "__wrap_";
|
2009-12-14 20:53:05 +01:00
|
|
|
s += name;
|
2008-04-09 02:48:13 +02:00
|
|
|
|
|
|
|
// This will give us both the old and new name in NAMEPOOL_, but
|
|
|
|
// that is OK. Only the versions we need will wind up in the
|
|
|
|
// real string table in the output file.
|
|
|
|
return this->namepool_.add(s.c_str(), true, name_key);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* const real_prefix = "__real_";
|
|
|
|
const size_t real_prefix_length = strlen(real_prefix);
|
2009-12-14 20:53:05 +01:00
|
|
|
if (strncmp(name, real_prefix, real_prefix_length) == 0
|
|
|
|
&& parameters->options().is_wrap(name + real_prefix_length))
|
2008-04-09 02:48:13 +02:00
|
|
|
{
|
|
|
|
// Turn __real_NAME into NAME.
|
|
|
|
std::string s;
|
|
|
|
if (prefix != '\0')
|
|
|
|
s += prefix;
|
2009-12-14 20:53:05 +01:00
|
|
|
s += name + real_prefix_length;
|
2008-04-09 02:48:13 +02:00
|
|
|
return this->namepool_.add(s.c_str(), true, name_key);
|
|
|
|
}
|
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
return name;
|
2008-04-09 02:48:13 +02:00
|
|
|
}
|
|
|
|
|
2009-03-17 08:07:21 +01:00
|
|
|
// This is called when we see a symbol NAME/VERSION, and the symbol
|
|
|
|
// already exists in the symbol table, and VERSION is marked as being
|
|
|
|
// the default version. SYM is the NAME/VERSION symbol we just added.
|
|
|
|
// DEFAULT_IS_NEW is true if this is the first time we have seen the
|
|
|
|
// symbol NAME/NULL. PDEF points to the entry for NAME/NULL.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Symbol_table::define_default_version(Sized_symbol<size>* sym,
|
|
|
|
bool default_is_new,
|
|
|
|
Symbol_table_type::iterator pdef)
|
|
|
|
{
|
|
|
|
if (default_is_new)
|
|
|
|
{
|
|
|
|
// This is the first time we have seen NAME/NULL. Make
|
|
|
|
// NAME/NULL point to NAME/VERSION, and mark SYM as the default
|
|
|
|
// version.
|
|
|
|
pdef->second = sym;
|
|
|
|
sym->set_is_default();
|
|
|
|
}
|
|
|
|
else if (pdef->second == sym)
|
|
|
|
{
|
|
|
|
// NAME/NULL already points to NAME/VERSION. Don't mark the
|
|
|
|
// symbol as the default if it is not already the default.
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// This is the unfortunate case where we already have entries
|
|
|
|
// for both NAME/VERSION and NAME/NULL. We now see a symbol
|
|
|
|
// NAME/VERSION where VERSION is the default version. We have
|
|
|
|
// already resolved this new symbol with the existing
|
|
|
|
// NAME/VERSION symbol.
|
|
|
|
|
|
|
|
// It's possible that NAME/NULL and NAME/VERSION are both
|
|
|
|
// defined in regular objects. This can only happen if one
|
|
|
|
// object file defines foo and another defines foo@@ver. This
|
|
|
|
// is somewhat obscure, but we call it a multiple definition
|
|
|
|
// error.
|
|
|
|
|
|
|
|
// It's possible that NAME/NULL actually has a version, in which
|
|
|
|
// case it won't be the same as VERSION. This happens with
|
|
|
|
// ver_test_7.so in the testsuite for the symbol t2_2. We see
|
|
|
|
// t2_2@@VER2, so we define both t2_2/VER2 and t2_2/NULL. We
|
|
|
|
// then see an unadorned t2_2 in an object file and give it
|
|
|
|
// version VER1 from the version script. This looks like a
|
|
|
|
// default definition for VER1, so it looks like we should merge
|
|
|
|
// t2_2/NULL with t2_2/VER1. That doesn't make sense, but it's
|
|
|
|
// not obvious that this is an error, either. So we just punt.
|
|
|
|
|
|
|
|
// If one of the symbols has non-default visibility, and the
|
|
|
|
// other is defined in a shared object, then they are different
|
|
|
|
// symbols.
|
|
|
|
|
2016-03-31 04:14:16 +02:00
|
|
|
// If the two symbols are from different shared objects,
|
|
|
|
// they are different symbols.
|
|
|
|
|
2009-03-17 08:07:21 +01:00
|
|
|
// Otherwise, we just resolve the symbols as though they were
|
|
|
|
// the same.
|
|
|
|
|
|
|
|
if (pdef->second->version() != NULL)
|
|
|
|
gold_assert(pdef->second->version() != sym->version());
|
|
|
|
else if (sym->visibility() != elfcpp::STV_DEFAULT
|
|
|
|
&& pdef->second->is_from_dynobj())
|
|
|
|
;
|
|
|
|
else if (pdef->second->visibility() != elfcpp::STV_DEFAULT
|
|
|
|
&& sym->is_from_dynobj())
|
|
|
|
;
|
2016-03-31 04:14:16 +02:00
|
|
|
else if (pdef->second->is_from_dynobj()
|
|
|
|
&& sym->is_from_dynobj()
|
2016-09-27 21:08:19 +02:00
|
|
|
&& pdef->second->is_defined()
|
2016-03-31 04:14:16 +02:00
|
|
|
&& pdef->second->object() != sym->object())
|
|
|
|
;
|
2009-03-17 08:07:21 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
const Sized_symbol<size>* symdef;
|
|
|
|
symdef = this->get_sized_symbol<size>(pdef->second);
|
|
|
|
Symbol_table::resolve<size, big_endian>(sym, symdef);
|
|
|
|
this->make_forwarder(pdef->second, sym);
|
|
|
|
pdef->second = sym;
|
|
|
|
sym->set_is_default();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Add one symbol from OBJECT to the symbol table. NAME is symbol
|
|
|
|
// name and VERSION is the version; both are canonicalized. DEF is
|
2008-04-19 20:30:58 +02:00
|
|
|
// whether this is the default version. ST_SHNDX is the symbol's
|
|
|
|
// section index; IS_ORDINARY is whether this is a normal section
|
|
|
|
// rather than a special code.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2010-01-05 20:29:15 +01:00
|
|
|
// If IS_DEFAULT_VERSION is true, then this is the definition of a
|
|
|
|
// default version of a symbol. That means that any lookup of
|
|
|
|
// NAME/NULL and any lookup of NAME/VERSION should always return the
|
|
|
|
// same symbol. This is obvious for references, but in particular we
|
|
|
|
// want to do this for definitions: overriding NAME/NULL should also
|
|
|
|
// override NAME/VERSION. If we don't do that, it would be very hard
|
|
|
|
// to override functions in a shared library which uses versioning.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
// We implement this by simply making both entries in the hash table
|
|
|
|
// point to the same Symbol structure. That is easy enough if this is
|
|
|
|
// the first time we see NAME/NULL or NAME/VERSION, but it is possible
|
|
|
|
// that we have seen both already, in which case they will both have
|
|
|
|
// independent entries in the symbol table. We can't simply change
|
|
|
|
// the symbol table entry, because we have pointers to the entries
|
|
|
|
// attached to the object files. So we mark the entry attached to the
|
|
|
|
// object file as a forwarder, and record it in the forwarders_ map.
|
|
|
|
// Note that entries in the hash table will never be marked as
|
|
|
|
// forwarders.
|
2007-11-13 21:02:32 +01:00
|
|
|
//
|
2008-04-19 20:30:58 +02:00
|
|
|
// ORIG_ST_SHNDX and ST_SHNDX are almost always the same.
|
|
|
|
// ORIG_ST_SHNDX is the section index in the input file, or SHN_UNDEF
|
|
|
|
// for a special section code. ST_SHNDX may be modified if the symbol
|
|
|
|
// is defined in a section being discarded.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
2007-10-14 17:35:27 +02:00
|
|
|
Sized_symbol<size>*
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol_table::add_from_object(Object* object,
|
2010-08-25 10:36:54 +02:00
|
|
|
const char* name,
|
2006-11-07 05:40:46 +01:00
|
|
|
Stringpool::Key name_key,
|
2010-08-25 10:36:54 +02:00
|
|
|
const char* version,
|
2006-11-07 05:40:46 +01:00
|
|
|
Stringpool::Key version_key,
|
2010-01-05 20:29:15 +01:00
|
|
|
bool is_default_version,
|
2007-11-13 21:02:32 +01:00
|
|
|
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
|
|
|
{
|
2008-04-18 00:45:47 +02:00
|
|
|
// Print a message if this symbol is being traced.
|
2009-12-14 20:53:05 +01:00
|
|
|
if (parameters->options().is_trace_symbol(name))
|
2008-04-18 00:45:47 +02:00
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
if (orig_st_shndx == elfcpp::SHN_UNDEF)
|
2009-12-14 20:53:05 +01:00
|
|
|
gold_info(_("%s: reference to %s"), object->name().c_str(), name);
|
2008-04-18 00:45:47 +02:00
|
|
|
else
|
2009-12-14 20:53:05 +01:00
|
|
|
gold_info(_("%s: definition of %s"), object->name().c_str(), name);
|
2008-04-18 00:45:47 +02:00
|
|
|
}
|
|
|
|
|
2008-04-09 02:48:13 +02:00
|
|
|
// For an undefined symbol, we may need to adjust the name using
|
|
|
|
// --wrap.
|
2008-04-19 20:30:58 +02:00
|
|
|
if (orig_st_shndx == elfcpp::SHN_UNDEF
|
2008-04-18 00:45:47 +02:00
|
|
|
&& parameters->options().any_wrap())
|
2008-04-09 02:48:13 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* wrap_name = this->wrap_symbol(name, &name_key);
|
|
|
|
if (wrap_name != name)
|
2008-04-09 02:48:13 +02:00
|
|
|
{
|
|
|
|
// If we see a reference to malloc with version GLIBC_2.0,
|
|
|
|
// and we turn it into a reference to __wrap_malloc, then we
|
|
|
|
// discard the version number. Otherwise the user would be
|
|
|
|
// required to specify the correct version for
|
|
|
|
// __wrap_malloc.
|
2009-12-14 20:53:05 +01:00
|
|
|
version = NULL;
|
2008-04-09 02:48:13 +02:00
|
|
|
version_key = 0;
|
2009-12-14 20:53:05 +01:00
|
|
|
name = wrap_name;
|
2008-04-09 02:48:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
Symbol* const snull = NULL;
|
|
|
|
std::pair<typename Symbol_table_type::iterator, bool> ins =
|
2006-11-07 05:40:46 +01:00
|
|
|
this->table_.insert(std::make_pair(std::make_pair(name_key, version_key),
|
|
|
|
snull));
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2010-01-05 20:29:15 +01:00
|
|
|
std::pair<typename Symbol_table_type::iterator, bool> insdefault =
|
2006-08-19 00:29:20 +02:00
|
|
|
std::make_pair(this->table_.end(), false);
|
2010-01-05 20:29:15 +01:00
|
|
|
if (is_default_version)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2006-11-07 05:40:46 +01:00
|
|
|
const Stringpool::Key vnull_key = 0;
|
2010-01-05 20:29:15 +01:00
|
|
|
insdefault = this->table_.insert(std::make_pair(std::make_pair(name_key,
|
|
|
|
vnull_key),
|
|
|
|
snull));
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// ins.first: an iterator, which is a pointer to a pair.
|
|
|
|
// ins.first->first: the key (a pair of name and version).
|
|
|
|
// ins.first->second: the value (Symbol*).
|
|
|
|
// ins.second: true if new entry was inserted, false if not.
|
|
|
|
|
2018-04-23 18:27:35 +02:00
|
|
|
Sized_symbol<size>* ret = NULL;
|
2017-12-01 21:10:02 +01:00
|
|
|
bool was_undefined_in_reg;
|
2006-11-03 19:26:11 +01:00
|
|
|
bool was_common;
|
2006-08-19 00:29:20 +02:00
|
|
|
if (!ins.second)
|
|
|
|
{
|
|
|
|
// We already have an entry for NAME/VERSION.
|
2008-02-29 20:19:17 +01:00
|
|
|
ret = this->get_sized_symbol<size>(ins.first->second);
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(ret != NULL);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2017-12-01 21:10:02 +01:00
|
|
|
was_undefined_in_reg = ret->is_undefined() && ret->in_reg();
|
Fix problem where TLS common symbols are not allocated properly during LTO.
The plugin API doesn't provide a way for the claimed file handler to
identify a TLS symbol, so when adding a common TLS symbol, gold
mistakenly places the symbol in the non-TLS commons list, and does
not override it when we see the replacement symbol that is marked
as TLS. Consequently, we allocate the TLS common symbol as a regular
common, and, if it's the only TLS in the program, we'll give an
internal error because we haven't allocated a TLS segment.
This patch fixes the problem by removing an exclusion where common
symbols would not override the placeholder symbols, but checking to
see if the size needs adjusting (the original reason for the exclusion).
Furthermore, we need to avoid putting placeholder symbols in the common
list, and wait until we see a real common symbol with a type we can
trust.
gold/
PR gold/17432
* resolve.cc (Symbol_table::resolve): Override common placeholder
symbols, but adjust sizes.
* symtab.cc (Symbol_table::add_from_object): Don't add placeholder
symbols to common lists.
2014-09-26 06:47:10 +02:00
|
|
|
// Commons from plugins are just placeholders.
|
|
|
|
was_common = ret->is_common() && ret->object()->pluginobj() == NULL;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object,
|
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
|
|
|
version, is_default_version);
|
2009-01-28 03:25:33 +01:00
|
|
|
if (parameters->options().gc_sections())
|
|
|
|
this->gc_mark_dyn_syms(ret);
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2010-01-05 20:29:15 +01:00
|
|
|
if (is_default_version)
|
|
|
|
this->define_default_version<size, big_endian>(ret, insdefault.second,
|
|
|
|
insdefault.first);
|
2015-08-26 02:53:53 +02:00
|
|
|
else
|
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
|
|
|
{
|
|
|
|
bool dummy;
|
2015-08-26 02:53:53 +02:00
|
|
|
if (version != NULL
|
|
|
|
&& ret->source() == Symbol::FROM_OBJECT
|
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
|
|
|
&& ret->object() == object
|
|
|
|
&& is_ordinary
|
2015-08-26 02:53:53 +02:00
|
|
|
&& ret->shndx(&dummy) == st_shndx
|
|
|
|
&& ret->is_default())
|
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
|
|
|
{
|
2015-08-26 02:53:53 +02:00
|
|
|
// We have seen NAME/VERSION already, and marked it as the
|
|
|
|
// default version, but now we see a definition for
|
|
|
|
// NAME/VERSION that is not the default version. This can
|
|
|
|
// happen when the assembler generates two symbols for
|
|
|
|
// a symbol as a result of a ".symver foo,foo@VER"
|
|
|
|
// directive. We see the first unversioned symbol and
|
|
|
|
// we may mark it as the default version (from a
|
|
|
|
// version script); then we see the second versioned
|
|
|
|
// symbol and we need to override the first.
|
|
|
|
// In any other case, the two symbols should have generated
|
|
|
|
// a multiple definition error.
|
|
|
|
// (See PR gold/18703.)
|
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
|
|
|
ret->set_is_not_default();
|
|
|
|
const Stringpool::Key vnull_key = 0;
|
|
|
|
this->table_.erase(std::make_pair(name_key, vnull_key));
|
|
|
|
}
|
|
|
|
}
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// This is the first time we have seen NAME/VERSION.
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(ins.first->second == NULL);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2010-01-05 20:29:15 +01:00
|
|
|
if (is_default_version && !insdefault.second)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2006-12-06 01:02:36 +01:00
|
|
|
// We already have an entry for NAME/NULL. If we override
|
|
|
|
// it, then change it to NAME/VERSION.
|
2010-01-05 20:29:15 +01:00
|
|
|
ret = this->get_sized_symbol<size>(insdefault.first->second);
|
2008-03-27 19:19:09 +01:00
|
|
|
|
2018-04-23 18:27:35 +02:00
|
|
|
// If the existing symbol already has a version,
|
|
|
|
// don't override it with the new symbol.
|
|
|
|
// This should only happen when the new symbol
|
|
|
|
// is from a shared library.
|
|
|
|
if (ret->version() != NULL)
|
|
|
|
{
|
|
|
|
if (!object->is_dynamic())
|
|
|
|
{
|
|
|
|
gold_warning(_("%s: conflicting default version definition"
|
|
|
|
" for %s@@%s"),
|
|
|
|
object->name().c_str(), name, version);
|
|
|
|
if (ret->source() == Symbol::FROM_OBJECT)
|
|
|
|
gold_info(_("%s: %s: previous definition of %s@@%s here"),
|
|
|
|
program_name,
|
|
|
|
ret->object()->name().c_str(),
|
|
|
|
name, ret->version());
|
|
|
|
}
|
|
|
|
ret = NULL;
|
|
|
|
is_default_version = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
was_undefined_in_reg = ret->is_undefined() && ret->in_reg();
|
|
|
|
// Commons from plugins are just placeholders.
|
|
|
|
was_common = (ret->is_common()
|
|
|
|
&& ret->object()->pluginobj() == NULL);
|
|
|
|
|
|
|
|
this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx,
|
|
|
|
object, version, is_default_version);
|
|
|
|
if (parameters->options().gc_sections())
|
|
|
|
this->gc_mark_dyn_syms(ret);
|
|
|
|
ins.first->second = ret;
|
|
|
|
}
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
2018-04-23 18:27:35 +02:00
|
|
|
|
|
|
|
if (ret == NULL)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2017-12-01 21:10:02 +01:00
|
|
|
was_undefined_in_reg = false;
|
2008-03-27 19:19:09 +01:00
|
|
|
was_common = false;
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
Sized_target<size, big_endian>* target =
|
2009-10-01 00:21:13 +02:00
|
|
|
parameters->sized_target<size, big_endian>();
|
2006-09-07 23:21:41 +02:00
|
|
|
if (!target->has_make_symbol())
|
|
|
|
ret = new Sized_symbol<size>();
|
|
|
|
else
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2016-02-05 01:55:39 +01:00
|
|
|
ret = target->make_symbol(name, sym.get_st_type(), object,
|
|
|
|
st_shndx, sym.get_st_value());
|
2006-09-07 23:21:41 +02:00
|
|
|
if (ret == NULL)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
|
|
|
// This means that we don't want a symbol table
|
|
|
|
// entry after all.
|
2010-01-05 20:29:15 +01:00
|
|
|
if (!is_default_version)
|
2006-08-19 00:29:20 +02:00
|
|
|
this->table_.erase(ins.first);
|
|
|
|
else
|
|
|
|
{
|
2010-01-05 20:29:15 +01:00
|
|
|
this->table_.erase(insdefault.first);
|
|
|
|
// Inserting INSDEFAULT invalidated INS.
|
2006-11-07 05:40:46 +01:00
|
|
|
this->table_.erase(std::make_pair(name_key,
|
|
|
|
version_key));
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
ret->init_object(name, version, object, sym, st_shndx, is_ordinary);
|
2006-09-07 23:21:41 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
ins.first->second = ret;
|
2010-01-05 20:29:15 +01:00
|
|
|
if (is_default_version)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
|
|
|
// This is the first time we have seen NAME/NULL. Point
|
|
|
|
// it at the new entry for NAME/VERSION.
|
2010-01-05 20:29:15 +01:00
|
|
|
gold_assert(insdefault.second);
|
|
|
|
insdefault.first->second = ret;
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
}
|
2009-03-17 08:07:21 +01:00
|
|
|
|
2010-01-05 20:29:15 +01:00
|
|
|
if (is_default_version)
|
2009-03-17 08:07:21 +01:00
|
|
|
ret->set_is_default();
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
|
2017-12-01 21:10:02 +01:00
|
|
|
// Record every time we see a new undefined symbol, to speed up archive
|
|
|
|
// groups. We only care about symbols undefined in regular objects here
|
|
|
|
// because undefined symbols only in dynamic objects should't trigger rescans.
|
|
|
|
if (!was_undefined_in_reg && ret->is_undefined() && ret->in_reg())
|
2011-01-24 22:48:40 +01:00
|
|
|
{
|
|
|
|
++this->saw_undefined_;
|
|
|
|
if (parameters->options().has_plugins())
|
|
|
|
parameters->options().plugins()->new_undefined_symbol(ret);
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
// Keep track of common symbols, to speed up common symbol
|
Fix problem where TLS common symbols are not allocated properly during LTO.
The plugin API doesn't provide a way for the claimed file handler to
identify a TLS symbol, so when adding a common TLS symbol, gold
mistakenly places the symbol in the non-TLS commons list, and does
not override it when we see the replacement symbol that is marked
as TLS. Consequently, we allocate the TLS common symbol as a regular
common, and, if it's the only TLS in the program, we'll give an
internal error because we haven't allocated a TLS segment.
This patch fixes the problem by removing an exclusion where common
symbols would not override the placeholder symbols, but checking to
see if the size needs adjusting (the original reason for the exclusion).
Furthermore, we need to avoid putting placeholder symbols in the common
list, and wait until we see a real common symbol with a type we can
trust.
gold/
PR gold/17432
* resolve.cc (Symbol_table::resolve): Override common placeholder
symbols, but adjust sizes.
* symtab.cc (Symbol_table::add_from_object): Don't add placeholder
symbols to common lists.
2014-09-26 06:47:10 +02:00
|
|
|
// allocation. Don't record commons from plugin objects;
|
|
|
|
// we need to wait until we see the real symbol in the
|
|
|
|
// replacement file.
|
|
|
|
if (!was_common && ret->is_common() && ret->object()->pluginobj() == NULL)
|
2008-04-17 09:12:00 +02:00
|
|
|
{
|
2009-06-22 08:51:53 +02:00
|
|
|
if (ret->type() == elfcpp::STT_TLS)
|
2008-04-17 09:12:00 +02:00
|
|
|
this->tls_commons_.push_back(ret);
|
2009-06-22 08:51:53 +02:00
|
|
|
else if (!is_ordinary
|
|
|
|
&& st_shndx == parameters->target().small_common_shndx())
|
|
|
|
this->small_commons_.push_back(ret);
|
|
|
|
else if (!is_ordinary
|
|
|
|
&& st_shndx == parameters->target().large_common_shndx())
|
|
|
|
this->large_commons_.push_back(ret);
|
|
|
|
else
|
|
|
|
this->commons_.push_back(ret);
|
2008-04-17 09:12:00 +02:00
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2009-02-27 20:57:46 +01:00
|
|
|
// If we're not doing a relocatable link, then any symbol with
|
|
|
|
// hidden or internal visibility is local.
|
|
|
|
if ((ret->visibility() == elfcpp::STV_HIDDEN
|
|
|
|
|| ret->visibility() == elfcpp::STV_INTERNAL)
|
|
|
|
&& (ret->binding() == elfcpp::STB_GLOBAL
|
2009-12-05 08:28:45 +01:00
|
|
|
|| ret->binding() == elfcpp::STB_GNU_UNIQUE
|
2009-02-27 20:57:46 +01:00
|
|
|
|| ret->binding() == elfcpp::STB_WEAK)
|
|
|
|
&& !parameters->options().relocatable())
|
|
|
|
this->force_local(ret);
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
// Add all the symbols in a relocatable object to the hash table.
|
2006-08-19 00:29:20 +02:00
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2006-11-14 20:21:05 +01:00
|
|
|
Symbol_table::add_from_relobj(
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<size, big_endian>* relobj,
|
2006-11-06 23:46:08 +01:00
|
|
|
const unsigned char* syms,
|
2006-08-19 00:29:20 +02:00
|
|
|
size_t count,
|
2008-04-19 20:30:58 +02:00
|
|
|
size_t symndx_offset,
|
2006-08-19 00:29:20 +02:00
|
|
|
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* sympointers,
|
2010-08-25 10:36:54 +02:00
|
|
|
size_t* defined)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2008-07-23 00:08:43 +02:00
|
|
|
*defined = 0;
|
|
|
|
|
2008-02-28 01:18:24 +01:00
|
|
|
gold_assert(size == parameters->target().get_size());
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2006-10-10 20:54:06 +02:00
|
|
|
const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
|
|
|
|
|
2008-02-07 02:51:25 +01:00
|
|
|
const bool just_symbols = relobj->just_symbols();
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
const unsigned char* p = syms;
|
2006-10-10 20:54:06 +02:00
|
|
|
for (size_t i = 0; i < count; ++i, p += sym_size)
|
2006-08-19 00:29:20 +02:00
|
|
|
{
|
2008-07-23 00:08:43 +02:00
|
|
|
(*sympointers)[i] = NULL;
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
elfcpp::Sym<size, big_endian> sym(p);
|
|
|
|
|
2008-04-19 20:30:58 +02:00
|
|
|
unsigned int st_name = sym.get_st_name();
|
2006-08-19 00:29:20 +02:00
|
|
|
if (st_name >= sym_name_size)
|
|
|
|
{
|
2007-10-14 08:49:14 +02:00
|
|
|
relobj->error(_("bad global symbol name offset %u at %zu"),
|
|
|
|
st_name, i);
|
|
|
|
continue;
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* name = sym_names + st_name;
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2015-12-10 20:28:48 +01:00
|
|
|
if (!parameters->options().relocatable()
|
2017-10-25 07:02:52 +02:00
|
|
|
&& name[0] == '_'
|
|
|
|
&& name[1] == '_'
|
|
|
|
&& strcmp (name + (name[2] == '_'), "__gnu_lto_slim") == 0)
|
2014-08-06 05:10:00 +02:00
|
|
|
gold_info(_("%s: plugin needed to handle lto object"),
|
|
|
|
relobj->name().c_str());
|
|
|
|
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
|
|
|
unsigned int st_shndx = relobj->adjust_sym_shndx(i + symndx_offset,
|
|
|
|
sym.get_st_shndx(),
|
|
|
|
&is_ordinary);
|
|
|
|
unsigned int orig_st_shndx = st_shndx;
|
|
|
|
if (!is_ordinary)
|
|
|
|
orig_st_shndx = elfcpp::SHN_UNDEF;
|
|
|
|
|
2008-07-23 00:08:43 +02:00
|
|
|
if (st_shndx != elfcpp::SHN_UNDEF)
|
|
|
|
++*defined;
|
|
|
|
|
2006-10-10 20:54:06 +02:00
|
|
|
// A symbol defined in a section which we are not including must
|
|
|
|
// be treated as an undefined symbol.
|
2010-01-09 01:13:48 +01:00
|
|
|
bool is_defined_in_discarded_section = false;
|
2006-10-10 20:54:06 +02:00
|
|
|
if (st_shndx != elfcpp::SHN_UNDEF
|
2008-04-19 20:30:58 +02:00
|
|
|
&& is_ordinary
|
2010-04-20 23:13:30 +02:00
|
|
|
&& !relobj->is_section_included(st_shndx)
|
|
|
|
&& !this->is_section_folded(relobj, st_shndx))
|
2010-01-09 01:13:48 +01:00
|
|
|
{
|
|
|
|
st_shndx = elfcpp::SHN_UNDEF;
|
|
|
|
is_defined_in_discarded_section = true;
|
|
|
|
}
|
2006-10-10 20:54:06 +02:00
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// In an object file, an '@' in the name separates the symbol
|
|
|
|
// name from the version name. If there are two '@' characters,
|
|
|
|
// this is the default version.
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* ver = strchr(name, '@');
|
2008-07-24 01:44:02 +02:00
|
|
|
Stringpool::Key ver_key = 0;
|
2008-01-16 00:41:28 +01:00
|
|
|
int namelen = 0;
|
2010-01-05 20:29:15 +01:00
|
|
|
// IS_DEFAULT_VERSION: is the version default?
|
|
|
|
// IS_FORCED_LOCAL: is the symbol forced local?
|
|
|
|
bool is_default_version = false;
|
|
|
|
bool is_forced_local = false;
|
2008-01-16 00:41:28 +01:00
|
|
|
|
2011-09-29 19:04:36 +02:00
|
|
|
// FIXME: For incremental links, we don't store version information,
|
|
|
|
// so we need to ignore version symbols for now.
|
|
|
|
if (parameters->incremental_update() && ver != NULL)
|
|
|
|
{
|
|
|
|
namelen = ver - name;
|
|
|
|
ver = NULL;
|
|
|
|
}
|
|
|
|
|
2008-01-16 00:41:28 +01:00
|
|
|
if (ver != NULL)
|
|
|
|
{
|
|
|
|
// The symbol name is of the form foo@VERSION or foo@@VERSION
|
2009-12-14 20:53:05 +01:00
|
|
|
namelen = ver - name;
|
2008-01-16 00:41:28 +01:00
|
|
|
++ver;
|
|
|
|
if (*ver == '@')
|
|
|
|
{
|
2010-01-05 20:29:15 +01:00
|
|
|
is_default_version = true;
|
2008-01-16 00:41:28 +01:00
|
|
|
++ver;
|
|
|
|
}
|
2008-07-24 01:44:02 +02:00
|
|
|
ver = this->namepool_.add(ver, true, &ver_key);
|
2008-01-16 00:41:28 +01:00
|
|
|
}
|
2008-03-27 07:11:57 +01:00
|
|
|
// We don't want to assign a version to an undefined symbol,
|
|
|
|
// even if it is listed in the version script. FIXME: What
|
|
|
|
// about a common symbol?
|
2008-07-24 01:44:02 +02:00
|
|
|
else
|
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
namelen = strlen(name);
|
2008-07-24 01:44:02 +02:00
|
|
|
if (!this->version_script_.empty()
|
|
|
|
&& st_shndx != elfcpp::SHN_UNDEF)
|
|
|
|
{
|
|
|
|
// The symbol name did not have a version, but the
|
|
|
|
// version script may assign a version anyway.
|
2009-12-14 20:53:05 +01:00
|
|
|
std::string version;
|
* script.cc (class Lazy_demangler): Recreate--revert part of patch
of 2009-12-30.
(Version_script_info::Version_script_info): Initialize globs_,
default_version_, default_is_global_, and exact_. Don't
initialize globals_ or locals_.
(Version_script_info::build_lookup_tables): Build local symbols
first.
(Version_script_info::unquote): New function.
(Version_script_info::add_exact_match): New function.
(Version_script_info::build_expression_list_lookup): Remove lookup
parameter. Add is_global parameter. Change all callers. Handle
wildcard pattern specially. Unquote pattern. Call
add_exact_match.
(Version_script_info::get_name_to_match): New function.
(Version_script_info::get_symbol_version): New function.
(Version_script_info::get_symbol_version_helper): Remove.
(Version_script_info::check_unmatched_names): Call unquote.
* script.h (class Version_script_info): Change get_symbol_version
to be non-inline and add is_global parameter; change all callers.
Rewrite symbol_is_local. Update declarations. Define struct
Version_tree_match, Exact, Globs. Don't define struct Lookup.
Remove globals_ and locals_ members. Add exact_, globs_,
default_version_, is_global_.
(Version_script_info::Glob): Remove pattern, add expression and
is_global. Update constructor. Change all callers.
* dynobj.cc (Versions::finalize): Mark the version symbol as the
default version.
(Versions::symbol_section_contents): If a symbol is undefined, or
defined in a dynamic object, set the version index to
VER_NDX_LOCAL.
* symtab.cc (Symbol_table::add_from_relobj): Don't call
symbol_is_local.
(Symbol_table::add_from_pluginobj): Likewise.
* testsuite/ver_matching_test.sh: blaza1 and blaza go into V2.
2010-01-12 07:41:36 +01:00
|
|
|
bool is_global;
|
|
|
|
if (this->version_script_.get_symbol_version(name, &version,
|
|
|
|
&is_global))
|
2008-07-24 01:44:02 +02:00
|
|
|
{
|
* script.cc (class Lazy_demangler): Recreate--revert part of patch
of 2009-12-30.
(Version_script_info::Version_script_info): Initialize globs_,
default_version_, default_is_global_, and exact_. Don't
initialize globals_ or locals_.
(Version_script_info::build_lookup_tables): Build local symbols
first.
(Version_script_info::unquote): New function.
(Version_script_info::add_exact_match): New function.
(Version_script_info::build_expression_list_lookup): Remove lookup
parameter. Add is_global parameter. Change all callers. Handle
wildcard pattern specially. Unquote pattern. Call
add_exact_match.
(Version_script_info::get_name_to_match): New function.
(Version_script_info::get_symbol_version): New function.
(Version_script_info::get_symbol_version_helper): Remove.
(Version_script_info::check_unmatched_names): Call unquote.
* script.h (class Version_script_info): Change get_symbol_version
to be non-inline and add is_global parameter; change all callers.
Rewrite symbol_is_local. Update declarations. Define struct
Version_tree_match, Exact, Globs. Don't define struct Lookup.
Remove globals_ and locals_ members. Add exact_, globs_,
default_version_, is_global_.
(Version_script_info::Glob): Remove pattern, add expression and
is_global. Update constructor. Change all callers.
* dynobj.cc (Versions::finalize): Mark the version symbol as the
default version.
(Versions::symbol_section_contents): If a symbol is undefined, or
defined in a dynamic object, set the version index to
VER_NDX_LOCAL.
* symtab.cc (Symbol_table::add_from_relobj): Don't call
symbol_is_local.
(Symbol_table::add_from_pluginobj): Likewise.
* testsuite/ver_matching_test.sh: blaza1 and blaza go into V2.
2010-01-12 07:41:36 +01:00
|
|
|
if (!is_global)
|
|
|
|
is_forced_local = true;
|
|
|
|
else if (!version.empty())
|
2008-07-24 01:44:02 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
ver = this->namepool_.add_with_length(version.c_str(),
|
|
|
|
version.length(),
|
2008-07-24 01:44:02 +02:00
|
|
|
true,
|
|
|
|
&ver_key);
|
2010-01-05 20:29:15 +01:00
|
|
|
is_default_version = true;
|
2008-07-24 01:44:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2008-04-19 20:30:58 +02:00
|
|
|
elfcpp::Sym<size, big_endian>* psym = &sym;
|
|
|
|
unsigned char symbuf[sym_size];
|
|
|
|
elfcpp::Sym<size, big_endian> sym2(symbuf);
|
2008-02-07 02:51:25 +01:00
|
|
|
if (just_symbols)
|
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
memcpy(symbuf, p, sym_size);
|
2008-02-07 02:51:25 +01:00
|
|
|
elfcpp::Sym_write<size, big_endian> sw(symbuf);
|
2011-08-01 20:25:22 +02:00
|
|
|
if (orig_st_shndx != elfcpp::SHN_UNDEF
|
|
|
|
&& is_ordinary
|
|
|
|
&& relobj->e_type() == elfcpp::ET_REL)
|
2008-02-07 02:51:25 +01:00
|
|
|
{
|
2011-08-01 20:25:22 +02:00
|
|
|
// Symbol values in relocatable object files are section
|
|
|
|
// relative. This is normally what we want, but since here
|
|
|
|
// we are converting the symbol to absolute we need to add
|
|
|
|
// the section address. The section address in an object
|
2008-02-07 02:51:25 +01:00
|
|
|
// file is normally zero, but people can use a linker
|
|
|
|
// script to change it.
|
2008-04-19 20:30:58 +02:00
|
|
|
sw.put_st_value(sym.get_st_value()
|
|
|
|
+ relobj->section_address(orig_st_shndx));
|
2008-02-07 02:51:25 +01:00
|
|
|
}
|
2008-04-19 20:30:58 +02:00
|
|
|
st_shndx = elfcpp::SHN_ABS;
|
|
|
|
is_ordinary = false;
|
2008-02-07 02:51:25 +01:00
|
|
|
psym = &sym2;
|
|
|
|
}
|
|
|
|
|
2009-05-20 00:14:17 +02:00
|
|
|
// Fix up visibility if object has no-export set.
|
2009-12-31 02:14:34 +01:00
|
|
|
if (relobj->no_export()
|
|
|
|
&& (orig_st_shndx != elfcpp::SHN_UNDEF || !is_ordinary))
|
2009-05-20 00:14:17 +02:00
|
|
|
{
|
|
|
|
// We may have copied symbol already above.
|
|
|
|
if (psym != &sym2)
|
|
|
|
{
|
|
|
|
memcpy(symbuf, p, sym_size);
|
|
|
|
psym = &sym2;
|
|
|
|
}
|
|
|
|
|
|
|
|
elfcpp::STV visibility = sym2.get_st_visibility();
|
|
|
|
if (visibility == elfcpp::STV_DEFAULT
|
|
|
|
|| visibility == elfcpp::STV_PROTECTED)
|
|
|
|
{
|
|
|
|
elfcpp::Sym_write<size, big_endian> sw(symbuf);
|
|
|
|
unsigned char nonvis = sym2.get_st_nonvis();
|
|
|
|
sw.put_st_other(elfcpp::STV_HIDDEN, nonvis);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-24 01:44:02 +02:00
|
|
|
Stringpool::Key name_key;
|
2009-12-14 20:53:05 +01:00
|
|
|
name = this->namepool_.add_with_length(name, namelen, true,
|
2008-07-24 01:44:02 +02:00
|
|
|
&name_key);
|
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
Sized_symbol<size>* res;
|
2009-12-14 20:53:05 +01:00
|
|
|
res = this->add_from_object(relobj, name, name_key, ver, ver_key,
|
2010-01-05 20:29:15 +01:00
|
|
|
is_default_version, *psym, st_shndx,
|
|
|
|
is_ordinary, orig_st_shndx);
|
2016-08-10 18:58:01 +02:00
|
|
|
|
|
|
|
if (res == NULL)
|
|
|
|
continue;
|
2009-01-28 03:25:33 +01:00
|
|
|
|
2011-07-23 00:38:42 +02:00
|
|
|
if (is_forced_local)
|
|
|
|
this->force_local(res);
|
|
|
|
|
2011-10-31 22:36:54 +01:00
|
|
|
// Do not treat this symbol as garbage if this symbol will be
|
|
|
|
// exported to the dynamic symbol table. This is true when
|
|
|
|
// building a shared library or using --export-dynamic and
|
|
|
|
// the symbol is externally visible.
|
|
|
|
if (parameters->options().gc_sections()
|
|
|
|
&& res->is_externally_visible()
|
|
|
|
&& !res->is_from_dynobj()
|
|
|
|
&& (parameters->options().shared()
|
2014-02-05 23:01:52 +01:00
|
|
|
|| parameters->options().export_dynamic()
|
|
|
|
|| parameters->options().in_dynamic_list(res->name())))
|
2011-10-31 22:36:54 +01:00
|
|
|
this->gc_mark_symbol(res);
|
2006-11-07 05:40:46 +01:00
|
|
|
|
2010-01-09 01:13:48 +01:00
|
|
|
if (is_defined_in_discarded_section)
|
|
|
|
res->set_is_defined_in_discarded_section();
|
|
|
|
|
2007-11-09 08:00:15 +01:00
|
|
|
(*sympointers)[i] = res;
|
2006-08-19 00:29:20 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-20 00:54:57 +02:00
|
|
|
// Add a symbol from a plugin-claimed file.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
Symbol*
|
|
|
|
Symbol_table::add_from_pluginobj(
|
|
|
|
Sized_pluginobj<size, big_endian>* obj,
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* name,
|
2008-09-20 00:54:57 +02:00
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<size, big_endian>* sym)
|
|
|
|
{
|
|
|
|
unsigned int st_shndx = sym->get_st_shndx();
|
2009-10-28 01:32:12 +01:00
|
|
|
bool is_ordinary = st_shndx < elfcpp::SHN_LORESERVE;
|
2008-09-20 00:54:57 +02:00
|
|
|
|
|
|
|
Stringpool::Key ver_key = 0;
|
2010-01-05 20:29:15 +01:00
|
|
|
bool is_default_version = false;
|
|
|
|
bool is_forced_local = false;
|
2008-09-20 00:54:57 +02:00
|
|
|
|
|
|
|
if (ver != NULL)
|
|
|
|
{
|
|
|
|
ver = this->namepool_.add(ver, true, &ver_key);
|
|
|
|
}
|
|
|
|
// We don't want to assign a version to an undefined symbol,
|
|
|
|
// even if it is listed in the version script. FIXME: What
|
|
|
|
// about a common symbol?
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!this->version_script_.empty()
|
|
|
|
&& st_shndx != elfcpp::SHN_UNDEF)
|
|
|
|
{
|
|
|
|
// The symbol name did not have a version, but the
|
|
|
|
// version script may assign a version anyway.
|
2009-12-14 20:53:05 +01:00
|
|
|
std::string version;
|
* script.cc (class Lazy_demangler): Recreate--revert part of patch
of 2009-12-30.
(Version_script_info::Version_script_info): Initialize globs_,
default_version_, default_is_global_, and exact_. Don't
initialize globals_ or locals_.
(Version_script_info::build_lookup_tables): Build local symbols
first.
(Version_script_info::unquote): New function.
(Version_script_info::add_exact_match): New function.
(Version_script_info::build_expression_list_lookup): Remove lookup
parameter. Add is_global parameter. Change all callers. Handle
wildcard pattern specially. Unquote pattern. Call
add_exact_match.
(Version_script_info::get_name_to_match): New function.
(Version_script_info::get_symbol_version): New function.
(Version_script_info::get_symbol_version_helper): Remove.
(Version_script_info::check_unmatched_names): Call unquote.
* script.h (class Version_script_info): Change get_symbol_version
to be non-inline and add is_global parameter; change all callers.
Rewrite symbol_is_local. Update declarations. Define struct
Version_tree_match, Exact, Globs. Don't define struct Lookup.
Remove globals_ and locals_ members. Add exact_, globs_,
default_version_, is_global_.
(Version_script_info::Glob): Remove pattern, add expression and
is_global. Update constructor. Change all callers.
* dynobj.cc (Versions::finalize): Mark the version symbol as the
default version.
(Versions::symbol_section_contents): If a symbol is undefined, or
defined in a dynamic object, set the version index to
VER_NDX_LOCAL.
* symtab.cc (Symbol_table::add_from_relobj): Don't call
symbol_is_local.
(Symbol_table::add_from_pluginobj): Likewise.
* testsuite/ver_matching_test.sh: blaza1 and blaza go into V2.
2010-01-12 07:41:36 +01:00
|
|
|
bool is_global;
|
|
|
|
if (this->version_script_.get_symbol_version(name, &version,
|
|
|
|
&is_global))
|
2008-09-20 00:54:57 +02:00
|
|
|
{
|
* script.cc (class Lazy_demangler): Recreate--revert part of patch
of 2009-12-30.
(Version_script_info::Version_script_info): Initialize globs_,
default_version_, default_is_global_, and exact_. Don't
initialize globals_ or locals_.
(Version_script_info::build_lookup_tables): Build local symbols
first.
(Version_script_info::unquote): New function.
(Version_script_info::add_exact_match): New function.
(Version_script_info::build_expression_list_lookup): Remove lookup
parameter. Add is_global parameter. Change all callers. Handle
wildcard pattern specially. Unquote pattern. Call
add_exact_match.
(Version_script_info::get_name_to_match): New function.
(Version_script_info::get_symbol_version): New function.
(Version_script_info::get_symbol_version_helper): Remove.
(Version_script_info::check_unmatched_names): Call unquote.
* script.h (class Version_script_info): Change get_symbol_version
to be non-inline and add is_global parameter; change all callers.
Rewrite symbol_is_local. Update declarations. Define struct
Version_tree_match, Exact, Globs. Don't define struct Lookup.
Remove globals_ and locals_ members. Add exact_, globs_,
default_version_, is_global_.
(Version_script_info::Glob): Remove pattern, add expression and
is_global. Update constructor. Change all callers.
* dynobj.cc (Versions::finalize): Mark the version symbol as the
default version.
(Versions::symbol_section_contents): If a symbol is undefined, or
defined in a dynamic object, set the version index to
VER_NDX_LOCAL.
* symtab.cc (Symbol_table::add_from_relobj): Don't call
symbol_is_local.
(Symbol_table::add_from_pluginobj): Likewise.
* testsuite/ver_matching_test.sh: blaza1 and blaza go into V2.
2010-01-12 07:41:36 +01:00
|
|
|
if (!is_global)
|
|
|
|
is_forced_local = true;
|
|
|
|
else if (!version.empty())
|
2008-09-20 00:54:57 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
ver = this->namepool_.add_with_length(version.c_str(),
|
|
|
|
version.length(),
|
2008-09-20 00:54:57 +02:00
|
|
|
true,
|
|
|
|
&ver_key);
|
2010-01-05 20:29:15 +01:00
|
|
|
is_default_version = true;
|
2008-09-20 00:54:57 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Stringpool::Key name_key;
|
2009-12-14 20:53:05 +01:00
|
|
|
name = this->namepool_.add(name, true, &name_key);
|
2008-09-20 00:54:57 +02:00
|
|
|
|
|
|
|
Sized_symbol<size>* res;
|
2009-12-14 20:53:05 +01:00
|
|
|
res = this->add_from_object(obj, name, name_key, ver, ver_key,
|
2010-01-05 20:29:15 +01:00
|
|
|
is_default_version, *sym, st_shndx,
|
|
|
|
is_ordinary, st_shndx);
|
2008-09-20 00:54:57 +02:00
|
|
|
|
2016-08-10 18:58:01 +02:00
|
|
|
if (res == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2010-01-05 20:29:15 +01:00
|
|
|
if (is_forced_local)
|
2009-02-27 20:57:46 +01:00
|
|
|
this->force_local(res);
|
2008-09-20 00:54:57 +02:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2006-11-14 20:21:05 +01:00
|
|
|
// Add all the symbols in a dynamic object to the hash table.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
|
|
|
Symbol_table::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*>* version_map,
|
2011-05-24 23:41:10 +02:00
|
|
|
typename Sized_relobj_file<size, big_endian>::Symbols* sympointers,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined)
|
2006-11-14 20:21:05 +01:00
|
|
|
{
|
2008-07-23 00:08:43 +02:00
|
|
|
*defined = 0;
|
|
|
|
|
2008-02-28 01:18:24 +01:00
|
|
|
gold_assert(size == parameters->target().get_size());
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2008-02-07 02:51:25 +01:00
|
|
|
if (dynobj->just_symbols())
|
|
|
|
{
|
|
|
|
gold_error(_("--just-symbols does not make sense with a shared object"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-09-29 19:04:36 +02:00
|
|
|
// FIXME: For incremental links, we don't store version information,
|
|
|
|
// so we need to ignore version symbols for now.
|
|
|
|
if (parameters->incremental_update())
|
|
|
|
versym = NULL;
|
|
|
|
|
2006-11-14 20:21:05 +01:00
|
|
|
if (versym != NULL && versym_size / 2 < count)
|
|
|
|
{
|
2007-10-14 08:49:14 +02:00
|
|
|
dynobj->error(_("too few symbol versions"));
|
|
|
|
return;
|
2006-11-14 20:21:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
|
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// We keep a list of all STT_OBJECT symbols, so that we can resolve
|
|
|
|
// weak aliases. This is necessary because if the dynamic object
|
|
|
|
// provides the same variable under two names, one of which is a
|
|
|
|
// weak definition, and the regular object refers to the weak
|
|
|
|
// definition, we have to put both the weak definition and the
|
|
|
|
// strong definition into the dynamic symbol table. Given a weak
|
|
|
|
// definition, the only way that we can find the corresponding
|
|
|
|
// strong definition, if any, is to search the symbol table.
|
|
|
|
std::vector<Sized_symbol<size>*> object_symbols;
|
|
|
|
|
2006-11-14 20:21:05 +01:00
|
|
|
const unsigned char* p = syms;
|
|
|
|
const unsigned char* vs = versym;
|
|
|
|
for (size_t i = 0; i < count; ++i, p += sym_size, vs += 2)
|
|
|
|
{
|
|
|
|
elfcpp::Sym<size, big_endian> sym(p);
|
|
|
|
|
2008-07-23 00:08:43 +02:00
|
|
|
if (sympointers != NULL)
|
|
|
|
(*sympointers)[i] = NULL;
|
|
|
|
|
2008-02-01 01:42:24 +01:00
|
|
|
// Ignore symbols with local binding or that have
|
|
|
|
// internal or hidden visibility.
|
|
|
|
if (sym.get_st_bind() == elfcpp::STB_LOCAL
|
|
|
|
|| sym.get_st_visibility() == elfcpp::STV_INTERNAL
|
|
|
|
|| sym.get_st_visibility() == elfcpp::STV_HIDDEN)
|
2006-11-14 20:21:05 +01:00
|
|
|
continue;
|
|
|
|
|
2008-05-07 00:24:26 +02:00
|
|
|
// A protected symbol in a shared library must be treated as a
|
|
|
|
// normal symbol when viewed from outside the shared library.
|
|
|
|
// Implement this by overriding the visibility here.
|
2015-09-07 18:44:11 +02:00
|
|
|
// Likewise, an IFUNC symbol in a shared library must be treated
|
|
|
|
// as a normal FUNC symbol.
|
2008-05-07 00:24:26 +02:00
|
|
|
elfcpp::Sym<size, big_endian>* psym = &sym;
|
|
|
|
unsigned char symbuf[sym_size];
|
|
|
|
elfcpp::Sym<size, big_endian> sym2(symbuf);
|
2015-09-07 18:44:11 +02:00
|
|
|
if (sym.get_st_visibility() == elfcpp::STV_PROTECTED
|
|
|
|
|| sym.get_st_type() == elfcpp::STT_GNU_IFUNC)
|
2008-05-07 00:24:26 +02:00
|
|
|
{
|
|
|
|
memcpy(symbuf, p, sym_size);
|
|
|
|
elfcpp::Sym_write<size, big_endian> sw(symbuf);
|
2015-09-07 18:44:11 +02:00
|
|
|
if (sym.get_st_visibility() == elfcpp::STV_PROTECTED)
|
|
|
|
sw.put_st_other(elfcpp::STV_DEFAULT, sym.get_st_nonvis());
|
|
|
|
if (sym.get_st_type() == elfcpp::STT_GNU_IFUNC)
|
|
|
|
sw.put_st_info(sym.get_st_bind(), elfcpp::STT_FUNC);
|
2008-05-07 00:24:26 +02:00
|
|
|
psym = &sym2;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int st_name = psym->get_st_name();
|
2006-11-14 20:21:05 +01:00
|
|
|
if (st_name >= sym_name_size)
|
|
|
|
{
|
2007-10-14 08:49:14 +02:00
|
|
|
dynobj->error(_("bad symbol name offset %u at %zu"),
|
|
|
|
st_name, i);
|
|
|
|
continue;
|
2006-11-14 20:21:05 +01:00
|
|
|
}
|
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* name = sym_names + st_name;
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
2008-05-07 00:24:26 +02:00
|
|
|
unsigned int st_shndx = dynobj->adjust_sym_shndx(i, psym->get_st_shndx(),
|
2008-04-19 20:30:58 +02:00
|
|
|
&is_ordinary);
|
|
|
|
|
2008-07-23 00:08:43 +02:00
|
|
|
if (st_shndx != elfcpp::SHN_UNDEF)
|
|
|
|
++*defined;
|
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
Sized_symbol<size>* res;
|
|
|
|
|
2006-11-14 20:21:05 +01:00
|
|
|
if (versym == NULL)
|
|
|
|
{
|
|
|
|
Stringpool::Key name_key;
|
2009-12-14 20:53:05 +01:00
|
|
|
name = this->namepool_.add(name, true, &name_key);
|
|
|
|
res = this->add_from_object(dynobj, name, name_key, NULL, 0,
|
2008-05-07 00:24:26 +02:00
|
|
|
false, *psym, st_shndx, is_ordinary,
|
2008-04-19 20:30:58 +02:00
|
|
|
st_shndx);
|
2006-11-14 20:21:05 +01:00
|
|
|
}
|
2007-10-14 17:35:27 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// Read the version information.
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
unsigned int v = elfcpp::Swap<16, big_endian>::readval(vs);
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
bool hidden = (v & elfcpp::VERSYM_HIDDEN) != 0;
|
|
|
|
v &= elfcpp::VERSYM_VERSION;
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// The Sun documentation says that V can be VER_NDX_LOCAL,
|
|
|
|
// or VER_NDX_GLOBAL, or a version index. The meaning of
|
|
|
|
// VER_NDX_LOCAL is defined as "Symbol has local scope."
|
|
|
|
// The old GNU linker will happily generate VER_NDX_LOCAL
|
|
|
|
// for an undefined symbol. I don't know what the Sun
|
|
|
|
// linker will generate.
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
|
2008-04-19 20:30:58 +02:00
|
|
|
&& st_shndx != elfcpp::SHN_UNDEF)
|
2007-10-14 17:35:27 +02:00
|
|
|
{
|
|
|
|
// This symbol should not be visible outside the object.
|
|
|
|
continue;
|
|
|
|
}
|
2007-09-04 19:59:53 +02:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// At this point we are definitely going to add this symbol.
|
|
|
|
Stringpool::Key name_key;
|
2009-12-14 20:53:05 +01:00
|
|
|
name = this->namepool_.add(name, true, &name_key);
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
|
|
|
|
|| v == static_cast<unsigned int>(elfcpp::VER_NDX_GLOBAL))
|
|
|
|
{
|
|
|
|
// This symbol does not have a version.
|
2009-12-14 20:53:05 +01:00
|
|
|
res = this->add_from_object(dynobj, name, name_key, NULL, 0,
|
2008-05-07 00:24:26 +02:00
|
|
|
false, *psym, st_shndx, is_ordinary,
|
2008-04-19 20:30:58 +02:00
|
|
|
st_shndx);
|
2007-10-14 17:35:27 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (v >= version_map->size())
|
|
|
|
{
|
|
|
|
dynobj->error(_("versym for symbol %zu out of range: %u"),
|
|
|
|
i, v);
|
|
|
|
continue;
|
|
|
|
}
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* version = (*version_map)[v];
|
|
|
|
if (version == NULL)
|
2007-10-14 17:35:27 +02:00
|
|
|
{
|
|
|
|
dynobj->error(_("versym for symbol %zu has no name: %u"),
|
|
|
|
i, v);
|
|
|
|
continue;
|
|
|
|
}
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
Stringpool::Key version_key;
|
2009-12-14 20:53:05 +01:00
|
|
|
version = this->namepool_.add(version, true, &version_key);
|
2007-10-14 17:35:27 +02:00
|
|
|
|
|
|
|
// If this is an absolute symbol, and the version name
|
|
|
|
// and symbol name are the same, then this is the
|
|
|
|
// version definition symbol. These symbols exist to
|
|
|
|
// support using -u to pull in particular versions. We
|
|
|
|
// do not want to record a version for them.
|
2008-04-19 20:30:58 +02:00
|
|
|
if (st_shndx == elfcpp::SHN_ABS
|
|
|
|
&& !is_ordinary
|
2007-10-14 17:35:27 +02:00
|
|
|
&& name_key == version_key)
|
2009-12-14 20:53:05 +01:00
|
|
|
res = this->add_from_object(dynobj, name, name_key, NULL, 0,
|
2008-05-07 00:24:26 +02:00
|
|
|
false, *psym, st_shndx, is_ordinary,
|
2008-04-19 20:30:58 +02:00
|
|
|
st_shndx);
|
2007-10-14 17:35:27 +02:00
|
|
|
else
|
|
|
|
{
|
2010-01-05 20:29:15 +01:00
|
|
|
const bool is_default_version =
|
|
|
|
!hidden && st_shndx != elfcpp::SHN_UNDEF;
|
2009-12-14 20:53:05 +01:00
|
|
|
res = this->add_from_object(dynobj, name, name_key, version,
|
2010-01-05 20:29:15 +01:00
|
|
|
version_key, is_default_version,
|
|
|
|
*psym, st_shndx,
|
2008-04-19 20:30:58 +02:00
|
|
|
is_ordinary, st_shndx);
|
2007-10-14 17:35:27 +02:00
|
|
|
}
|
|
|
|
}
|
2006-11-14 20:21:05 +01:00
|
|
|
}
|
|
|
|
|
2016-08-10 18:58:01 +02:00
|
|
|
if (res == NULL)
|
|
|
|
continue;
|
|
|
|
|
2008-04-10 00:45:08 +02:00
|
|
|
// Note that it is possible that RES was overridden by an
|
2008-04-10 02:58:58 +02:00
|
|
|
// earlier object, in which case it can't be aliased here.
|
2008-04-19 20:30:58 +02:00
|
|
|
if (st_shndx != elfcpp::SHN_UNDEF
|
|
|
|
&& is_ordinary
|
2008-05-07 00:24:26 +02:00
|
|
|
&& psym->get_st_type() == elfcpp::STT_OBJECT
|
2008-04-10 00:45:08 +02:00
|
|
|
&& res->source() == Symbol::FROM_OBJECT
|
|
|
|
&& res->object() == dynobj)
|
2007-10-14 17:35:27 +02:00
|
|
|
object_symbols.push_back(res);
|
2008-07-23 00:08:43 +02:00
|
|
|
|
2016-05-19 23:58:18 +02:00
|
|
|
// If the symbol has protected visibility in the dynobj,
|
|
|
|
// mark it as such if it was not overridden.
|
|
|
|
if (res->source() == Symbol::FROM_OBJECT
|
|
|
|
&& res->object() == dynobj
|
|
|
|
&& sym.get_st_visibility() == elfcpp::STV_PROTECTED)
|
|
|
|
res->set_is_protected();
|
|
|
|
|
2008-07-23 00:08:43 +02:00
|
|
|
if (sympointers != NULL)
|
|
|
|
(*sympointers)[i] = res;
|
2007-10-14 17:35:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
this->record_weak_aliases(&object_symbols);
|
|
|
|
}
|
|
|
|
|
2011-04-12 02:44:48 +02:00
|
|
|
// Add a symbol from a incremental object file.
|
|
|
|
|
|
|
|
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
|
|
|
Symbol_table::add_from_incrobj(
|
|
|
|
Object* obj,
|
|
|
|
const char* name,
|
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<size, big_endian>* sym)
|
|
|
|
{
|
|
|
|
unsigned int st_shndx = sym->get_st_shndx();
|
|
|
|
bool is_ordinary = st_shndx < elfcpp::SHN_LORESERVE;
|
|
|
|
|
|
|
|
Stringpool::Key ver_key = 0;
|
|
|
|
bool is_default_version = false;
|
|
|
|
|
|
|
|
Stringpool::Key name_key;
|
|
|
|
name = this->namepool_.add(name, true, &name_key);
|
|
|
|
|
|
|
|
Sized_symbol<size>* res;
|
|
|
|
res = this->add_from_object(obj, name, name_key, ver, ver_key,
|
|
|
|
is_default_version, *sym, st_shndx,
|
|
|
|
is_ordinary, st_shndx);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// This is used to sort weak aliases. We sort them first by section
|
|
|
|
// index, then by offset, then by weak ahead of strong.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
class Weak_alias_sorter
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
bool operator()(const Sized_symbol<size>*, const Sized_symbol<size>*) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
bool
|
|
|
|
Weak_alias_sorter<size>::operator()(const Sized_symbol<size>* s1,
|
|
|
|
const Sized_symbol<size>* s2) const
|
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
|
|
|
unsigned int s1_shndx = s1->shndx(&is_ordinary);
|
|
|
|
gold_assert(is_ordinary);
|
|
|
|
unsigned int s2_shndx = s2->shndx(&is_ordinary);
|
|
|
|
gold_assert(is_ordinary);
|
|
|
|
if (s1_shndx != s2_shndx)
|
|
|
|
return s1_shndx < s2_shndx;
|
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
if (s1->value() != s2->value())
|
|
|
|
return s1->value() < s2->value();
|
|
|
|
if (s1->binding() != s2->binding())
|
|
|
|
{
|
|
|
|
if (s1->binding() == elfcpp::STB_WEAK)
|
|
|
|
return true;
|
|
|
|
if (s2->binding() == elfcpp::STB_WEAK)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return std::string(s1->name()) < std::string(s2->name());
|
|
|
|
}
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
// SYMBOLS is a list of object symbols from a dynamic object. Look
|
|
|
|
// for any weak aliases, and record them so that if we add the weak
|
|
|
|
// alias to the dynamic symbol table, we also add the corresponding
|
|
|
|
// strong symbol.
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
template<int size>
|
|
|
|
void
|
|
|
|
Symbol_table::record_weak_aliases(std::vector<Sized_symbol<size>*>* symbols)
|
|
|
|
{
|
|
|
|
// Sort the vector by section index, then by offset, then by weak
|
|
|
|
// ahead of strong.
|
|
|
|
std::sort(symbols->begin(), symbols->end(), Weak_alias_sorter<size>());
|
|
|
|
|
|
|
|
// Walk through the vector. For each weak definition, record
|
|
|
|
// aliases.
|
|
|
|
for (typename std::vector<Sized_symbol<size>*>::const_iterator p =
|
|
|
|
symbols->begin();
|
|
|
|
p != symbols->end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
if ((*p)->binding() != elfcpp::STB_WEAK)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Build a circular list of weak aliases. Each symbol points to
|
|
|
|
// the next one in the circular list.
|
|
|
|
|
|
|
|
Sized_symbol<size>* from_sym = *p;
|
|
|
|
typename std::vector<Sized_symbol<size>*>::const_iterator q;
|
|
|
|
for (q = p + 1; q != symbols->end(); ++q)
|
2006-11-14 20:21:05 +01:00
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
bool dummy;
|
|
|
|
if ((*q)->shndx(&dummy) != from_sym->shndx(&dummy)
|
2007-10-14 17:35:27 +02:00
|
|
|
|| (*q)->value() != from_sym->value())
|
|
|
|
break;
|
|
|
|
|
|
|
|
this->weak_aliases_[from_sym] = *q;
|
|
|
|
from_sym->set_has_alias();
|
|
|
|
from_sym = *q;
|
2006-11-14 20:21:05 +01:00
|
|
|
}
|
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
if (from_sym != *p)
|
|
|
|
{
|
|
|
|
this->weak_aliases_[from_sym] = *p;
|
|
|
|
from_sym->set_has_alias();
|
|
|
|
}
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-10-14 17:35:27 +02:00
|
|
|
p = q - 1;
|
2006-11-14 20:21:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Create and return a specially defined symbol. If ONLY_IF_REF is
|
|
|
|
// true, then only create the symbol if there is a reference to it.
|
2007-09-19 08:02:29 +02:00
|
|
|
// If this does not return NULL, it sets *POLDSYM to the existing
|
2009-03-17 08:07:21 +01:00
|
|
|
// symbol if there is one. This sets *RESOLVE_OLDSYM if we should
|
|
|
|
// resolve the newly created symbol to the old one. This
|
|
|
|
// canonicalizes *PNAME and *PVERSION.
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
Sized_symbol<size>*
|
2008-01-26 02:17:45 +01:00
|
|
|
Symbol_table::define_special_symbol(const char** pname, const char** pversion,
|
|
|
|
bool only_if_ref,
|
2017-11-09 00:56:54 +01:00
|
|
|
elfcpp::STV visibility,
|
2009-03-17 08:07:21 +01:00
|
|
|
Sized_symbol<size>** poldsym,
|
2016-12-22 02:32:39 +01:00
|
|
|
bool* resolve_oldsym, bool is_forced_local)
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2009-03-17 08:07:21 +01:00
|
|
|
*resolve_oldsym = false;
|
2012-05-26 00:53:52 +02:00
|
|
|
*poldsym = NULL;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
// If the caller didn't give us a version, see if we get one from
|
|
|
|
// the version script.
|
2008-07-24 01:44:02 +02:00
|
|
|
std::string v;
|
2009-03-17 08:07:21 +01:00
|
|
|
bool is_default_version = false;
|
2016-12-22 02:32:39 +01:00
|
|
|
if (!is_forced_local && *pversion == NULL)
|
2008-01-24 01:15:00 +01:00
|
|
|
{
|
* script.cc (class Lazy_demangler): Recreate--revert part of patch
of 2009-12-30.
(Version_script_info::Version_script_info): Initialize globs_,
default_version_, default_is_global_, and exact_. Don't
initialize globals_ or locals_.
(Version_script_info::build_lookup_tables): Build local symbols
first.
(Version_script_info::unquote): New function.
(Version_script_info::add_exact_match): New function.
(Version_script_info::build_expression_list_lookup): Remove lookup
parameter. Add is_global parameter. Change all callers. Handle
wildcard pattern specially. Unquote pattern. Call
add_exact_match.
(Version_script_info::get_name_to_match): New function.
(Version_script_info::get_symbol_version): New function.
(Version_script_info::get_symbol_version_helper): Remove.
(Version_script_info::check_unmatched_names): Call unquote.
* script.h (class Version_script_info): Change get_symbol_version
to be non-inline and add is_global parameter; change all callers.
Rewrite symbol_is_local. Update declarations. Define struct
Version_tree_match, Exact, Globs. Don't define struct Lookup.
Remove globals_ and locals_ members. Add exact_, globs_,
default_version_, is_global_.
(Version_script_info::Glob): Remove pattern, add expression and
is_global. Update constructor. Change all callers.
* dynobj.cc (Versions::finalize): Mark the version symbol as the
default version.
(Versions::symbol_section_contents): If a symbol is undefined, or
defined in a dynamic object, set the version index to
VER_NDX_LOCAL.
* symtab.cc (Symbol_table::add_from_relobj): Don't call
symbol_is_local.
(Symbol_table::add_from_pluginobj): Likewise.
* testsuite/ver_matching_test.sh: blaza1 and blaza go into V2.
2010-01-12 07:41:36 +01:00
|
|
|
bool is_global;
|
|
|
|
if (this->version_script_.get_symbol_version(*pname, &v, &is_global))
|
2008-07-24 01:44:02 +02:00
|
|
|
{
|
* script.cc (class Lazy_demangler): Recreate--revert part of patch
of 2009-12-30.
(Version_script_info::Version_script_info): Initialize globs_,
default_version_, default_is_global_, and exact_. Don't
initialize globals_ or locals_.
(Version_script_info::build_lookup_tables): Build local symbols
first.
(Version_script_info::unquote): New function.
(Version_script_info::add_exact_match): New function.
(Version_script_info::build_expression_list_lookup): Remove lookup
parameter. Add is_global parameter. Change all callers. Handle
wildcard pattern specially. Unquote pattern. Call
add_exact_match.
(Version_script_info::get_name_to_match): New function.
(Version_script_info::get_symbol_version): New function.
(Version_script_info::get_symbol_version_helper): Remove.
(Version_script_info::check_unmatched_names): Call unquote.
* script.h (class Version_script_info): Change get_symbol_version
to be non-inline and add is_global parameter; change all callers.
Rewrite symbol_is_local. Update declarations. Define struct
Version_tree_match, Exact, Globs. Don't define struct Lookup.
Remove globals_ and locals_ members. Add exact_, globs_,
default_version_, is_global_.
(Version_script_info::Glob): Remove pattern, add expression and
is_global. Update constructor. Change all callers.
* dynobj.cc (Versions::finalize): Mark the version symbol as the
default version.
(Versions::symbol_section_contents): If a symbol is undefined, or
defined in a dynamic object, set the version index to
VER_NDX_LOCAL.
* symtab.cc (Symbol_table::add_from_relobj): Don't call
symbol_is_local.
(Symbol_table::add_from_pluginobj): Likewise.
* testsuite/ver_matching_test.sh: blaza1 and blaza go into V2.
2010-01-12 07:41:36 +01:00
|
|
|
if (is_global && !v.empty())
|
|
|
|
{
|
|
|
|
*pversion = v.c_str();
|
|
|
|
// If we get the version from a version script, then we
|
|
|
|
// are also the default version.
|
|
|
|
is_default_version = true;
|
|
|
|
}
|
2008-07-24 01:44:02 +02:00
|
|
|
}
|
2008-01-24 01:15:00 +01:00
|
|
|
}
|
|
|
|
|
2009-03-17 08:07:21 +01:00
|
|
|
Symbol* oldsym;
|
|
|
|
Sized_symbol<size>* sym;
|
|
|
|
|
|
|
|
bool add_to_table = false;
|
|
|
|
typename Symbol_table_type::iterator add_loc = this->table_.end();
|
|
|
|
bool add_def_to_table = false;
|
|
|
|
typename Symbol_table_type::iterator add_def_loc = this->table_.end();
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
if (only_if_ref)
|
|
|
|
{
|
2007-09-22 06:40:13 +02:00
|
|
|
oldsym = this->lookup(*pname, *pversion);
|
2009-03-17 08:07:21 +01:00
|
|
|
if (oldsym == NULL && is_default_version)
|
|
|
|
oldsym = this->lookup(*pname, NULL);
|
2017-11-09 00:56:54 +01:00
|
|
|
if (oldsym == NULL)
|
2006-11-03 19:26:11 +01:00
|
|
|
return NULL;
|
2017-11-09 00:56:54 +01:00
|
|
|
if (!oldsym->is_undefined())
|
|
|
|
{
|
|
|
|
// Skip if the old definition is from a regular object.
|
|
|
|
if (!oldsym->is_from_dynobj())
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
// If the symbol has hidden or internal visibility, ignore
|
|
|
|
// definition and reference from a dynamic object.
|
|
|
|
if ((visibility == elfcpp::STV_HIDDEN
|
|
|
|
|| visibility == elfcpp::STV_INTERNAL)
|
|
|
|
&& !oldsym->in_reg())
|
|
|
|
return NULL;
|
|
|
|
}
|
2007-09-22 06:40:13 +02:00
|
|
|
|
|
|
|
*pname = oldsym->name();
|
2011-09-28 02:55:35 +02:00
|
|
|
if (is_default_version)
|
|
|
|
*pversion = this->namepool_.add(*pversion, true, NULL);
|
|
|
|
else
|
2009-03-17 08:07:21 +01:00
|
|
|
*pversion = oldsym->version();
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2006-12-06 01:02:36 +01:00
|
|
|
// Canonicalize NAME and VERSION.
|
2006-11-07 05:40:46 +01:00
|
|
|
Stringpool::Key name_key;
|
2007-10-12 08:06:34 +02:00
|
|
|
*pname = this->namepool_.add(*pname, true, &name_key);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2006-12-06 01:02:36 +01:00
|
|
|
Stringpool::Key version_key = 0;
|
2007-09-22 06:40:13 +02:00
|
|
|
if (*pversion != NULL)
|
2007-10-12 08:06:34 +02:00
|
|
|
*pversion = this->namepool_.add(*pversion, true, &version_key);
|
2006-12-06 01:02:36 +01:00
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
Symbol* const snull = NULL;
|
|
|
|
std::pair<typename Symbol_table_type::iterator, bool> ins =
|
2006-12-06 01:02:36 +01:00
|
|
|
this->table_.insert(std::make_pair(std::make_pair(name_key,
|
|
|
|
version_key),
|
2006-11-03 19:26:11 +01:00
|
|
|
snull));
|
|
|
|
|
2010-01-05 20:29:15 +01:00
|
|
|
std::pair<typename Symbol_table_type::iterator, bool> insdefault =
|
2009-03-17 08:07:21 +01:00
|
|
|
std::make_pair(this->table_.end(), false);
|
|
|
|
if (is_default_version)
|
|
|
|
{
|
|
|
|
const Stringpool::Key vnull = 0;
|
2010-01-05 20:29:15 +01:00
|
|
|
insdefault =
|
|
|
|
this->table_.insert(std::make_pair(std::make_pair(name_key,
|
|
|
|
vnull),
|
|
|
|
snull));
|
2009-03-17 08:07:21 +01:00
|
|
|
}
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
if (!ins.second)
|
|
|
|
{
|
2006-12-06 01:02:36 +01:00
|
|
|
// We already have a symbol table entry for NAME/VERSION.
|
2006-11-03 19:26:11 +01:00
|
|
|
oldsym = ins.first->second;
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(oldsym != NULL);
|
2009-03-17 08:07:21 +01:00
|
|
|
|
|
|
|
if (is_default_version)
|
|
|
|
{
|
|
|
|
Sized_symbol<size>* soldsym =
|
|
|
|
this->get_sized_symbol<size>(oldsym);
|
|
|
|
this->define_default_version<size, big_endian>(soldsym,
|
2010-01-05 20:29:15 +01:00
|
|
|
insdefault.second,
|
|
|
|
insdefault.first);
|
2009-03-17 08:07:21 +01:00
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// We haven't seen this symbol before.
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(ins.first->second == NULL);
|
2009-03-17 08:07:21 +01:00
|
|
|
|
|
|
|
add_to_table = true;
|
|
|
|
add_loc = ins.first;
|
|
|
|
|
2018-07-14 21:29:03 +02:00
|
|
|
if (is_default_version
|
|
|
|
&& !insdefault.second
|
|
|
|
&& insdefault.first->second->version() == NULL)
|
2009-03-17 08:07:21 +01:00
|
|
|
{
|
|
|
|
// We are adding NAME/VERSION, and it is the default
|
2018-07-14 21:29:03 +02:00
|
|
|
// version. We already have an entry for NAME/NULL
|
|
|
|
// that does not already have a version.
|
2010-01-05 20:29:15 +01:00
|
|
|
oldsym = insdefault.first->second;
|
2009-03-17 08:07:21 +01:00
|
|
|
*resolve_oldsym = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
oldsym = NULL;
|
|
|
|
|
|
|
|
if (is_default_version)
|
|
|
|
{
|
|
|
|
add_def_to_table = true;
|
2010-01-05 20:29:15 +01:00
|
|
|
add_def_loc = insdefault.first;
|
2009-03-17 08:07:21 +01:00
|
|
|
}
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-28 01:18:24 +01:00
|
|
|
const Target& target = parameters->target();
|
|
|
|
if (!target.has_make_symbol())
|
2007-09-19 08:02:29 +02:00
|
|
|
sym = new Sized_symbol<size>();
|
|
|
|
else
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2009-10-01 00:21:13 +02:00
|
|
|
Sized_target<size, big_endian>* sized_target =
|
|
|
|
parameters->sized_target<size, big_endian>();
|
2016-02-05 01:55:39 +01:00
|
|
|
sym = sized_target->make_symbol(*pname, elfcpp::STT_NOTYPE,
|
|
|
|
NULL, elfcpp::SHN_UNDEF, 0);
|
2007-09-19 08:02:29 +02:00
|
|
|
if (sym == NULL)
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2007-09-19 08:02:29 +02:00
|
|
|
if (add_to_table)
|
|
|
|
add_loc->second = sym;
|
|
|
|
else
|
|
|
|
gold_assert(oldsym != NULL);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2009-03-17 08:07:21 +01:00
|
|
|
if (add_def_to_table)
|
|
|
|
add_def_loc->second = sym;
|
|
|
|
|
2008-02-29 20:19:17 +01:00
|
|
|
*poldsym = this->get_sized_symbol<size>(oldsym);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
return sym;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Define a symbol based on an Output_data.
|
|
|
|
|
2006-12-06 01:02:36 +01:00
|
|
|
Symbol*
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol_table::define_in_output_data(const char* name,
|
|
|
|
const char* version,
|
2009-12-29 01:31:48 +01:00
|
|
|
Defined defined,
|
2008-01-26 02:17:45 +01:00
|
|
|
Output_data* od,
|
2009-12-14 20:53:05 +01:00
|
|
|
uint64_t value,
|
|
|
|
uint64_t symsize,
|
2008-01-26 02:17:45 +01:00
|
|
|
elfcpp::STT type,
|
|
|
|
elfcpp::STB binding,
|
2006-11-03 19:26:11 +01:00
|
|
|
elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis,
|
2009-12-14 20:53:05 +01:00
|
|
|
bool offset_is_from_end,
|
2006-11-03 19:26:11 +01:00
|
|
|
bool only_if_ref)
|
|
|
|
{
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().get_size() == 32)
|
2007-09-19 08:02:29 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
|
2009-12-29 01:31:48 +01:00
|
|
|
return this->do_define_in_output_data<32>(name, version, defined, od,
|
2009-12-14 20:53:05 +01:00
|
|
|
value, symsize, type, binding,
|
2007-09-19 08:02:29 +02:00
|
|
|
visibility, nonvis,
|
2009-12-14 20:53:05 +01:00
|
|
|
offset_is_from_end,
|
2007-09-19 08:02:29 +02:00
|
|
|
only_if_ref);
|
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2008-02-28 01:18:24 +01:00
|
|
|
else if (parameters->target().get_size() == 64)
|
2007-09-19 08:02:29 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
|
2009-12-29 01:31:48 +01:00
|
|
|
return this->do_define_in_output_data<64>(name, version, defined, od,
|
2009-12-14 20:53:05 +01:00
|
|
|
value, symsize, type, binding,
|
2007-09-19 08:02:29 +02:00
|
|
|
visibility, nonvis,
|
2009-12-14 20:53:05 +01:00
|
|
|
offset_is_from_end,
|
2007-09-19 08:02:29 +02:00
|
|
|
only_if_ref);
|
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
else
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_unreachable();
|
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>*
|
2006-11-03 19:26:11 +01:00
|
|
|
Symbol_table::do_define_in_output_data(
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* name,
|
|
|
|
const char* version,
|
2009-12-29 01:31:48 +01:00
|
|
|
Defined defined,
|
2006-11-03 19:26:11 +01:00
|
|
|
Output_data* od,
|
2009-12-14 20:53:05 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_WXword symsize,
|
2006-11-03 19:26:11 +01:00
|
|
|
elfcpp::STT type,
|
|
|
|
elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis,
|
2009-12-14 20:53:05 +01:00
|
|
|
bool offset_is_from_end,
|
2006-11-03 19:26:11 +01:00
|
|
|
bool only_if_ref)
|
|
|
|
{
|
|
|
|
Sized_symbol<size>* sym;
|
2007-09-19 08:02:29 +02:00
|
|
|
Sized_symbol<size>* oldsym;
|
2009-03-17 08:07:21 +01:00
|
|
|
bool resolve_oldsym;
|
2016-12-22 02:32:39 +01:00
|
|
|
const bool is_forced_local = binding == elfcpp::STB_LOCAL;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().is_big_endian())
|
2007-09-04 22:00:53 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
|
2009-12-14 20:53:05 +01:00
|
|
|
sym = this->define_special_symbol<size, true>(&name, &version,
|
2017-11-09 00:56:54 +01:00
|
|
|
only_if_ref,
|
|
|
|
visibility,
|
|
|
|
&oldsym,
|
2016-12-22 02:32:39 +01:00
|
|
|
&resolve_oldsym,
|
|
|
|
is_forced_local);
|
2007-09-04 22:00:53 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
else
|
2007-09-04 22:00:53 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
|
2009-12-14 20:53:05 +01:00
|
|
|
sym = this->define_special_symbol<size, false>(&name, &version,
|
2017-11-09 00:56:54 +01:00
|
|
|
only_if_ref,
|
|
|
|
visibility,
|
|
|
|
&oldsym,
|
2016-12-22 02:32:39 +01:00
|
|
|
&resolve_oldsym,
|
|
|
|
is_forced_local);
|
2007-09-04 22:00:53 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
if (sym == NULL)
|
2006-12-06 01:02:36 +01:00
|
|
|
return NULL;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
sym->init_output_data(name, version, od, value, symsize, type, binding,
|
2011-06-08 06:05:25 +02:00
|
|
|
visibility, nonvis, offset_is_from_end,
|
|
|
|
defined == PREDEFINED);
|
2006-12-06 01:02:36 +01:00
|
|
|
|
2008-01-09 20:57:45 +01:00
|
|
|
if (oldsym == NULL)
|
2008-01-24 01:15:00 +01:00
|
|
|
{
|
2016-12-22 02:32:39 +01:00
|
|
|
if (is_forced_local || this->version_script_.symbol_is_local(name))
|
2008-01-24 01:15:00 +01:00
|
|
|
this->force_local(sym);
|
2009-12-14 20:53:05 +01:00
|
|
|
else if (version != NULL)
|
2008-05-08 20:44:33 +02:00
|
|
|
sym->set_is_default();
|
2008-01-24 01:15:00 +01:00
|
|
|
return sym;
|
|
|
|
}
|
2007-09-19 08:02:29 +02:00
|
|
|
|
2011-07-09 01:49:11 +02:00
|
|
|
if (Symbol_table::should_override_with_special(oldsym, type, defined))
|
2008-01-09 20:57:45 +01:00
|
|
|
this->override_with_special(oldsym, sym);
|
2009-03-17 08:07:21 +01:00
|
|
|
|
|
|
|
if (resolve_oldsym)
|
|
|
|
return sym;
|
|
|
|
else
|
|
|
|
{
|
2015-11-14 20:04:01 +01:00
|
|
|
if (defined == PREDEFINED
|
2016-12-22 02:32:39 +01:00
|
|
|
&& (is_forced_local || this->version_script_.symbol_is_local(name)))
|
2015-07-22 01:10:05 +02:00
|
|
|
this->force_local(oldsym);
|
2009-03-17 08:07:21 +01:00
|
|
|
delete sym;
|
|
|
|
return oldsym;
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Define a symbol based on an Output_segment.
|
|
|
|
|
2006-12-06 01:02:36 +01:00
|
|
|
Symbol*
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol_table::define_in_output_segment(const char* name,
|
2009-12-29 01:31:48 +01:00
|
|
|
const char* version,
|
|
|
|
Defined defined,
|
|
|
|
Output_segment* os,
|
2009-12-14 20:53:05 +01:00
|
|
|
uint64_t value,
|
|
|
|
uint64_t symsize,
|
2008-01-26 02:17:45 +01:00
|
|
|
elfcpp::STT type,
|
|
|
|
elfcpp::STB binding,
|
2006-11-03 19:26:11 +01:00
|
|
|
elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis,
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::Segment_offset_base offset_base,
|
2006-11-03 19:26:11 +01:00
|
|
|
bool only_if_ref)
|
|
|
|
{
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().get_size() == 32)
|
2007-09-19 08:02:29 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
|
2009-12-29 01:31:48 +01:00
|
|
|
return this->do_define_in_output_segment<32>(name, version, defined, os,
|
2009-12-14 20:53:05 +01:00
|
|
|
value, symsize, type,
|
2007-09-19 08:02:29 +02:00
|
|
|
binding, visibility, nonvis,
|
2009-12-14 20:53:05 +01:00
|
|
|
offset_base, only_if_ref);
|
2007-09-19 08:02:29 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2008-02-28 01:18:24 +01:00
|
|
|
else if (parameters->target().get_size() == 64)
|
2007-09-19 08:02:29 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
|
2009-12-29 01:31:48 +01:00
|
|
|
return this->do_define_in_output_segment<64>(name, version, defined, os,
|
2009-12-14 20:53:05 +01:00
|
|
|
value, symsize, type,
|
2007-09-19 08:02:29 +02:00
|
|
|
binding, visibility, nonvis,
|
2009-12-14 20:53:05 +01:00
|
|
|
offset_base, only_if_ref);
|
2007-09-19 08:02:29 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
else
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_unreachable();
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
|
|
Symbol_table::do_define_in_output_segment(
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* name,
|
|
|
|
const char* version,
|
2009-12-29 01:31:48 +01:00
|
|
|
Defined defined,
|
2006-11-03 19:26:11 +01:00
|
|
|
Output_segment* os,
|
2009-12-14 20:53:05 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_WXword symsize,
|
2006-11-03 19:26:11 +01:00
|
|
|
elfcpp::STT type,
|
|
|
|
elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis,
|
2009-12-14 20:53:05 +01:00
|
|
|
Symbol::Segment_offset_base offset_base,
|
2006-11-03 19:26:11 +01:00
|
|
|
bool only_if_ref)
|
|
|
|
{
|
|
|
|
Sized_symbol<size>* sym;
|
2007-09-19 08:02:29 +02:00
|
|
|
Sized_symbol<size>* oldsym;
|
2009-03-17 08:07:21 +01:00
|
|
|
bool resolve_oldsym;
|
2016-12-22 02:32:39 +01:00
|
|
|
const bool is_forced_local = binding == elfcpp::STB_LOCAL;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().is_big_endian())
|
2007-09-26 09:01:35 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
|
2009-12-14 20:53:05 +01:00
|
|
|
sym = this->define_special_symbol<size, true>(&name, &version,
|
2017-11-09 00:56:54 +01:00
|
|
|
only_if_ref,
|
|
|
|
visibility,
|
|
|
|
&oldsym,
|
2016-12-22 02:32:39 +01:00
|
|
|
&resolve_oldsym,
|
|
|
|
is_forced_local);
|
2007-09-26 09:01:35 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
else
|
2007-09-26 09:01:35 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
|
2009-12-14 20:53:05 +01:00
|
|
|
sym = this->define_special_symbol<size, false>(&name, &version,
|
2017-11-09 00:56:54 +01:00
|
|
|
only_if_ref,
|
|
|
|
visibility,
|
|
|
|
&oldsym,
|
2016-12-22 02:32:39 +01:00
|
|
|
&resolve_oldsym,
|
|
|
|
is_forced_local);
|
2007-09-26 09:01:35 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
if (sym == NULL)
|
2006-12-06 01:02:36 +01:00
|
|
|
return NULL;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
sym->init_output_segment(name, version, os, value, symsize, type, binding,
|
2011-06-08 06:05:25 +02:00
|
|
|
visibility, nonvis, offset_base,
|
|
|
|
defined == PREDEFINED);
|
2006-12-06 01:02:36 +01:00
|
|
|
|
2008-01-09 20:57:45 +01:00
|
|
|
if (oldsym == NULL)
|
2008-01-24 01:15:00 +01:00
|
|
|
{
|
2016-12-22 02:32:39 +01:00
|
|
|
if (is_forced_local || this->version_script_.symbol_is_local(name))
|
2008-01-24 01:15:00 +01:00
|
|
|
this->force_local(sym);
|
2009-12-14 20:53:05 +01:00
|
|
|
else if (version != NULL)
|
2008-05-08 20:44:33 +02:00
|
|
|
sym->set_is_default();
|
2008-01-24 01:15:00 +01:00
|
|
|
return sym;
|
|
|
|
}
|
2007-09-19 08:02:29 +02:00
|
|
|
|
2011-07-09 01:49:11 +02:00
|
|
|
if (Symbol_table::should_override_with_special(oldsym, type, defined))
|
2008-01-09 20:57:45 +01:00
|
|
|
this->override_with_special(oldsym, sym);
|
2009-03-17 08:07:21 +01:00
|
|
|
|
|
|
|
if (resolve_oldsym)
|
|
|
|
return sym;
|
|
|
|
else
|
|
|
|
{
|
2016-12-22 02:32:39 +01:00
|
|
|
if (is_forced_local || this->version_script_.symbol_is_local(name))
|
2015-07-22 01:10:05 +02:00
|
|
|
this->force_local(oldsym);
|
2009-03-17 08:07:21 +01:00
|
|
|
delete sym;
|
|
|
|
return oldsym;
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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-14 20:53:05 +01:00
|
|
|
Symbol_table::define_as_constant(const char* name,
|
|
|
|
const char* version,
|
2009-12-29 01:31:48 +01:00
|
|
|
Defined defined,
|
2009-12-14 20:53:05 +01:00
|
|
|
uint64_t value,
|
|
|
|
uint64_t symsize,
|
2008-01-26 02:17:45 +01:00
|
|
|
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-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().get_size() == 32)
|
2007-09-19 08:02:29 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
|
2009-12-29 01:31:48 +01:00
|
|
|
return this->do_define_as_constant<32>(name, version, defined, value,
|
2009-12-14 20:53:05 +01:00
|
|
|
symsize, type, binding,
|
2008-02-13 02:20:38 +01:00
|
|
|
visibility, nonvis, only_if_ref,
|
|
|
|
force_override);
|
2007-09-19 08:02:29 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2008-02-28 01:18:24 +01:00
|
|
|
else if (parameters->target().get_size() == 64)
|
2007-09-19 08:02:29 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
|
2009-12-29 01:31:48 +01:00
|
|
|
return this->do_define_as_constant<64>(name, version, defined, value,
|
2009-12-14 20:53:05 +01:00
|
|
|
symsize, type, binding,
|
2008-02-13 02:20:38 +01:00
|
|
|
visibility, nonvis, only_if_ref,
|
|
|
|
force_override);
|
2007-09-19 08:02:29 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
else
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_unreachable();
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
|
|
Symbol_table::do_define_as_constant(
|
2009-12-14 20:53:05 +01:00
|
|
|
const char* name,
|
|
|
|
const char* version,
|
2009-12-29 01:31:48 +01:00
|
|
|
Defined defined,
|
2009-12-14 20:53:05 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_WXword symsize,
|
2006-11-03 19:26:11 +01:00
|
|
|
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
|
|
|
{
|
|
|
|
Sized_symbol<size>* sym;
|
2007-09-19 08:02:29 +02:00
|
|
|
Sized_symbol<size>* oldsym;
|
2009-03-17 08:07:21 +01:00
|
|
|
bool resolve_oldsym;
|
2016-12-22 02:32:39 +01:00
|
|
|
const bool is_forced_local = binding == elfcpp::STB_LOCAL;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().is_big_endian())
|
2007-09-26 09:01:35 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
|
2009-12-14 20:53:05 +01:00
|
|
|
sym = this->define_special_symbol<size, true>(&name, &version,
|
2017-11-09 00:56:54 +01:00
|
|
|
only_if_ref,
|
|
|
|
visibility,
|
|
|
|
&oldsym,
|
2016-12-22 02:32:39 +01:00
|
|
|
&resolve_oldsym,
|
|
|
|
is_forced_local);
|
2007-09-26 09:01:35 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
else
|
2007-09-26 09:01:35 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
|
2009-12-14 20:53:05 +01:00
|
|
|
sym = this->define_special_symbol<size, false>(&name, &version,
|
2017-11-09 00:56:54 +01:00
|
|
|
only_if_ref,
|
|
|
|
visibility,
|
|
|
|
&oldsym,
|
2016-12-22 02:32:39 +01:00
|
|
|
&resolve_oldsym,
|
|
|
|
is_forced_local);
|
2007-09-26 09:01:35 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
|
|
|
|
if (sym == NULL)
|
2006-12-06 01:02:36 +01:00
|
|
|
return NULL;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
sym->init_constant(name, version, value, symsize, type, binding, visibility,
|
2011-06-08 06:05:25 +02:00
|
|
|
nonvis, defined == PREDEFINED);
|
2006-12-06 01:02:36 +01:00
|
|
|
|
2008-01-09 20:57:45 +01:00
|
|
|
if (oldsym == NULL)
|
2008-01-24 01:15:00 +01:00
|
|
|
{
|
2008-03-29 09:39:26 +01:00
|
|
|
// Version symbols are absolute symbols with name == version.
|
|
|
|
// We don't want to force them to be local.
|
2009-12-14 20:53:05 +01:00
|
|
|
if ((version == NULL
|
|
|
|
|| name != version
|
|
|
|
|| value != 0)
|
2016-12-22 02:32:39 +01:00
|
|
|
&& (is_forced_local || this->version_script_.symbol_is_local(name)))
|
2008-01-24 01:15:00 +01:00
|
|
|
this->force_local(sym);
|
2009-12-14 20:53:05 +01:00
|
|
|
else if (version != NULL
|
|
|
|
&& (name != version || value != 0))
|
2008-05-08 20:44:33 +02:00
|
|
|
sym->set_is_default();
|
2008-01-24 01:15:00 +01:00
|
|
|
return sym;
|
|
|
|
}
|
2007-09-19 08:02:29 +02:00
|
|
|
|
2009-12-29 01:31:48 +01:00
|
|
|
if (force_override
|
2011-07-09 01:49:11 +02:00
|
|
|
|| Symbol_table::should_override_with_special(oldsym, type, defined))
|
2008-01-09 20:57:45 +01:00
|
|
|
this->override_with_special(oldsym, sym);
|
2009-03-17 08:07:21 +01:00
|
|
|
|
|
|
|
if (resolve_oldsym)
|
|
|
|
return sym;
|
|
|
|
else
|
|
|
|
{
|
2016-12-22 02:32:39 +01:00
|
|
|
if (is_forced_local || this->version_script_.symbol_is_local(name))
|
2015-07-22 01:10:05 +02:00
|
|
|
this->force_local(oldsym);
|
2009-03-17 08:07:21 +01:00
|
|
|
delete sym;
|
|
|
|
return oldsym;
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Define a set of symbols in output sections.
|
|
|
|
|
|
|
|
void
|
2008-01-26 02:17:45 +01:00
|
|
|
Symbol_table::define_symbols(const Layout* layout, int count,
|
2008-02-04 06:43:05 +01:00
|
|
|
const Define_symbol_in_section* p,
|
|
|
|
bool only_if_ref)
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
|
|
|
for (int i = 0; i < count; ++i, ++p)
|
|
|
|
{
|
|
|
|
Output_section* os = layout->find_output_section(p->output_section);
|
|
|
|
if (os != NULL)
|
2009-12-29 01:31:48 +01:00
|
|
|
this->define_in_output_data(p->name, NULL, PREDEFINED, os, p->value,
|
2006-12-06 01:02:36 +01:00
|
|
|
p->size, p->type, p->binding,
|
|
|
|
p->visibility, p->nonvis,
|
2008-02-04 06:43:05 +01:00
|
|
|
p->offset_is_from_end,
|
|
|
|
only_if_ref || p->only_if_ref);
|
2006-11-03 19:26:11 +01:00
|
|
|
else
|
2009-12-29 01:31:48 +01:00
|
|
|
this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size,
|
|
|
|
p->type, p->binding, p->visibility, p->nonvis,
|
2008-02-13 02:20:38 +01:00
|
|
|
only_if_ref || p->only_if_ref,
|
|
|
|
false);
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Define a set of symbols in output segments.
|
|
|
|
|
|
|
|
void
|
2008-01-26 02:17:45 +01:00
|
|
|
Symbol_table::define_symbols(const Layout* layout, int count,
|
2008-02-04 06:43:05 +01:00
|
|
|
const Define_symbol_in_segment* p,
|
|
|
|
bool only_if_ref)
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
|
|
|
for (int i = 0; i < count; ++i, ++p)
|
|
|
|
{
|
|
|
|
Output_segment* os = layout->find_output_segment(p->segment_type,
|
|
|
|
p->segment_flags_set,
|
|
|
|
p->segment_flags_clear);
|
|
|
|
if (os != NULL)
|
2009-12-29 01:31:48 +01:00
|
|
|
this->define_in_output_segment(p->name, NULL, PREDEFINED, os, p->value,
|
2006-12-06 01:02:36 +01:00
|
|
|
p->size, p->type, p->binding,
|
|
|
|
p->visibility, p->nonvis,
|
2008-02-04 06:43:05 +01:00
|
|
|
p->offset_base,
|
|
|
|
only_if_ref || p->only_if_ref);
|
2006-11-03 19:26:11 +01:00
|
|
|
else
|
2009-12-29 01:31:48 +01:00
|
|
|
this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size,
|
|
|
|
p->type, p->binding, p->visibility, p->nonvis,
|
2008-02-13 02:20:38 +01:00
|
|
|
only_if_ref || p->only_if_ref,
|
|
|
|
false);
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-23 01:08:22 +02:00
|
|
|
// Define CSYM 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
|
2007-12-20 22:21:24 +01:00
|
|
|
Symbol_table::define_with_copy_reloc(
|
|
|
|
Sized_symbol<size>* csym,
|
|
|
|
Output_data* posd,
|
2009-12-14 20:53:05 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr value)
|
2007-10-23 01:08:22 +02:00
|
|
|
{
|
|
|
|
gold_assert(csym->is_from_dynobj());
|
|
|
|
gold_assert(!csym->is_copied_from_dynobj());
|
2009-12-14 20:53:05 +01:00
|
|
|
Object* object = csym->object();
|
|
|
|
gold_assert(object->is_dynamic());
|
|
|
|
Dynobj* dynobj = static_cast<Dynobj*>(object);
|
2007-10-23 01:08:22 +02:00
|
|
|
|
|
|
|
// Our copied variable has to override any variable in a shared
|
|
|
|
// library.
|
|
|
|
elfcpp::STB binding = csym->binding();
|
|
|
|
if (binding == elfcpp::STB_WEAK)
|
|
|
|
binding = elfcpp::STB_GLOBAL;
|
|
|
|
|
2009-12-29 01:31:48 +01:00
|
|
|
this->define_in_output_data(csym->name(), csym->version(), COPY,
|
2009-12-14 20:53:05 +01:00
|
|
|
posd, value, csym->symsize(),
|
2007-10-23 01:08:22 +02:00
|
|
|
csym->type(), binding,
|
|
|
|
csym->visibility(), csym->nonvis(),
|
|
|
|
false, false);
|
|
|
|
|
|
|
|
csym->set_is_copied_from_dynobj();
|
|
|
|
csym->set_needs_dynsym_entry();
|
|
|
|
|
|
|
|
this->copied_symbol_dynobjs_[csym] = dynobj;
|
|
|
|
|
|
|
|
// We have now defined all aliases, but we have not entered them all
|
|
|
|
// in the copied_symbol_dynobjs_ map.
|
|
|
|
if (csym->has_alias())
|
|
|
|
{
|
|
|
|
Symbol* sym = csym;
|
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
sym = this->weak_aliases_[sym];
|
|
|
|
if (sym == csym)
|
|
|
|
break;
|
|
|
|
gold_assert(sym->output_data() == posd);
|
|
|
|
|
|
|
|
sym->set_is_copied_from_dynobj();
|
|
|
|
this->copied_symbol_dynobjs_[sym] = dynobj;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// SYM is defined using a COPY reloc. Return the dynamic object where
|
|
|
|
// the original definition was found.
|
|
|
|
|
|
|
|
Dynobj*
|
|
|
|
Symbol_table::get_copy_source(const Symbol* sym) const
|
|
|
|
{
|
|
|
|
gold_assert(sym->is_copied_from_dynobj());
|
|
|
|
Copied_symbol_dynobjs::const_iterator p =
|
|
|
|
this->copied_symbol_dynobjs_.find(sym);
|
|
|
|
gold_assert(p != this->copied_symbol_dynobjs_.end());
|
|
|
|
return p->second;
|
|
|
|
}
|
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
// Add any undefined symbols named on the command line.
|
|
|
|
|
|
|
|
void
|
2010-08-02 15:34:33 +02:00
|
|
|
Symbol_table::add_undefined_symbols_from_command_line(Layout* layout)
|
2008-05-07 08:08:01 +02:00
|
|
|
{
|
2010-08-02 15:34:33 +02:00
|
|
|
if (parameters->options().any_undefined()
|
|
|
|
|| layout->script_options()->any_unreferenced())
|
2008-05-07 08:08:01 +02:00
|
|
|
{
|
|
|
|
if (parameters->target().get_size() == 32)
|
|
|
|
{
|
2008-06-30 20:16:31 +02:00
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
|
2010-08-02 15:34:33 +02:00
|
|
|
this->do_add_undefined_symbols_from_command_line<32>(layout);
|
2008-05-07 08:08:01 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else if (parameters->target().get_size() == 64)
|
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
|
2010-08-02 15:34:33 +02:00
|
|
|
this->do_add_undefined_symbols_from_command_line<64>(layout);
|
2008-05-07 08:08:01 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
2010-08-02 15:34:33 +02:00
|
|
|
Symbol_table::do_add_undefined_symbols_from_command_line(Layout* layout)
|
2008-05-07 08:08:01 +02:00
|
|
|
{
|
|
|
|
for (options::String_set::const_iterator p =
|
|
|
|
parameters->options().undefined_begin();
|
|
|
|
p != parameters->options().undefined_end();
|
|
|
|
++p)
|
2010-08-02 15:34:33 +02:00
|
|
|
this->add_undefined_symbol_from_command_line<size>(p->c_str());
|
2008-05-07 08:08:01 +02:00
|
|
|
|
2012-04-17 02:28:41 +02:00
|
|
|
for (options::String_set::const_iterator p =
|
|
|
|
parameters->options().export_dynamic_symbol_begin();
|
|
|
|
p != parameters->options().export_dynamic_symbol_end();
|
|
|
|
++p)
|
|
|
|
this->add_undefined_symbol_from_command_line<size>(p->c_str());
|
|
|
|
|
2010-08-02 15:34:33 +02:00
|
|
|
for (Script_options::referenced_const_iterator p =
|
|
|
|
layout->script_options()->referenced_begin();
|
|
|
|
p != layout->script_options()->referenced_end();
|
|
|
|
++p)
|
|
|
|
this->add_undefined_symbol_from_command_line<size>(p->c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
|
|
|
Symbol_table::add_undefined_symbol_from_command_line(const char* name)
|
|
|
|
{
|
|
|
|
if (this->lookup(name) != NULL)
|
|
|
|
return;
|
2008-05-07 08:08:01 +02:00
|
|
|
|
2010-08-02 15:34:33 +02:00
|
|
|
const char* version = NULL;
|
2008-05-07 08:08:01 +02:00
|
|
|
|
2010-08-02 15:34:33 +02:00
|
|
|
Sized_symbol<size>* sym;
|
|
|
|
Sized_symbol<size>* oldsym;
|
|
|
|
bool resolve_oldsym;
|
|
|
|
if (parameters->target().is_big_endian())
|
|
|
|
{
|
2008-05-07 08:08:01 +02:00
|
|
|
#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
|
2010-08-02 15:34:33 +02:00
|
|
|
sym = this->define_special_symbol<size, true>(&name, &version,
|
2017-11-09 00:56:54 +01:00
|
|
|
false,
|
|
|
|
elfcpp::STV_DEFAULT,
|
|
|
|
&oldsym,
|
2016-12-22 02:32:39 +01:00
|
|
|
&resolve_oldsym,
|
|
|
|
false);
|
2008-05-07 08:08:01 +02:00
|
|
|
#else
|
2010-08-02 15:34:33 +02:00
|
|
|
gold_unreachable();
|
2008-05-07 08:08:01 +02:00
|
|
|
#endif
|
2010-08-02 15:34:33 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-05-07 08:08:01 +02:00
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
|
2010-08-02 15:34:33 +02:00
|
|
|
sym = this->define_special_symbol<size, false>(&name, &version,
|
2017-11-09 00:56:54 +01:00
|
|
|
false,
|
|
|
|
elfcpp::STV_DEFAULT,
|
|
|
|
&oldsym,
|
2016-12-22 02:32:39 +01:00
|
|
|
&resolve_oldsym,
|
|
|
|
false);
|
2008-05-07 08:08:01 +02:00
|
|
|
#else
|
2010-08-02 15:34:33 +02:00
|
|
|
gold_unreachable();
|
2008-05-07 08:08:01 +02:00
|
|
|
#endif
|
2010-08-02 15:34:33 +02:00
|
|
|
}
|
2008-05-07 08:08:01 +02:00
|
|
|
|
2010-08-02 15:34:33 +02:00
|
|
|
gold_assert(oldsym == NULL);
|
2008-05-07 08:08:01 +02:00
|
|
|
|
2016-02-05 01:55:39 +01:00
|
|
|
sym->init_undefined(name, version, 0, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
|
2010-08-02 15:34:33 +02:00
|
|
|
elfcpp::STV_DEFAULT, 0);
|
|
|
|
++this->saw_undefined_;
|
2008-05-07 08:08:01 +02:00
|
|
|
}
|
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
// Set the dynamic symbol indexes. INDEX is the index of the first
|
2016-12-22 23:06:24 +01:00
|
|
|
// global dynamic symbol. Pointers to the global symbols are stored
|
|
|
|
// into the vector SYMS. The names are added to DYNPOOL.
|
|
|
|
// This returns an updated dynamic symbol index.
|
2006-11-29 18:56:40 +01:00
|
|
|
|
|
|
|
unsigned int
|
2008-01-26 02:17:45 +01:00
|
|
|
Symbol_table::set_dynsym_indexes(unsigned int index,
|
2016-12-22 23:06:24 +01:00
|
|
|
unsigned int* pforced_local_count,
|
2006-11-29 18:56:40 +01:00
|
|
|
std::vector<Symbol*>* syms,
|
2006-12-06 01:02:36 +01:00
|
|
|
Stringpool* dynpool,
|
|
|
|
Versions* versions)
|
2006-11-29 18:56:40 +01:00
|
|
|
{
|
2016-12-22 23:06:24 +01:00
|
|
|
// First process all the symbols which have been forced to be local,
|
|
|
|
// as they must appear before all global symbols.
|
|
|
|
unsigned int forced_local_count = 0;
|
|
|
|
for (Forced_locals::iterator p = this->forced_locals_.begin();
|
|
|
|
p != this->forced_locals_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
Symbol* sym = *p;
|
|
|
|
gold_assert(sym->is_forced_local());
|
|
|
|
if (sym->has_dynsym_index())
|
|
|
|
continue;
|
|
|
|
if (!sym->should_add_dynsym_entry(this))
|
|
|
|
sym->set_dynsym_index(-1U);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sym->set_dynsym_index(index);
|
|
|
|
++index;
|
|
|
|
++forced_local_count;
|
|
|
|
dynpool->add(sym->name(), false, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*pforced_local_count = forced_local_count;
|
|
|
|
|
2014-03-10 21:33:20 +01:00
|
|
|
// Allow a target to set dynsym indexes.
|
|
|
|
if (parameters->target().has_custom_set_dynsym_indexes())
|
|
|
|
{
|
|
|
|
std::vector<Symbol*> dyn_symbols;
|
|
|
|
for (Symbol_table_type::iterator p = this->table_.begin();
|
|
|
|
p != this->table_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
Symbol* sym = p->second;
|
2016-12-22 23:06:24 +01:00
|
|
|
if (sym->is_forced_local())
|
|
|
|
continue;
|
2014-03-10 21:33:20 +01:00
|
|
|
if (!sym->should_add_dynsym_entry(this))
|
|
|
|
sym->set_dynsym_index(-1U);
|
|
|
|
else
|
|
|
|
dyn_symbols.push_back(sym);
|
|
|
|
}
|
|
|
|
|
|
|
|
return parameters->target().set_dynsym_indexes(&dyn_symbols, index, syms,
|
|
|
|
dynpool, versions, this);
|
|
|
|
}
|
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
for (Symbol_table_type::iterator p = this->table_.begin();
|
|
|
|
p != this->table_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
Symbol* sym = p->second;
|
2006-12-01 17:51:25 +01:00
|
|
|
|
2016-12-22 23:06:24 +01:00
|
|
|
if (sym->is_forced_local())
|
|
|
|
continue;
|
|
|
|
|
2006-12-01 17:51:25 +01:00
|
|
|
// Note that SYM may already have a dynamic symbol index, since
|
|
|
|
// some symbols appear more than once in the symbol table, with
|
|
|
|
// and without a version.
|
|
|
|
|
2010-04-20 23:13:30 +02:00
|
|
|
if (!sym->should_add_dynsym_entry(this))
|
2006-12-01 17:51:25 +01:00
|
|
|
sym->set_dynsym_index(-1U);
|
|
|
|
else if (!sym->has_dynsym_index())
|
2006-11-29 18:56:40 +01:00
|
|
|
{
|
|
|
|
sym->set_dynsym_index(index);
|
|
|
|
++index;
|
|
|
|
syms->push_back(sym);
|
2007-10-12 08:06:34 +02:00
|
|
|
dynpool->add(sym->name(), false, NULL);
|
2006-12-06 01:02:36 +01:00
|
|
|
|
2013-03-20 01:25:28 +01:00
|
|
|
// Record any version information, except those from
|
|
|
|
// as-needed libraries not seen to be needed. Note that the
|
|
|
|
// is_needed state for such libraries can change in this loop.
|
|
|
|
if (sym->version() != NULL)
|
|
|
|
{
|
|
|
|
if (!sym->is_from_dynobj()
|
|
|
|
|| !sym->object()->as_needed()
|
|
|
|
|| sym->object()->is_needed())
|
|
|
|
versions->record_version(this, dynpool, sym);
|
|
|
|
else
|
2018-06-21 22:51:16 +02:00
|
|
|
{
|
2018-08-06 23:08:48 +02:00
|
|
|
if (parameters->options().warn_drop_version())
|
|
|
|
gold_warning(_("discarding version information for "
|
|
|
|
"%s@%s, defined in unused shared library %s "
|
|
|
|
"(linked with --as-needed)"),
|
|
|
|
sym->name(), sym->version(),
|
|
|
|
sym->object()->name().c_str());
|
2018-06-21 22:51:16 +02:00
|
|
|
sym->clear_version();
|
|
|
|
}
|
2013-03-20 01:25:28 +01:00
|
|
|
}
|
2006-11-29 18:56:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-06 01:02:36 +01:00
|
|
|
// Finish up the versions. In some cases this may add new dynamic
|
|
|
|
// symbols.
|
2008-01-26 02:17:45 +01:00
|
|
|
index = versions->finalize(this, index, syms);
|
2006-12-06 01:02:36 +01:00
|
|
|
|
2016-02-05 01:55:39 +01:00
|
|
|
// Process target-specific symbols.
|
|
|
|
for (std::vector<Symbol*>::iterator p = this->target_symbols_.begin();
|
|
|
|
p != this->target_symbols_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
(*p)->set_dynsym_index(index);
|
|
|
|
++index;
|
|
|
|
syms->push_back(*p);
|
|
|
|
dynpool->add((*p)->name(), false, NULL);
|
|
|
|
}
|
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
2006-11-16 01:38:25 +01:00
|
|
|
// Set the final values for all the symbols. The index of the first
|
2008-01-24 01:15:00 +01:00
|
|
|
// global symbol in the output file is *PLOCAL_SYMCOUNT. Record the
|
|
|
|
// file offset OFF. Add their names to POOL. Return the new file
|
2016-12-22 23:06:24 +01:00
|
|
|
// offset. Update *PLOCAL_SYMCOUNT if necessary. DYNOFF and
|
|
|
|
// DYN_GLOBAL_INDEX refer to the start of the symbols that will be
|
|
|
|
// written from the global symbol table in Symtab::write_globals(),
|
|
|
|
// which will include forced-local symbols. DYN_GLOBAL_INDEX is
|
|
|
|
// not necessarily the same as the sh_info field for the .dynsym
|
|
|
|
// section, which will point to the first real global symbol.
|
2006-09-26 23:00:34 +02:00
|
|
|
|
2006-09-28 00:53:42 +02:00
|
|
|
off_t
|
2008-01-24 01:15:00 +01:00
|
|
|
Symbol_table::finalize(off_t off, off_t dynoff, size_t dyn_global_index,
|
|
|
|
size_t dyncount, Stringpool* pool,
|
2010-08-25 10:36:54 +02:00
|
|
|
unsigned int* plocal_symcount)
|
2006-09-26 23:00:34 +02:00
|
|
|
{
|
2006-11-06 23:46:08 +01:00
|
|
|
off_t ret;
|
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
gold_assert(*plocal_symcount != 0);
|
|
|
|
this->first_global_index_ = *plocal_symcount;
|
2006-11-16 01:38:25 +01:00
|
|
|
|
2006-12-01 17:51:25 +01:00
|
|
|
this->dynamic_offset_ = dynoff;
|
|
|
|
this->first_dynamic_global_index_ = dyn_global_index;
|
|
|
|
this->dynamic_count_ = dyncount;
|
|
|
|
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->target().get_size() == 32)
|
2007-09-26 09:01:35 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_32_LITTLE)
|
2008-01-24 01:15:00 +01:00
|
|
|
ret = this->sized_finalize<32>(off, pool, plocal_symcount);
|
2007-09-26 09:01:35 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2008-02-28 01:18:24 +01:00
|
|
|
else if (parameters->target().get_size() == 64)
|
2007-09-26 09:01:35 +02:00
|
|
|
{
|
|
|
|
#if defined(HAVE_TARGET_64_BIG) || defined(HAVE_TARGET_64_LITTLE)
|
2008-01-24 01:15:00 +01:00
|
|
|
ret = this->sized_finalize<64>(off, pool, plocal_symcount);
|
2007-09-26 09:01:35 +02:00
|
|
|
#else
|
|
|
|
gold_unreachable();
|
|
|
|
#endif
|
|
|
|
}
|
2006-09-29 21:58:17 +02:00
|
|
|
else
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_unreachable();
|
2006-11-06 23:46:08 +01:00
|
|
|
|
|
|
|
// Now that we have the final symbol table, we can reliably note
|
|
|
|
// which symbols should get warnings.
|
2008-01-03 00:48:49 +01:00
|
|
|
this->warnings_.note_warnings(this);
|
2006-11-06 23:46:08 +01:00
|
|
|
|
|
|
|
return ret;
|
2006-09-28 00:53:42 +02:00
|
|
|
}
|
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
// SYM is going into the symbol table at *PINDEX. Add the name to
|
|
|
|
// POOL, update *PINDEX and *POFF.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
void
|
|
|
|
Symbol_table::add_to_final_symtab(Symbol* sym, Stringpool* pool,
|
|
|
|
unsigned int* pindex, off_t* poff)
|
|
|
|
{
|
|
|
|
sym->set_symtab_index(*pindex);
|
2011-06-28 07:39:45 +02:00
|
|
|
if (sym->version() == NULL || !parameters->options().relocatable())
|
|
|
|
pool->add(sym->name(), false, NULL);
|
|
|
|
else
|
|
|
|
pool->add(sym->versioned_name(), true, NULL);
|
2008-01-24 01:15:00 +01:00
|
|
|
++*pindex;
|
|
|
|
*poff += elfcpp::Elf_sizes<size>::sym_size;
|
|
|
|
}
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
// Set the final value for all the symbols. This is called after
|
|
|
|
// Layout::finalize, so all the output sections have their final
|
|
|
|
// address.
|
2006-09-28 00:53:42 +02:00
|
|
|
|
|
|
|
template<int size>
|
|
|
|
off_t
|
2008-01-24 01:15:00 +01:00
|
|
|
Symbol_table::sized_finalize(off_t off, Stringpool* pool,
|
|
|
|
unsigned int* plocal_symcount)
|
2006-09-28 00:53:42 +02:00
|
|
|
{
|
2006-11-03 19:26:11 +01:00
|
|
|
off = align_address(off, size >> 3);
|
2006-09-28 00:53:42 +02:00
|
|
|
this->offset_ = off;
|
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
unsigned int index = *plocal_symcount;
|
|
|
|
const unsigned int orig_index = index;
|
2006-11-16 01:38:25 +01:00
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
// First do all the symbols which have been forced to be local, as
|
|
|
|
// they must appear before all global symbols.
|
|
|
|
for (Forced_locals::iterator p = this->forced_locals_.begin();
|
|
|
|
p != this->forced_locals_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
Symbol* sym = *p;
|
|
|
|
gold_assert(sym->is_forced_local());
|
|
|
|
if (this->sized_finalize_symbol<size>(sym))
|
|
|
|
{
|
|
|
|
this->add_to_final_symtab<size>(sym, pool, &index, &off);
|
|
|
|
++*plocal_symcount;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now do all the remaining symbols.
|
2006-11-16 01:38:25 +01:00
|
|
|
for (Symbol_table_type::iterator p = this->table_.begin();
|
|
|
|
p != this->table_.end();
|
|
|
|
++p)
|
2006-09-26 23:00:34 +02:00
|
|
|
{
|
2008-01-24 01:15:00 +01:00
|
|
|
Symbol* sym = p->second;
|
|
|
|
if (this->sized_finalize_symbol<size>(sym))
|
|
|
|
this->add_to_final_symtab<size>(sym, pool, &index, &off);
|
|
|
|
}
|
2006-09-26 23:00:34 +02:00
|
|
|
|
2016-02-05 01:55:39 +01:00
|
|
|
// Now do target-specific symbols.
|
|
|
|
for (std::vector<Symbol*>::iterator p = this->target_symbols_.begin();
|
|
|
|
p != this->target_symbols_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
this->add_to_final_symtab<size>(*p, pool, &index, &off);
|
|
|
|
}
|
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
this->output_count_ = index - orig_index;
|
2006-11-29 18:56:40 +01:00
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
return off;
|
|
|
|
}
|
2006-09-28 00:53:42 +02:00
|
|
|
|
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
|
|
|
// 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.
|
2006-12-06 07:28:56 +01:00
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
template<int size>
|
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
|
|
|
typename Sized_symbol<size>::Value_type
|
|
|
|
Symbol_table::compute_final_value(
|
|
|
|
const Sized_symbol<size>* sym,
|
|
|
|
Compute_final_value_status* pstatus) const
|
2008-01-24 01:15:00 +01:00
|
|
|
{
|
2008-07-11 01:01:20 +02:00
|
|
|
typedef typename Sized_symbol<size>::Value_type Value_type;
|
2009-12-14 20:53:05 +01:00
|
|
|
Value_type value;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
switch (sym->source())
|
|
|
|
{
|
|
|
|
case Symbol::FROM_OBJECT:
|
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
2009-12-14 20:53:05 +01:00
|
|
|
unsigned int shndx = sym->shndx(&is_ordinary);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-04-19 20:30:58 +02:00
|
|
|
if (!is_ordinary
|
2009-12-14 20:53:05 +01:00
|
|
|
&& shndx != elfcpp::SHN_ABS
|
|
|
|
&& !Symbol::is_common_shndx(shndx))
|
2008-01-24 01:15:00 +01:00
|
|
|
{
|
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
|
|
|
*pstatus = CFVS_UNSUPPORTED_SYMBOL_SECTION;
|
|
|
|
return 0;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
Object* symobj = sym->object();
|
|
|
|
if (symobj->is_dynamic())
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
value = 0;
|
|
|
|
shndx = elfcpp::SHN_UNDEF;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
2008-09-20 00:54:57 +02:00
|
|
|
else if (symobj->pluginobj() != NULL)
|
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
value = 0;
|
|
|
|
shndx = elfcpp::SHN_UNDEF;
|
2008-09-20 00:54:57 +02:00
|
|
|
}
|
2009-12-14 20:53:05 +01:00
|
|
|
else if (shndx == elfcpp::SHN_UNDEF)
|
|
|
|
value = 0;
|
2008-04-19 20:30:58 +02:00
|
|
|
else if (!is_ordinary
|
2009-12-14 20:53:05 +01:00
|
|
|
&& (shndx == elfcpp::SHN_ABS
|
|
|
|
|| Symbol::is_common_shndx(shndx)))
|
|
|
|
value = sym->value();
|
2008-01-24 01:15:00 +01:00
|
|
|
else
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2008-01-24 01:15:00 +01:00
|
|
|
Relobj* relobj = static_cast<Relobj*>(symobj);
|
2009-12-14 20:53:05 +01:00
|
|
|
Output_section* os = relobj->output_section(shndx);
|
2008-01-24 01:15:00 +01:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
if (this->is_section_folded(relobj, shndx))
|
2009-08-05 22:51:56 +02:00
|
|
|
{
|
|
|
|
gold_assert(os == NULL);
|
|
|
|
// Get the os of the section it is folded onto.
|
|
|
|
Section_id folded = this->icf_->get_folded_section(relobj,
|
2009-12-14 20:53:05 +01:00
|
|
|
shndx);
|
2009-08-05 22:51:56 +02:00
|
|
|
gold_assert(folded.first != NULL);
|
|
|
|
Relobj* folded_obj = reinterpret_cast<Relobj*>(folded.first);
|
2009-12-17 01:00:26 +01:00
|
|
|
unsigned folded_shndx = folded.second;
|
|
|
|
|
|
|
|
os = folded_obj->output_section(folded_shndx);
|
2009-08-05 22:51:56 +02:00
|
|
|
gold_assert(os != NULL);
|
2009-12-17 01:00:26 +01:00
|
|
|
|
|
|
|
// Replace (relobj, shndx) with canonical ICF input section.
|
|
|
|
shndx = folded_shndx;
|
|
|
|
relobj = folded_obj;
|
2009-08-05 22:51:56 +02:00
|
|
|
}
|
|
|
|
|
2009-12-17 01:00:26 +01:00
|
|
|
uint64_t secoff64 = relobj->output_section_offset(shndx);
|
2009-08-05 22:51:56 +02:00
|
|
|
if (os == NULL)
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2009-01-28 03:25:33 +01:00
|
|
|
bool static_or_reloc = (parameters->doing_static_link() ||
|
|
|
|
parameters->options().relocatable());
|
|
|
|
gold_assert(static_or_reloc || sym->dynsym_index() == -1U);
|
|
|
|
|
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
|
|
|
*pstatus = CFVS_NO_OUTPUT_SECTION;
|
|
|
|
return 0;
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
2008-01-24 01:15:00 +01:00
|
|
|
|
2008-09-29 23:10:26 +02:00
|
|
|
if (secoff64 == -1ULL)
|
|
|
|
{
|
|
|
|
// The section needs special handling (e.g., a merge section).
|
2009-08-05 22:51:56 +02:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
value = os->output_address(relobj, shndx, sym->value());
|
2008-09-29 23:10:26 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Value_type secoff =
|
|
|
|
convert_types<Value_type, uint64_t>(secoff64);
|
|
|
|
if (sym->type() == elfcpp::STT_TLS)
|
2009-12-14 20:53:05 +01:00
|
|
|
value = sym->value() + os->tls_offset() + secoff;
|
2008-09-29 23:10:26 +02:00
|
|
|
else
|
2009-12-14 20:53:05 +01:00
|
|
|
value = sym->value() + os->address() + secoff;
|
2008-09-29 23:10:26 +02:00
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
2008-01-24 01:15:00 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Symbol::IN_OUTPUT_DATA:
|
|
|
|
{
|
|
|
|
Output_data* od = sym->output_data();
|
2009-12-14 20:53:05 +01:00
|
|
|
value = sym->value();
|
2008-04-17 09:12:00 +02:00
|
|
|
if (sym->type() != elfcpp::STT_TLS)
|
2009-12-14 20:53:05 +01:00
|
|
|
value += od->address();
|
2008-04-17 09:12:00 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
Output_section* os = od->output_section();
|
|
|
|
gold_assert(os != NULL);
|
2009-12-14 20:53:05 +01:00
|
|
|
value += os->tls_offset() + (od->address() - os->address());
|
2008-04-17 09:12:00 +02:00
|
|
|
}
|
2008-01-24 01:15:00 +01:00
|
|
|
if (sym->offset_is_from_end())
|
2009-12-14 20:53:05 +01:00
|
|
|
value += od->data_size();
|
2008-01-24 01:15:00 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Symbol::IN_OUTPUT_SEGMENT:
|
|
|
|
{
|
|
|
|
Output_segment* os = sym->output_segment();
|
2009-12-14 20:53:05 +01:00
|
|
|
value = sym->value();
|
2008-04-17 04:00:54 +02:00
|
|
|
if (sym->type() != elfcpp::STT_TLS)
|
2009-12-14 20:53:05 +01:00
|
|
|
value += os->vaddr();
|
2008-01-24 01:15:00 +01:00
|
|
|
switch (sym->offset_base())
|
|
|
|
{
|
|
|
|
case Symbol::SEGMENT_START:
|
|
|
|
break;
|
|
|
|
case Symbol::SEGMENT_END:
|
2009-12-14 20:53:05 +01:00
|
|
|
value += os->memsz();
|
2008-01-24 01:15:00 +01:00
|
|
|
break;
|
|
|
|
case Symbol::SEGMENT_BSS:
|
2009-12-14 20:53:05 +01:00
|
|
|
value += os->filesz();
|
2008-01-24 01:15:00 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
case Symbol::IS_CONSTANT:
|
2009-12-14 20:53:05 +01:00
|
|
|
value = sym->value();
|
2008-01-24 01:15:00 +01:00
|
|
|
break;
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
case Symbol::IS_UNDEFINED:
|
2009-12-14 20:53:05 +01:00
|
|
|
value = 0;
|
2008-05-07 08:08:01 +02:00
|
|
|
break;
|
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
|
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
|
|
|
*pstatus = CFVS_OK;
|
2009-12-14 20:53:05 +01:00
|
|
|
return value;
|
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
|
|
|
}
|
|
|
|
|
|
|
|
// Finalize the symbol SYM. This returns true if the symbol should be
|
|
|
|
// added to the symbol table, false otherwise.
|
|
|
|
|
|
|
|
template<int size>
|
|
|
|
bool
|
|
|
|
Symbol_table::sized_finalize_symbol(Symbol* unsized_sym)
|
|
|
|
{
|
|
|
|
typedef typename Sized_symbol<size>::Value_type Value_type;
|
|
|
|
|
|
|
|
Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(unsized_sym);
|
|
|
|
|
|
|
|
// The default version of a symbol may appear twice in the symbol
|
|
|
|
// table. We only need to finalize it once.
|
|
|
|
if (sym->has_symtab_index())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!sym->in_reg())
|
|
|
|
{
|
|
|
|
gold_assert(!sym->has_symtab_index());
|
|
|
|
sym->set_symtab_index(-1U);
|
|
|
|
gold_assert(sym->dynsym_index() == -1U);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-02-18 15:55:33 +01:00
|
|
|
// If the symbol is only present on plugin files, the plugin decided we
|
|
|
|
// don't need it.
|
|
|
|
if (!sym->in_real_elf())
|
|
|
|
{
|
|
|
|
gold_assert(!sym->has_symtab_index());
|
|
|
|
sym->set_symtab_index(-1U);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
// Compute final symbol value.
|
|
|
|
Compute_final_value_status status;
|
2009-12-14 20:53:05 +01:00
|
|
|
Value_type value = this->compute_final_value(sym, &status);
|
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
|
|
|
|
|
|
|
switch (status)
|
|
|
|
{
|
|
|
|
case CFVS_OK:
|
|
|
|
break;
|
|
|
|
case CFVS_UNSUPPORTED_SYMBOL_SECTION:
|
|
|
|
{
|
|
|
|
bool is_ordinary;
|
2009-12-14 20:53:05 +01:00
|
|
|
unsigned int shndx = sym->shndx(&is_ordinary);
|
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
|
|
|
gold_error(_("%s: unsupported symbol section 0x%x"),
|
2009-12-14 20:53:05 +01:00
|
|
|
sym->demangled_name().c_str(), shndx);
|
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
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CFVS_NO_OUTPUT_SECTION:
|
|
|
|
sym->set_symtab_index(-1U);
|
|
|
|
return false;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
sym->set_value(value);
|
2007-10-10 21:02:56 +02:00
|
|
|
|
2009-09-18 22:03:22 +02:00
|
|
|
if (parameters->options().strip_all()
|
|
|
|
|| !parameters->options().should_retain_symbol(sym->name()))
|
2008-01-24 01:15:00 +01:00
|
|
|
{
|
|
|
|
sym->set_symtab_index(-1U);
|
|
|
|
return false;
|
2006-09-26 23:00:34 +02:00
|
|
|
}
|
2006-09-28 00:53:42 +02:00
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
return true;
|
2006-09-26 23:00:34 +02:00
|
|
|
}
|
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
// Write out the global symbols.
|
|
|
|
|
|
|
|
void
|
2009-02-28 05:39:57 +01:00
|
|
|
Symbol_table::write_globals(const Stringpool* sympool,
|
2008-04-19 20:30:58 +02:00
|
|
|
const Stringpool* dynpool,
|
|
|
|
Output_symtab_xindex* symtab_xindex,
|
|
|
|
Output_symtab_xindex* dynsym_xindex,
|
|
|
|
Output_file* of) const
|
2006-09-29 21:58:17 +02:00
|
|
|
{
|
2008-02-28 01:18:24 +01:00
|
|
|
switch (parameters->size_and_endianness())
|
2006-09-29 21:58:17 +02:00
|
|
|
{
|
2007-09-26 09:01:35 +02:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
2008-02-28 01:18:24 +01:00
|
|
|
case Parameters::TARGET_32_LITTLE:
|
2009-02-28 05:39:57 +01:00
|
|
|
this->sized_write_globals<32, false>(sympool, dynpool, symtab_xindex,
|
2008-04-19 20:30:58 +02:00
|
|
|
dynsym_xindex, of);
|
2008-02-28 01:18:24 +01:00
|
|
|
break;
|
2007-09-26 09:01:35 +02:00
|
|
|
#endif
|
2008-02-28 01:18:24 +01:00
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
|
|
|
case Parameters::TARGET_32_BIG:
|
2009-02-28 05:39:57 +01:00
|
|
|
this->sized_write_globals<32, true>(sympool, dynpool, symtab_xindex,
|
2008-04-19 20:30:58 +02:00
|
|
|
dynsym_xindex, of);
|
2008-02-28 01:18:24 +01:00
|
|
|
break;
|
2007-09-26 09:01:35 +02:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
2008-02-28 01:18:24 +01:00
|
|
|
case Parameters::TARGET_64_LITTLE:
|
2009-02-28 05:39:57 +01:00
|
|
|
this->sized_write_globals<64, false>(sympool, dynpool, symtab_xindex,
|
2008-04-19 20:30:58 +02:00
|
|
|
dynsym_xindex, of);
|
2008-02-28 01:18:24 +01:00
|
|
|
break;
|
2007-09-26 09:01:35 +02:00
|
|
|
#endif
|
2008-02-28 01:18:24 +01:00
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
|
|
|
case Parameters::TARGET_64_BIG:
|
2009-02-28 05:39:57 +01:00
|
|
|
this->sized_write_globals<64, true>(sympool, dynpool, symtab_xindex,
|
2008-04-19 20:30:58 +02:00
|
|
|
dynsym_xindex, of);
|
2008-02-28 01:18:24 +01:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
2006-09-29 21:58:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write out the global symbols.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2009-02-28 05:39:57 +01:00
|
|
|
Symbol_table::sized_write_globals(const Stringpool* sympool,
|
2006-12-01 17:51:25 +01:00
|
|
|
const Stringpool* dynpool,
|
2008-04-19 20:30:58 +02:00
|
|
|
Output_symtab_xindex* symtab_xindex,
|
|
|
|
Output_symtab_xindex* dynsym_xindex,
|
2006-09-29 21:58:17 +02:00
|
|
|
Output_file* of) const
|
|
|
|
{
|
2008-02-28 01:18:24 +01:00
|
|
|
const Target& target = parameters->target();
|
2007-11-14 17:53:25 +01:00
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
|
2008-01-24 01:15:00 +01:00
|
|
|
|
|
|
|
const unsigned int output_count = this->output_count_;
|
|
|
|
const section_size_type oview_size = output_count * sym_size;
|
|
|
|
const unsigned int first_global_index = this->first_global_index_;
|
2008-02-07 05:35:41 +01:00
|
|
|
unsigned char* psyms;
|
|
|
|
if (this->offset_ == 0 || output_count == 0)
|
|
|
|
psyms = NULL;
|
|
|
|
else
|
|
|
|
psyms = of->get_output_view(this->offset_, oview_size);
|
2006-12-01 17:51:25 +01:00
|
|
|
|
2008-01-24 01:15:00 +01:00
|
|
|
const unsigned int dynamic_count = this->dynamic_count_;
|
|
|
|
const section_size_type dynamic_size = dynamic_count * sym_size;
|
|
|
|
const unsigned int first_dynamic_global_index =
|
|
|
|
this->first_dynamic_global_index_;
|
2006-12-01 17:51:25 +01:00
|
|
|
unsigned char* dynamic_view;
|
2008-02-07 05:35:41 +01:00
|
|
|
if (this->dynamic_offset_ == 0 || dynamic_count == 0)
|
2006-12-01 17:51:25 +01:00
|
|
|
dynamic_view = NULL;
|
|
|
|
else
|
|
|
|
dynamic_view = of->get_output_view(this->dynamic_offset_, dynamic_size);
|
2006-11-16 01:38:25 +01:00
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
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);
|
|
|
|
|
2007-11-14 17:53:25 +01:00
|
|
|
// Possibly warn about unresolved symbols in shared libraries.
|
2009-02-28 05:39:57 +01:00
|
|
|
this->warn_about_undefined_dynobj_symbol(sym);
|
2007-11-14 08:34:53 +01:00
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
unsigned int sym_index = sym->symtab_index();
|
2006-12-01 17:51:25 +01:00
|
|
|
unsigned int dynsym_index;
|
|
|
|
if (dynamic_view == NULL)
|
|
|
|
dynsym_index = -1U;
|
|
|
|
else
|
|
|
|
dynsym_index = sym->dynsym_index();
|
|
|
|
|
|
|
|
if (sym_index == -1U && dynsym_index == -1U)
|
2006-11-29 18:56:40 +01:00
|
|
|
{
|
|
|
|
// This symbol is not included in the output file.
|
|
|
|
continue;
|
|
|
|
}
|
2006-12-01 17:51:25 +01:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
unsigned int shndx;
|
2008-02-07 02:51:25 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr sym_value = sym->value();
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr dynsym_value = sym_value;
|
2010-07-09 03:34:31 +02:00
|
|
|
elfcpp::STB binding = sym->binding();
|
2011-10-31 23:43:49 +01:00
|
|
|
|
2015-04-23 22:56:40 +02:00
|
|
|
// If --weak-unresolved-symbols is set, change binding of unresolved
|
|
|
|
// global symbols to STB_WEAK.
|
|
|
|
if (parameters->options().weak_unresolved_symbols()
|
|
|
|
&& binding == elfcpp::STB_GLOBAL
|
|
|
|
&& sym->is_undefined())
|
|
|
|
binding = elfcpp::STB_WEAK;
|
|
|
|
|
2011-10-31 23:43:49 +01:00
|
|
|
// If --no-gnu-unique is set, change STB_GNU_UNIQUE to STB_GLOBAL.
|
|
|
|
if (binding == elfcpp::STB_GNU_UNIQUE
|
|
|
|
&& !parameters->options().gnu_unique())
|
|
|
|
binding = elfcpp::STB_GLOBAL;
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
switch (sym->source())
|
|
|
|
{
|
|
|
|
case Symbol::FROM_OBJECT:
|
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
bool is_ordinary;
|
|
|
|
unsigned int in_shndx = sym->shndx(&is_ordinary);
|
2006-11-03 19:26:11 +01:00
|
|
|
|
2008-04-19 20:30:58 +02:00
|
|
|
if (!is_ordinary
|
2008-02-28 21:35:39 +01:00
|
|
|
&& in_shndx != elfcpp::SHN_ABS
|
2009-06-22 08:51:53 +02:00
|
|
|
&& !Symbol::is_common_shndx(in_shndx))
|
2006-11-03 19:26:11 +01:00
|
|
|
{
|
2007-10-14 08:49:14 +02:00
|
|
|
gold_error(_("%s: unsupported symbol section 0x%x"),
|
2007-11-15 02:12:55 +01:00
|
|
|
sym->demangled_name().c_str(), in_shndx);
|
2009-12-14 20:53:05 +01:00
|
|
|
shndx = in_shndx;
|
2006-11-06 23:46:08 +01:00
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
else
|
|
|
|
{
|
2007-10-14 08:49:14 +02:00
|
|
|
Object* symobj = sym->object();
|
|
|
|
if (symobj->is_dynamic())
|
|
|
|
{
|
|
|
|
if (sym->needs_dynsym_value())
|
2008-02-28 01:18:24 +01:00
|
|
|
dynsym_value = target.dynsym_value(sym);
|
2009-12-14 20:53:05 +01:00
|
|
|
shndx = elfcpp::SHN_UNDEF;
|
2010-07-09 03:34:31 +02:00
|
|
|
if (sym->is_undef_binding_weak())
|
|
|
|
binding = elfcpp::STB_WEAK;
|
2010-08-13 02:18:19 +02:00
|
|
|
else
|
|
|
|
binding = elfcpp::STB_GLOBAL;
|
2007-10-14 08:49:14 +02:00
|
|
|
}
|
2008-09-20 00:54:57 +02:00
|
|
|
else if (symobj->pluginobj() != NULL)
|
2009-12-14 20:53:05 +01:00
|
|
|
shndx = elfcpp::SHN_UNDEF;
|
2007-10-14 08:49:14 +02:00
|
|
|
else if (in_shndx == elfcpp::SHN_UNDEF
|
2008-04-19 20:30:58 +02:00
|
|
|
|| (!is_ordinary
|
|
|
|
&& (in_shndx == elfcpp::SHN_ABS
|
2009-06-22 08:51:53 +02:00
|
|
|
|| Symbol::is_common_shndx(in_shndx))))
|
2009-12-14 20:53:05 +01:00
|
|
|
shndx = in_shndx;
|
2007-10-14 08:49:14 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
Relobj* relobj = static_cast<Relobj*>(symobj);
|
2008-07-11 01:01:20 +02:00
|
|
|
Output_section* os = relobj->output_section(in_shndx);
|
2009-08-05 22:51:56 +02:00
|
|
|
if (this->is_section_folded(relobj, in_shndx))
|
|
|
|
{
|
|
|
|
// This global symbol must be written out even though
|
|
|
|
// it is folded.
|
|
|
|
// Get the os of the section it is folded onto.
|
|
|
|
Section_id folded =
|
|
|
|
this->icf_->get_folded_section(relobj, in_shndx);
|
|
|
|
gold_assert(folded.first !=NULL);
|
|
|
|
Relobj* folded_obj =
|
|
|
|
reinterpret_cast<Relobj*>(folded.first);
|
|
|
|
os = folded_obj->output_section(folded.second);
|
|
|
|
gold_assert(os != NULL);
|
|
|
|
}
|
2007-10-14 08:49:14 +02:00
|
|
|
gold_assert(os != NULL);
|
2009-12-14 20:53:05 +01:00
|
|
|
shndx = os->out_shndx();
|
2008-02-07 02:51:25 +01:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
if (shndx >= elfcpp::SHN_LORESERVE)
|
2008-04-19 20:30:58 +02:00
|
|
|
{
|
|
|
|
if (sym_index != -1U)
|
2009-12-14 20:53:05 +01:00
|
|
|
symtab_xindex->add(sym_index, shndx);
|
2008-04-19 20:30:58 +02:00
|
|
|
if (dynsym_index != -1U)
|
2009-12-14 20:53:05 +01:00
|
|
|
dynsym_xindex->add(dynsym_index, shndx);
|
|
|
|
shndx = elfcpp::SHN_XINDEX;
|
2008-04-19 20:30:58 +02:00
|
|
|
}
|
|
|
|
|
2008-02-07 02:51:25 +01:00
|
|
|
// In object files symbol values are section
|
|
|
|
// relative.
|
2008-02-28 01:18:24 +01:00
|
|
|
if (parameters->options().relocatable())
|
2008-02-07 02:51:25 +01:00
|
|
|
sym_value -= os->address();
|
2007-10-14 08:49:14 +02:00
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Symbol::IN_OUTPUT_DATA:
|
2013-04-15 18:34:12 +02:00
|
|
|
{
|
|
|
|
Output_data* od = sym->output_data();
|
|
|
|
|
|
|
|
shndx = od->out_shndx();
|
|
|
|
if (shndx >= elfcpp::SHN_LORESERVE)
|
|
|
|
{
|
|
|
|
if (sym_index != -1U)
|
|
|
|
symtab_xindex->add(sym_index, shndx);
|
|
|
|
if (dynsym_index != -1U)
|
|
|
|
dynsym_xindex->add(dynsym_index, shndx);
|
|
|
|
shndx = elfcpp::SHN_XINDEX;
|
|
|
|
}
|
|
|
|
|
|
|
|
// In object files symbol values are section
|
|
|
|
// relative.
|
|
|
|
if (parameters->options().relocatable())
|
2016-12-19 19:37:23 +01:00
|
|
|
{
|
|
|
|
Output_section* os = od->output_section();
|
|
|
|
gold_assert(os != NULL);
|
|
|
|
sym_value -= os->address();
|
|
|
|
}
|
2013-04-15 18:34:12 +02:00
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Symbol::IN_OUTPUT_SEGMENT:
|
2016-12-22 01:21:23 +01:00
|
|
|
{
|
|
|
|
Output_segment* oseg = sym->output_segment();
|
|
|
|
Output_section* osect = oseg->first_section();
|
|
|
|
if (osect == NULL)
|
|
|
|
shndx = elfcpp::SHN_ABS;
|
|
|
|
else
|
|
|
|
shndx = osect->out_shndx();
|
|
|
|
}
|
2006-11-03 19:26:11 +01:00
|
|
|
break;
|
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
case Symbol::IS_CONSTANT:
|
2009-12-14 20:53:05 +01:00
|
|
|
shndx = elfcpp::SHN_ABS;
|
2006-11-03 19:26:11 +01:00
|
|
|
break;
|
|
|
|
|
2008-05-07 08:08:01 +02:00
|
|
|
case Symbol::IS_UNDEFINED:
|
2009-12-14 20:53:05 +01:00
|
|
|
shndx = elfcpp::SHN_UNDEF;
|
2008-05-07 08:08:01 +02:00
|
|
|
break;
|
|
|
|
|
2006-11-03 19:26:11 +01:00
|
|
|
default:
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_unreachable();
|
2006-11-03 19:26:11 +01:00
|
|
|
}
|
2006-09-29 21:58:17 +02:00
|
|
|
|
2006-12-01 17:51:25 +01:00
|
|
|
if (sym_index != -1U)
|
|
|
|
{
|
2008-01-24 01:15:00 +01:00
|
|
|
sym_index -= first_global_index;
|
|
|
|
gold_assert(sym_index < output_count);
|
|
|
|
unsigned char* ps = psyms + (sym_index * sym_size);
|
2009-12-14 20:53:05 +01:00
|
|
|
this->sized_write_symbol<size, big_endian>(sym, sym_value, shndx,
|
2010-07-09 03:34:31 +02:00
|
|
|
binding, sympool, ps);
|
2006-12-01 17:51:25 +01:00
|
|
|
}
|
2006-09-29 21:58:17 +02:00
|
|
|
|
2006-12-01 17:51:25 +01:00
|
|
|
if (dynsym_index != -1U)
|
|
|
|
{
|
|
|
|
dynsym_index -= first_dynamic_global_index;
|
|
|
|
gold_assert(dynsym_index < dynamic_count);
|
|
|
|
unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
|
2009-12-14 20:53:05 +01:00
|
|
|
this->sized_write_symbol<size, big_endian>(sym, dynsym_value, shndx,
|
2010-07-09 03:34:31 +02:00
|
|
|
binding, dynpool, pd);
|
2014-03-10 21:35:53 +01:00
|
|
|
// Allow a target to adjust dynamic symbol value.
|
|
|
|
parameters->target().adjust_dyn_symbol(sym, pd);
|
2006-12-01 17:51:25 +01:00
|
|
|
}
|
2006-09-29 21:58:17 +02:00
|
|
|
}
|
|
|
|
|
2016-02-05 01:55:39 +01:00
|
|
|
// Write the target-specific symbols.
|
|
|
|
for (std::vector<Symbol*>::const_iterator p = this->target_symbols_.begin();
|
|
|
|
p != this->target_symbols_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(*p);
|
|
|
|
|
|
|
|
unsigned int sym_index = sym->symtab_index();
|
|
|
|
unsigned int dynsym_index;
|
|
|
|
if (dynamic_view == NULL)
|
|
|
|
dynsym_index = -1U;
|
|
|
|
else
|
|
|
|
dynsym_index = sym->dynsym_index();
|
|
|
|
|
|
|
|
unsigned int shndx;
|
|
|
|
switch (sym->source())
|
|
|
|
{
|
|
|
|
case Symbol::IS_CONSTANT:
|
|
|
|
shndx = elfcpp::SHN_ABS;
|
|
|
|
break;
|
|
|
|
case Symbol::IS_UNDEFINED:
|
|
|
|
shndx = elfcpp::SHN_UNDEF;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sym_index != -1U)
|
|
|
|
{
|
|
|
|
sym_index -= first_global_index;
|
|
|
|
gold_assert(sym_index < output_count);
|
|
|
|
unsigned char* ps = psyms + (sym_index * sym_size);
|
|
|
|
this->sized_write_symbol<size, big_endian>(sym, sym->value(), shndx,
|
|
|
|
sym->binding(), sympool,
|
|
|
|
ps);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dynsym_index != -1U)
|
|
|
|
{
|
|
|
|
dynsym_index -= first_dynamic_global_index;
|
|
|
|
gold_assert(dynsym_index < dynamic_count);
|
|
|
|
unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
|
|
|
|
this->sized_write_symbol<size, big_endian>(sym, sym->value(), shndx,
|
|
|
|
sym->binding(), dynpool,
|
|
|
|
pd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-16 01:38:25 +01:00
|
|
|
of->write_output_view(this->offset_, oview_size, psyms);
|
2006-12-01 17:51:25 +01:00
|
|
|
if (dynamic_view != NULL)
|
|
|
|
of->write_output_view(this->dynamic_offset_, dynamic_size, dynamic_view);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write out the symbol SYM, in section SHNDX, to P. POOL is the
|
|
|
|
// strtab holding the name.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
void
|
2007-09-23 07:31:48 +02:00
|
|
|
Symbol_table::sized_write_symbol(
|
|
|
|
Sized_symbol<size>* sym,
|
2009-12-14 20:53:05 +01:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr value,
|
|
|
|
unsigned int shndx,
|
2010-07-09 03:34:31 +02:00
|
|
|
elfcpp::STB binding,
|
2007-09-23 07:31:48 +02:00
|
|
|
const Stringpool* pool,
|
2008-02-29 20:19:17 +01:00
|
|
|
unsigned char* p) const
|
2006-12-01 17:51:25 +01:00
|
|
|
{
|
|
|
|
elfcpp::Sym_write<size, big_endian> osym(p);
|
2011-06-28 07:39:45 +02:00
|
|
|
if (sym->version() == NULL || !parameters->options().relocatable())
|
|
|
|
osym.put_st_name(pool->get_offset(sym->name()));
|
|
|
|
else
|
|
|
|
osym.put_st_name(pool->get_offset(sym->versioned_name()));
|
2009-12-14 20:53:05 +01:00
|
|
|
osym.put_st_value(value);
|
2008-07-23 18:19:59 +02:00
|
|
|
// Use a symbol size of zero for undefined symbols from shared libraries.
|
2009-12-14 20:53:05 +01:00
|
|
|
if (shndx == elfcpp::SHN_UNDEF && sym->is_from_dynobj())
|
2008-07-23 18:19:59 +02:00
|
|
|
osym.put_st_size(0);
|
|
|
|
else
|
|
|
|
osym.put_st_size(sym->symsize());
|
2009-12-07 18:14:55 +01:00
|
|
|
elfcpp::STT type = sym->type();
|
2015-09-02 13:14:21 +02:00
|
|
|
gold_assert(type != elfcpp::STT_GNU_IFUNC || !sym->is_from_dynobj());
|
2008-01-24 01:15:00 +01:00
|
|
|
// A version script may have overridden the default binding.
|
|
|
|
if (sym->is_forced_local())
|
2009-12-07 18:14:55 +01:00
|
|
|
osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL, type));
|
2008-01-24 01:15:00 +01:00
|
|
|
else
|
2010-07-09 03:34:31 +02:00
|
|
|
osym.put_st_info(elfcpp::elf_st_info(binding, type));
|
2006-12-01 17:51:25 +01:00
|
|
|
osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis()));
|
2009-12-14 20:53:05 +01:00
|
|
|
osym.put_st_shndx(shndx);
|
2006-09-29 21:58:17 +02:00
|
|
|
}
|
|
|
|
|
2007-11-14 17:53:25 +01:00
|
|
|
// Check for unresolved symbols in shared libraries. This is
|
|
|
|
// controlled by the --allow-shlib-undefined option.
|
|
|
|
|
|
|
|
// We only warn about libraries for which we have seen all the
|
|
|
|
// DT_NEEDED entries. We don't try to track down DT_NEEDED entries
|
|
|
|
// which were not seen in this link. If we didn't see a DT_NEEDED
|
|
|
|
// entry, we aren't going to be able to reliably report whether the
|
|
|
|
// symbol is undefined.
|
|
|
|
|
2009-02-28 05:39:57 +01:00
|
|
|
// We also don't warn about libraries found in a system library
|
|
|
|
// directory (e.g., /lib or /usr/lib); we assume that those libraries
|
|
|
|
// are OK. This heuristic avoids problems on GNU/Linux, in which -ldl
|
|
|
|
// can have undefined references satisfied by ld-linux.so.
|
2007-11-14 17:53:25 +01:00
|
|
|
|
|
|
|
inline void
|
2009-02-28 05:39:57 +01:00
|
|
|
Symbol_table::warn_about_undefined_dynobj_symbol(Symbol* sym) const
|
2007-11-14 17:53:25 +01:00
|
|
|
{
|
2008-04-19 20:30:58 +02:00
|
|
|
bool dummy;
|
2007-11-14 17:53:25 +01:00
|
|
|
if (sym->source() == Symbol::FROM_OBJECT
|
|
|
|
&& sym->object()->is_dynamic()
|
2008-04-19 20:30:58 +02:00
|
|
|
&& sym->shndx(&dummy) == elfcpp::SHN_UNDEF
|
2007-11-14 17:53:25 +01:00
|
|
|
&& sym->binding() != elfcpp::STB_WEAK
|
2008-02-28 01:18:24 +01:00
|
|
|
&& !parameters->options().allow_shlib_undefined()
|
|
|
|
&& !parameters->target().is_defined_by_abi(sym)
|
2009-02-28 05:39:57 +01:00
|
|
|
&& !sym->object()->is_in_system_directory())
|
2007-11-14 17:53:25 +01:00
|
|
|
{
|
|
|
|
// A very ugly cast.
|
|
|
|
Dynobj* dynobj = static_cast<Dynobj*>(sym->object());
|
|
|
|
if (!dynobj->has_unknown_needed_entries())
|
2009-02-06 20:20:10 +01:00
|
|
|
gold_undefined_symbol(sym);
|
2007-11-14 17:53:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
// Write out a section symbol. Return the update offset.
|
|
|
|
|
|
|
|
void
|
2010-08-25 10:36:54 +02:00
|
|
|
Symbol_table::write_section_symbol(const Output_section* os,
|
2008-04-19 20:30:58 +02:00
|
|
|
Output_symtab_xindex* symtab_xindex,
|
2006-11-29 18:56:40 +01:00
|
|
|
Output_file* of,
|
|
|
|
off_t offset) const
|
|
|
|
{
|
2008-02-28 01:18:24 +01:00
|
|
|
switch (parameters->size_and_endianness())
|
2006-11-29 18:56:40 +01:00
|
|
|
{
|
2007-09-26 09:01:35 +02:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
2008-02-28 01:18:24 +01:00
|
|
|
case Parameters::TARGET_32_LITTLE:
|
2008-04-19 20:30:58 +02:00
|
|
|
this->sized_write_section_symbol<32, false>(os, symtab_xindex, of,
|
|
|
|
offset);
|
2008-02-28 01:18:24 +01:00
|
|
|
break;
|
2007-09-26 09:01:35 +02:00
|
|
|
#endif
|
2008-02-28 01:18:24 +01:00
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
|
|
|
case Parameters::TARGET_32_BIG:
|
2008-04-19 20:30:58 +02:00
|
|
|
this->sized_write_section_symbol<32, true>(os, symtab_xindex, of,
|
|
|
|
offset);
|
2008-02-28 01:18:24 +01:00
|
|
|
break;
|
2007-09-26 09:01:35 +02:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
2008-02-28 01:18:24 +01:00
|
|
|
case Parameters::TARGET_64_LITTLE:
|
2008-04-19 20:30:58 +02:00
|
|
|
this->sized_write_section_symbol<64, false>(os, symtab_xindex, of,
|
|
|
|
offset);
|
2008-02-28 01:18:24 +01:00
|
|
|
break;
|
2007-09-26 09:01:35 +02:00
|
|
|
#endif
|
2008-02-28 01:18:24 +01:00
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
|
|
|
case Parameters::TARGET_64_BIG:
|
2008-04-19 20:30:58 +02:00
|
|
|
this->sized_write_section_symbol<64, true>(os, symtab_xindex, of,
|
|
|
|
offset);
|
2008-02-28 01:18:24 +01:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
gold_unreachable();
|
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
|
|
|
|
Symbol_table::sized_write_section_symbol(const Output_section* os,
|
2008-04-19 20:30:58 +02:00
|
|
|
Output_symtab_xindex* symtab_xindex,
|
2006-11-29 18:56:40 +01:00
|
|
|
Output_file* of,
|
|
|
|
off_t offset) const
|
|
|
|
{
|
|
|
|
const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
|
|
|
|
|
|
|
|
unsigned char* pov = of->get_output_view(offset, sym_size);
|
|
|
|
|
|
|
|
elfcpp::Sym_write<size, big_endian> osym(pov);
|
|
|
|
osym.put_st_name(0);
|
2009-02-28 18:53:16 +01:00
|
|
|
if (parameters->options().relocatable())
|
|
|
|
osym.put_st_value(0);
|
|
|
|
else
|
|
|
|
osym.put_st_value(os->address());
|
2006-11-29 18:56:40 +01:00
|
|
|
osym.put_st_size(0);
|
|
|
|
osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL,
|
|
|
|
elfcpp::STT_SECTION));
|
|
|
|
osym.put_st_other(elfcpp::elf_st_other(elfcpp::STV_DEFAULT, 0));
|
2008-04-19 20:30:58 +02:00
|
|
|
|
2009-12-14 20:53:05 +01:00
|
|
|
unsigned int shndx = os->out_shndx();
|
|
|
|
if (shndx >= elfcpp::SHN_LORESERVE)
|
2008-04-19 20:30:58 +02:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
symtab_xindex->add(os->symtab_index(), shndx);
|
|
|
|
shndx = elfcpp::SHN_XINDEX;
|
2008-04-19 20:30:58 +02:00
|
|
|
}
|
2009-12-14 20:53:05 +01:00
|
|
|
osym.put_st_shndx(shndx);
|
2006-11-29 18:56:40 +01:00
|
|
|
|
|
|
|
of->write_output_view(offset, sym_size, pov);
|
|
|
|
}
|
|
|
|
|
2007-12-05 00:11:35 +01:00
|
|
|
// Print statistical information to stderr. This is used for --stats.
|
|
|
|
|
|
|
|
void
|
|
|
|
Symbol_table::print_stats() const
|
|
|
|
{
|
|
|
|
#if defined(HAVE_TR1_UNORDERED_MAP) || defined(HAVE_EXT_HASH_MAP)
|
|
|
|
fprintf(stderr, _("%s: symbol table entries: %zu; buckets: %zu\n"),
|
|
|
|
program_name, this->table_.size(), this->table_.bucket_count());
|
|
|
|
#else
|
|
|
|
fprintf(stderr, _("%s: symbol table entries: %zu\n"),
|
|
|
|
program_name, this->table_.size());
|
|
|
|
#endif
|
2007-12-05 01:48:49 +01:00
|
|
|
this->namepool_.print_stats("symbol table stringpool");
|
2007-12-05 00:11:35 +01:00
|
|
|
}
|
|
|
|
|
2007-11-16 17:54:19 +01:00
|
|
|
// We check for ODR violations by looking for symbols with the same
|
|
|
|
// name for which the debugging information reports that they were
|
2011-03-10 02:31:33 +01:00
|
|
|
// defined in disjoint source locations. When comparing the source
|
2011-02-05 02:52:40 +01:00
|
|
|
// location, we consider instances with the same base filename to be
|
|
|
|
// the same. This is because different object files/shared libraries
|
|
|
|
// can include the same header file using different paths, and
|
|
|
|
// different optimization settings can make the line number appear to
|
|
|
|
// be a couple lines off, and we don't want to report an ODR violation
|
|
|
|
// in those cases.
|
2007-11-16 17:54:19 +01:00
|
|
|
|
|
|
|
// This struct is used to compare line information, as returned by
|
2007-12-06 06:55:50 +01:00
|
|
|
// Dwarf_line_info::one_addr2line. It implements a < comparison
|
2011-03-10 02:31:33 +01:00
|
|
|
// operator used with std::sort.
|
2007-11-16 17:54:19 +01:00
|
|
|
|
|
|
|
struct Odr_violation_compare
|
|
|
|
{
|
|
|
|
bool
|
|
|
|
operator()(const std::string& s1, const std::string& s2) const
|
|
|
|
{
|
2011-02-05 02:52:40 +01:00
|
|
|
// Inputs should be of the form "dirname/filename:linenum" where
|
2011-03-10 02:31:33 +01:00
|
|
|
// "dirname/" is optional. We want to compare just the filename:linenum.
|
2011-02-05 02:52:40 +01:00
|
|
|
|
2011-03-10 02:31:33 +01:00
|
|
|
// Find the last '/' in each string.
|
2011-02-05 02:52:40 +01:00
|
|
|
std::string::size_type s1begin = s1.rfind('/');
|
|
|
|
std::string::size_type s2begin = s2.rfind('/');
|
|
|
|
// If there was no '/' in a string, start at the beginning.
|
|
|
|
if (s1begin == std::string::npos)
|
|
|
|
s1begin = 0;
|
|
|
|
if (s2begin == std::string::npos)
|
|
|
|
s2begin = 0;
|
2011-03-10 02:31:33 +01:00
|
|
|
return s1.compare(s1begin, std::string::npos,
|
|
|
|
s2, s2begin, std::string::npos) < 0;
|
2007-11-16 17:54:19 +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.
|
|
|
|
std::vector<std::string>
|
|
|
|
Symbol_table::linenos_from_loc(const Task* task,
|
|
|
|
const Symbol_location& loc)
|
|
|
|
{
|
|
|
|
// We need to lock the object in order to read it. This
|
|
|
|
// means that we have to run in a singleton Task. If we
|
|
|
|
// want to run this in a general Task for better
|
|
|
|
// performance, we will need one Task for object, plus
|
|
|
|
// appropriate locking to ensure that we don't conflict with
|
|
|
|
// other uses of the object. Also note, one_addr2line is not
|
|
|
|
// currently thread-safe.
|
|
|
|
Task_lock_obj<Object> tl(task, loc.object);
|
|
|
|
|
|
|
|
std::vector<std::string> result;
|
2013-03-11 00:08:18 +01:00
|
|
|
Symbol_location code_loc = loc;
|
|
|
|
parameters->target().function_location(&code_loc);
|
2011-03-10 02:31:33 +01:00
|
|
|
// 16 is the size of the object-cache that one_addr2line should use.
|
|
|
|
std::string canonical_result = Dwarf_line_info::one_addr2line(
|
2013-03-11 00:08:18 +01:00
|
|
|
code_loc.object, code_loc.shndx, code_loc.offset, 16, &result);
|
2011-03-10 02:31:33 +01:00
|
|
|
if (!canonical_result.empty())
|
|
|
|
result.push_back(canonical_result);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// OutputIterator that records if it was ever assigned to. This
|
|
|
|
// allows it to be used with std::set_intersection() to check for
|
|
|
|
// intersection rather than computing the intersection.
|
|
|
|
struct Check_intersection
|
|
|
|
{
|
|
|
|
Check_intersection()
|
|
|
|
: value_(false)
|
|
|
|
{}
|
|
|
|
|
|
|
|
bool had_intersection() const
|
|
|
|
{ return this->value_; }
|
|
|
|
|
|
|
|
Check_intersection& operator++()
|
|
|
|
{ return *this; }
|
|
|
|
|
|
|
|
Check_intersection& operator*()
|
|
|
|
{ return *this; }
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
Check_intersection& operator=(const T&)
|
|
|
|
{
|
|
|
|
this->value_ = true;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool value_;
|
|
|
|
};
|
|
|
|
|
2007-11-13 21:02:32 +01:00
|
|
|
// Check candidate_odr_violations_ to find symbols with the same name
|
2011-03-10 02:31:33 +01:00
|
|
|
// but apparently different definitions (different source-file/line-no
|
|
|
|
// for each line assigned to the first instruction).
|
2007-11-13 21:02:32 +01:00
|
|
|
|
|
|
|
void
|
2007-12-14 20:00:21 +01:00
|
|
|
Symbol_table::detect_odr_violations(const Task* task,
|
|
|
|
const char* output_file_name) const
|
2007-11-13 21:02:32 +01:00
|
|
|
{
|
|
|
|
for (Odr_map::const_iterator it = candidate_odr_violations_.begin();
|
|
|
|
it != candidate_odr_violations_.end();
|
|
|
|
++it)
|
|
|
|
{
|
2011-03-10 02:31:33 +01:00
|
|
|
const char* const symbol_name = it->first;
|
|
|
|
|
|
|
|
std::string first_object_name;
|
|
|
|
std::vector<std::string> first_object_linenos;
|
|
|
|
|
|
|
|
Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator
|
|
|
|
locs = it->second.begin();
|
|
|
|
const Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator
|
|
|
|
locs_end = it->second.end();
|
|
|
|
for (; locs != locs_end && first_object_linenos.empty(); ++locs)
|
2007-11-13 21:02:32 +01:00
|
|
|
{
|
2011-03-10 02:31:33 +01:00
|
|
|
// Save the line numbers from the first definition to
|
|
|
|
// compare to the other definitions. Ideally, we'd compare
|
|
|
|
// every definition to every other, but we don't want to
|
|
|
|
// take O(N^2) time to do this. This shortcut may cause
|
|
|
|
// false negatives that appear or disappear depending on the
|
|
|
|
// link order, but it won't cause false positives.
|
|
|
|
first_object_name = locs->object->name();
|
|
|
|
first_object_linenos = this->linenos_from_loc(task, *locs);
|
2007-11-13 21:02:32 +01:00
|
|
|
}
|
2015-04-09 20:52:21 +02:00
|
|
|
if (first_object_linenos.empty())
|
|
|
|
continue;
|
2007-11-13 21:02:32 +01:00
|
|
|
|
2011-03-10 02:31:33 +01:00
|
|
|
// Sort by Odr_violation_compare to make std::set_intersection work.
|
2015-04-09 20:52:21 +02:00
|
|
|
std::string first_object_canonical_result = first_object_linenos.back();
|
2011-03-10 02:31:33 +01:00
|
|
|
std::sort(first_object_linenos.begin(), first_object_linenos.end(),
|
|
|
|
Odr_violation_compare());
|
|
|
|
|
|
|
|
for (; locs != locs_end; ++locs)
|
2007-11-13 21:02:32 +01:00
|
|
|
{
|
2011-03-10 02:31:33 +01:00
|
|
|
std::vector<std::string> linenos =
|
|
|
|
this->linenos_from_loc(task, *locs);
|
|
|
|
// linenos will be empty if we couldn't parse the debug info.
|
|
|
|
if (linenos.empty())
|
|
|
|
continue;
|
|
|
|
// Sort by Odr_violation_compare to make std::set_intersection work.
|
2015-04-09 20:52:21 +02:00
|
|
|
gold_assert(!linenos.empty());
|
|
|
|
std::string second_object_canonical_result = linenos.back();
|
2011-03-10 02:31:33 +01:00
|
|
|
std::sort(linenos.begin(), linenos.end(), Odr_violation_compare());
|
|
|
|
|
|
|
|
Check_intersection intersection_result =
|
|
|
|
std::set_intersection(first_object_linenos.begin(),
|
|
|
|
first_object_linenos.end(),
|
|
|
|
linenos.begin(),
|
|
|
|
linenos.end(),
|
|
|
|
Check_intersection(),
|
|
|
|
Odr_violation_compare());
|
|
|
|
if (!intersection_result.had_intersection())
|
|
|
|
{
|
|
|
|
gold_warning(_("while linking %s: symbol '%s' defined in "
|
|
|
|
"multiple places (possible ODR violation):"),
|
|
|
|
output_file_name, demangle(symbol_name).c_str());
|
|
|
|
// This only prints one location from each definition,
|
|
|
|
// which may not be the location we expect to intersect
|
|
|
|
// with another definition. We could print the whole
|
|
|
|
// set of locations, but that seems too verbose.
|
|
|
|
fprintf(stderr, _(" %s from %s\n"),
|
2015-04-09 20:52:21 +02:00
|
|
|
first_object_canonical_result.c_str(),
|
2011-03-10 02:31:33 +01:00
|
|
|
first_object_name.c_str());
|
|
|
|
fprintf(stderr, _(" %s from %s\n"),
|
2015-04-09 20:52:21 +02:00
|
|
|
second_object_canonical_result.c_str(),
|
2011-03-10 02:31:33 +01:00
|
|
|
locs->object->name().c_str());
|
|
|
|
// Only print one broken pair, to avoid needing to
|
|
|
|
// compare against a list of the disjoint definition
|
|
|
|
// locations we've found so far. (If we kept comparing
|
|
|
|
// against just the first one, we'd get a lot of
|
|
|
|
// redundant complaints about the second definition
|
|
|
|
// location.)
|
|
|
|
break;
|
|
|
|
}
|
2007-11-13 21:02:32 +01:00
|
|
|
}
|
|
|
|
}
|
2008-05-01 02:25:33 +02:00
|
|
|
// We only call one_addr2line() in this function, so we can clear its cache.
|
|
|
|
Dwarf_line_info::clear_addr2line_cache();
|
2007-11-13 21:02:32 +01:00
|
|
|
}
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
// Warnings functions.
|
|
|
|
|
|
|
|
// Add a new warning.
|
|
|
|
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
Warnings::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
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
name = symtab->canonicalize_name(name);
|
|
|
|
this->warnings_[name].set(obj, warning);
|
2006-11-06 23:46:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Look through the warnings and mark the symbols for which we should
|
|
|
|
// warn. This is called during Layout::finalize when we know the
|
|
|
|
// sources for all the symbols.
|
|
|
|
|
|
|
|
void
|
2008-01-03 00:48:49 +01:00
|
|
|
Warnings::note_warnings(Symbol_table* symtab)
|
2006-11-06 23:46:08 +01:00
|
|
|
{
|
|
|
|
for (Warning_table::iterator p = this->warnings_.begin();
|
|
|
|
p != this->warnings_.end();
|
|
|
|
++p)
|
|
|
|
{
|
|
|
|
Symbol* sym = symtab->lookup(p->first, NULL);
|
|
|
|
if (sym != NULL
|
|
|
|
&& sym->source() == Symbol::FROM_OBJECT
|
|
|
|
&& sym->object() == p->second.object)
|
2008-01-03 00:48:49 +01:00
|
|
|
sym->set_has_warning();
|
2006-11-06 23:46:08 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Issue a warning. This is called when we see a relocation against a
|
|
|
|
// symbol for which has a warning.
|
|
|
|
|
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
|
|
|
Warnings::issue_warning(const Symbol* sym,
|
|
|
|
const Relocate_info<size, big_endian>* relinfo,
|
|
|
|
size_t relnum, off_t reloffset) const
|
2006-11-06 23:46:08 +01:00
|
|
|
{
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(sym->has_warning());
|
2011-06-16 19:55:48 +02:00
|
|
|
|
|
|
|
// We don't want to issue a warning for a relocation against the
|
|
|
|
// symbol in the same object file in which the symbol is defined.
|
|
|
|
if (sym->object() == relinfo->object)
|
|
|
|
return;
|
|
|
|
|
2006-11-06 23:46:08 +01:00
|
|
|
Warning_table::const_iterator p = this->warnings_.find(sym->name());
|
2006-11-29 18:56:40 +01:00
|
|
|
gold_assert(p != this->warnings_.end());
|
2007-10-14 08:49:14 +02:00
|
|
|
gold_warning_at_location(relinfo, relnum, reloffset,
|
|
|
|
"%s", p->second.text.c_str());
|
2006-11-06 23:46:08 +01:00
|
|
|
}
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
// Instantiate the templates we need. We could use the configure
|
|
|
|
// script to restrict this to only the ones needed for implemented
|
|
|
|
// targets.
|
|
|
|
|
2007-11-22 01:05:51 +01:00
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Sized_symbol<32>::allocate_common(Output_data*, Value_type);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Sized_symbol<64>::allocate_common(Output_data*, Value_type);
|
|
|
|
#endif
|
|
|
|
|
2007-09-04 22:00:53 +02:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
2006-08-19 00:29:20 +02:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::add_from_relobj<32, false>(
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<32, false>* relobj,
|
2006-11-06 23:46:08 +01:00
|
|
|
const unsigned char* syms,
|
2006-08-19 00:29:20 +02:00
|
|
|
size_t count,
|
2008-04-19 20:30:58 +02:00
|
|
|
size_t symndx_offset,
|
2006-08-19 00:29:20 +02:00
|
|
|
const char* sym_names,
|
|
|
|
size_t sym_name_size,
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<32, false>::Symbols* sympointers,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2007-09-04 22:00:53 +02:00
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
2006-08-19 00:29:20 +02:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::add_from_relobj<32, true>(
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<32, true>* relobj,
|
2006-11-06 23:46:08 +01:00
|
|
|
const unsigned char* syms,
|
2006-08-19 00:29:20 +02:00
|
|
|
size_t count,
|
2008-04-19 20:30:58 +02:00
|
|
|
size_t symndx_offset,
|
2006-08-19 00:29:20 +02:00
|
|
|
const char* sym_names,
|
|
|
|
size_t sym_name_size,
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<32, true>::Symbols* sympointers,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2007-09-04 22:00:53 +02:00
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
2006-08-19 00:29:20 +02:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::add_from_relobj<64, false>(
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<64, false>* relobj,
|
2006-11-06 23:46:08 +01:00
|
|
|
const unsigned char* syms,
|
2006-08-19 00:29:20 +02:00
|
|
|
size_t count,
|
2008-04-19 20:30:58 +02:00
|
|
|
size_t symndx_offset,
|
2006-08-19 00:29:20 +02:00
|
|
|
const char* sym_names,
|
|
|
|
size_t sym_name_size,
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<64, false>::Symbols* sympointers,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2007-09-04 22:00:53 +02:00
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
2006-08-19 00:29:20 +02:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::add_from_relobj<64, true>(
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<64, true>* relobj,
|
2006-11-06 23:46:08 +01:00
|
|
|
const unsigned char* syms,
|
2006-08-19 00:29:20 +02:00
|
|
|
size_t count,
|
2008-04-19 20:30:58 +02:00
|
|
|
size_t symndx_offset,
|
2006-08-19 00:29:20 +02:00
|
|
|
const char* sym_names,
|
|
|
|
size_t sym_name_size,
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<64, true>::Symbols* sympointers,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-08-19 00:29:20 +02:00
|
|
|
|
2008-09-20 00:54:57 +02:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
|
|
|
template
|
|
|
|
Symbol*
|
|
|
|
Symbol_table::add_from_pluginobj<32, false>(
|
|
|
|
Sized_pluginobj<32, false>* obj,
|
|
|
|
const char* name,
|
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<32, false>* sym);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
|
|
|
template
|
|
|
|
Symbol*
|
|
|
|
Symbol_table::add_from_pluginobj<32, true>(
|
|
|
|
Sized_pluginobj<32, true>* obj,
|
|
|
|
const char* name,
|
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<32, true>* sym);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
|
|
|
template
|
|
|
|
Symbol*
|
|
|
|
Symbol_table::add_from_pluginobj<64, false>(
|
|
|
|
Sized_pluginobj<64, false>* obj,
|
|
|
|
const char* name,
|
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<64, false>* sym);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
|
|
|
template
|
|
|
|
Symbol*
|
|
|
|
Symbol_table::add_from_pluginobj<64, true>(
|
|
|
|
Sized_pluginobj<64, true>* obj,
|
|
|
|
const char* name,
|
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<64, true>* sym);
|
|
|
|
#endif
|
|
|
|
|
2007-09-04 22:00:53 +02:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
2006-11-14 20:21:05 +01:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::add_from_dynobj<32, false>(
|
|
|
|
Sized_dynobj<32, false>* dynobj,
|
2006-11-14 20:21:05 +01:00
|
|
|
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*>* version_map,
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<32, false>::Symbols* sympointers,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-09-04 22:00:53 +02:00
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
2006-11-14 20:21:05 +01:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::add_from_dynobj<32, true>(
|
|
|
|
Sized_dynobj<32, true>* dynobj,
|
2006-11-14 20:21:05 +01:00
|
|
|
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*>* version_map,
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<32, true>::Symbols* sympointers,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-09-04 22:00:53 +02:00
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
2006-11-14 20:21:05 +01:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::add_from_dynobj<64, false>(
|
|
|
|
Sized_dynobj<64, false>* dynobj,
|
2006-11-14 20:21:05 +01:00
|
|
|
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*>* version_map,
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<64, false>::Symbols* sympointers,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2007-09-04 22:00:53 +02:00
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
2006-11-14 20:21:05 +01:00
|
|
|
template
|
|
|
|
void
|
2007-09-04 22:00:53 +02:00
|
|
|
Symbol_table::add_from_dynobj<64, true>(
|
|
|
|
Sized_dynobj<64, true>* dynobj,
|
2006-11-14 20:21:05 +01:00
|
|
|
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*>* version_map,
|
2011-05-24 23:41:10 +02:00
|
|
|
Sized_relobj_file<64, true>::Symbols* sympointers,
|
2008-07-23 00:08:43 +02:00
|
|
|
size_t* defined);
|
2007-09-04 22:00:53 +02:00
|
|
|
#endif
|
2006-11-14 20:21:05 +01:00
|
|
|
|
2011-04-12 02:44:48 +02:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
|
|
|
template
|
2011-06-08 05:50:12 +02:00
|
|
|
Sized_symbol<32>*
|
2011-04-12 02:44:48 +02:00
|
|
|
Symbol_table::add_from_incrobj(
|
|
|
|
Object* obj,
|
|
|
|
const char* name,
|
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<32, false>* sym);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
|
|
|
template
|
2011-06-08 05:50:12 +02:00
|
|
|
Sized_symbol<32>*
|
2011-04-12 02:44:48 +02:00
|
|
|
Symbol_table::add_from_incrobj(
|
|
|
|
Object* obj,
|
|
|
|
const char* name,
|
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<32, true>* sym);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
|
|
|
template
|
2011-06-08 05:50:12 +02:00
|
|
|
Sized_symbol<64>*
|
2011-04-12 02:44:48 +02:00
|
|
|
Symbol_table::add_from_incrobj(
|
|
|
|
Object* obj,
|
|
|
|
const char* name,
|
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<64, false>* sym);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
|
|
|
template
|
2011-06-08 05:50:12 +02:00
|
|
|
Sized_symbol<64>*
|
2011-04-12 02:44:48 +02:00
|
|
|
Symbol_table::add_from_incrobj(
|
|
|
|
Object* obj,
|
|
|
|
const char* name,
|
|
|
|
const char* ver,
|
|
|
|
elfcpp::Sym<64, true>* sym);
|
|
|
|
#endif
|
|
|
|
|
2007-10-23 01:08:22 +02:00
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
|
|
|
|
template
|
|
|
|
void
|
2007-12-20 22:21:24 +01:00
|
|
|
Symbol_table::define_with_copy_reloc<32>(
|
|
|
|
Sized_symbol<32>* sym,
|
|
|
|
Output_data* posd,
|
2009-12-14 20:53:05 +01:00
|
|
|
elfcpp::Elf_types<32>::Elf_Addr value);
|
2007-10-23 01:08:22 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
|
|
|
|
template
|
|
|
|
void
|
2007-12-20 22:21:24 +01:00
|
|
|
Symbol_table::define_with_copy_reloc<64>(
|
|
|
|
Sized_symbol<64>* sym,
|
|
|
|
Output_data* posd,
|
2009-12-14 20:53:05 +01:00
|
|
|
elfcpp::Elf_types<64>::Elf_Addr value);
|
2007-10-23 01:08:22 +02:00
|
|
|
#endif
|
|
|
|
|
2014-03-10 21:36:40 +01:00
|
|
|
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Sized_symbol<32>::init_output_data(const char* name, const char* version,
|
|
|
|
Output_data* od, Value_type value,
|
|
|
|
Size_type symsize, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis,
|
|
|
|
bool offset_is_from_end,
|
|
|
|
bool is_predefined);
|
2016-03-04 17:10:57 +01:00
|
|
|
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Sized_symbol<32>::init_constant(const char* name, const char* version,
|
|
|
|
Value_type value, Size_type symsize,
|
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility, unsigned char nonvis,
|
|
|
|
bool is_predefined);
|
|
|
|
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Sized_symbol<32>::init_undefined(const char* name, const char* version,
|
|
|
|
Value_type value, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding, elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis);
|
2014-03-10 21:36:40 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Sized_symbol<64>::init_output_data(const char* name, const char* version,
|
|
|
|
Output_data* od, Value_type value,
|
|
|
|
Size_type symsize, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis,
|
|
|
|
bool offset_is_from_end,
|
|
|
|
bool is_predefined);
|
2016-03-04 17:10:57 +01:00
|
|
|
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Sized_symbol<64>::init_constant(const char* name, const char* version,
|
|
|
|
Value_type value, Size_type symsize,
|
|
|
|
elfcpp::STT type, elfcpp::STB binding,
|
|
|
|
elfcpp::STV visibility, unsigned char nonvis,
|
|
|
|
bool is_predefined);
|
|
|
|
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Sized_symbol<64>::init_undefined(const char* name, const char* version,
|
|
|
|
Value_type value, elfcpp::STT type,
|
|
|
|
elfcpp::STB binding, elfcpp::STV visibility,
|
|
|
|
unsigned char nonvis);
|
2014-03-10 21:36:40 +01:00
|
|
|
#endif
|
|
|
|
|
2007-10-14 08:49:14 +02:00
|
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Warnings::issue_warning<32, false>(const Symbol* sym,
|
|
|
|
const Relocate_info<32, false>* relinfo,
|
|
|
|
size_t relnum, off_t reloffset) const;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TARGET_32_BIG
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Warnings::issue_warning<32, true>(const Symbol* sym,
|
|
|
|
const Relocate_info<32, true>* relinfo,
|
|
|
|
size_t relnum, off_t reloffset) const;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Warnings::issue_warning<64, false>(const Symbol* sym,
|
|
|
|
const Relocate_info<64, false>* relinfo,
|
|
|
|
size_t relnum, off_t reloffset) const;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_TARGET_64_BIG
|
|
|
|
template
|
|
|
|
void
|
|
|
|
Warnings::issue_warning<64, true>(const Symbol* sym,
|
|
|
|
const Relocate_info<64, true>* relinfo,
|
|
|
|
size_t relnum, off_t reloffset) const;
|
|
|
|
#endif
|
|
|
|
|
2006-08-19 00:29:20 +02:00
|
|
|
} // End namespace gold.
|