1*fae548d3Szrj // symtab.cc -- the gold symbol table
2*fae548d3Szrj
3*fae548d3Szrj // Copyright (C) 2006-2020 Free Software Foundation, Inc.
4*fae548d3Szrj // Written by Ian Lance Taylor <iant@google.com>.
5*fae548d3Szrj
6*fae548d3Szrj // This file is part of gold.
7*fae548d3Szrj
8*fae548d3Szrj // This program is free software; you can redistribute it and/or modify
9*fae548d3Szrj // it under the terms of the GNU General Public License as published by
10*fae548d3Szrj // the Free Software Foundation; either version 3 of the License, or
11*fae548d3Szrj // (at your option) any later version.
12*fae548d3Szrj
13*fae548d3Szrj // This program is distributed in the hope that it will be useful,
14*fae548d3Szrj // but WITHOUT ANY WARRANTY; without even the implied warranty of
15*fae548d3Szrj // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16*fae548d3Szrj // GNU General Public License for more details.
17*fae548d3Szrj
18*fae548d3Szrj // You should have received a copy of the GNU General Public License
19*fae548d3Szrj // along with this program; if not, write to the Free Software
20*fae548d3Szrj // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21*fae548d3Szrj // MA 02110-1301, USA.
22*fae548d3Szrj
23*fae548d3Szrj #include "gold.h"
24*fae548d3Szrj
25*fae548d3Szrj #include <cstring>
26*fae548d3Szrj #include <stdint.h>
27*fae548d3Szrj #include <algorithm>
28*fae548d3Szrj #include <set>
29*fae548d3Szrj #include <string>
30*fae548d3Szrj #include <utility>
31*fae548d3Szrj #include "demangle.h"
32*fae548d3Szrj
33*fae548d3Szrj #include "gc.h"
34*fae548d3Szrj #include "object.h"
35*fae548d3Szrj #include "dwarf_reader.h"
36*fae548d3Szrj #include "dynobj.h"
37*fae548d3Szrj #include "output.h"
38*fae548d3Szrj #include "target.h"
39*fae548d3Szrj #include "workqueue.h"
40*fae548d3Szrj #include "symtab.h"
41*fae548d3Szrj #include "script.h"
42*fae548d3Szrj #include "plugin.h"
43*fae548d3Szrj #include "incremental.h"
44*fae548d3Szrj
45*fae548d3Szrj namespace gold
46*fae548d3Szrj {
47*fae548d3Szrj
48*fae548d3Szrj // Class Symbol.
49*fae548d3Szrj
50*fae548d3Szrj // Initialize fields in Symbol. This initializes everything except
51*fae548d3Szrj // u1_, u2_ and source_.
52*fae548d3Szrj
53*fae548d3Szrj void
init_fields(const char * name,const char * version,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis)54*fae548d3Szrj Symbol::init_fields(const char* name, const char* version,
55*fae548d3Szrj elfcpp::STT type, elfcpp::STB binding,
56*fae548d3Szrj elfcpp::STV visibility, unsigned char nonvis)
57*fae548d3Szrj {
58*fae548d3Szrj this->name_ = name;
59*fae548d3Szrj this->version_ = version;
60*fae548d3Szrj this->symtab_index_ = 0;
61*fae548d3Szrj this->dynsym_index_ = 0;
62*fae548d3Szrj this->got_offsets_.init();
63*fae548d3Szrj this->plt_offset_ = -1U;
64*fae548d3Szrj this->type_ = type;
65*fae548d3Szrj this->binding_ = binding;
66*fae548d3Szrj this->visibility_ = visibility;
67*fae548d3Szrj this->nonvis_ = nonvis;
68*fae548d3Szrj this->is_def_ = false;
69*fae548d3Szrj this->is_forwarder_ = false;
70*fae548d3Szrj this->has_alias_ = false;
71*fae548d3Szrj this->needs_dynsym_entry_ = false;
72*fae548d3Szrj this->in_reg_ = false;
73*fae548d3Szrj this->in_dyn_ = false;
74*fae548d3Szrj this->has_warning_ = false;
75*fae548d3Szrj this->is_copied_from_dynobj_ = false;
76*fae548d3Szrj this->is_forced_local_ = false;
77*fae548d3Szrj this->is_ordinary_shndx_ = false;
78*fae548d3Szrj this->in_real_elf_ = false;
79*fae548d3Szrj this->is_defined_in_discarded_section_ = false;
80*fae548d3Szrj this->undef_binding_set_ = false;
81*fae548d3Szrj this->undef_binding_weak_ = false;
82*fae548d3Szrj this->is_predefined_ = false;
83*fae548d3Szrj this->is_protected_ = false;
84*fae548d3Szrj this->non_zero_localentry_ = false;
85*fae548d3Szrj }
86*fae548d3Szrj
87*fae548d3Szrj // Return the demangled version of the symbol's name, but only
88*fae548d3Szrj // if the --demangle flag was set.
89*fae548d3Szrj
90*fae548d3Szrj static std::string
demangle(const char * name)91*fae548d3Szrj demangle(const char* name)
92*fae548d3Szrj {
93*fae548d3Szrj if (!parameters->options().do_demangle())
94*fae548d3Szrj return name;
95*fae548d3Szrj
96*fae548d3Szrj // cplus_demangle allocates memory for the result it returns,
97*fae548d3Szrj // and returns NULL if the name is already demangled.
98*fae548d3Szrj char* demangled_name = cplus_demangle(name, DMGL_ANSI | DMGL_PARAMS);
99*fae548d3Szrj if (demangled_name == NULL)
100*fae548d3Szrj return name;
101*fae548d3Szrj
102*fae548d3Szrj std::string retval(demangled_name);
103*fae548d3Szrj free(demangled_name);
104*fae548d3Szrj return retval;
105*fae548d3Szrj }
106*fae548d3Szrj
107*fae548d3Szrj std::string
demangled_name() const108*fae548d3Szrj Symbol::demangled_name() const
109*fae548d3Szrj {
110*fae548d3Szrj return demangle(this->name());
111*fae548d3Szrj }
112*fae548d3Szrj
113*fae548d3Szrj // Initialize the fields in the base class Symbol for SYM in OBJECT.
114*fae548d3Szrj
115*fae548d3Szrj template<int size, bool big_endian>
116*fae548d3Szrj void
init_base_object(const char * name,const char * version,Object * object,const elfcpp::Sym<size,big_endian> & sym,unsigned int st_shndx,bool is_ordinary)117*fae548d3Szrj Symbol::init_base_object(const char* name, const char* version, Object* object,
118*fae548d3Szrj const elfcpp::Sym<size, big_endian>& sym,
119*fae548d3Szrj unsigned int st_shndx, bool is_ordinary)
120*fae548d3Szrj {
121*fae548d3Szrj this->init_fields(name, version, sym.get_st_type(), sym.get_st_bind(),
122*fae548d3Szrj sym.get_st_visibility(), sym.get_st_nonvis());
123*fae548d3Szrj this->u1_.object = object;
124*fae548d3Szrj this->u2_.shndx = st_shndx;
125*fae548d3Szrj this->is_ordinary_shndx_ = is_ordinary;
126*fae548d3Szrj this->source_ = FROM_OBJECT;
127*fae548d3Szrj this->in_reg_ = !object->is_dynamic();
128*fae548d3Szrj this->in_dyn_ = object->is_dynamic();
129*fae548d3Szrj this->in_real_elf_ = object->pluginobj() == NULL;
130*fae548d3Szrj }
131*fae548d3Szrj
132*fae548d3Szrj // Initialize the fields in the base class Symbol for a symbol defined
133*fae548d3Szrj // in an Output_data.
134*fae548d3Szrj
135*fae548d3Szrj void
init_base_output_data(const char * name,const char * version,Output_data * od,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis,bool offset_is_from_end,bool is_predefined)136*fae548d3Szrj Symbol::init_base_output_data(const char* name, const char* version,
137*fae548d3Szrj Output_data* od, elfcpp::STT type,
138*fae548d3Szrj elfcpp::STB binding, elfcpp::STV visibility,
139*fae548d3Szrj unsigned char nonvis, bool offset_is_from_end,
140*fae548d3Szrj bool is_predefined)
141*fae548d3Szrj {
142*fae548d3Szrj this->init_fields(name, version, type, binding, visibility, nonvis);
143*fae548d3Szrj this->u1_.output_data = od;
144*fae548d3Szrj this->u2_.offset_is_from_end = offset_is_from_end;
145*fae548d3Szrj this->source_ = IN_OUTPUT_DATA;
146*fae548d3Szrj this->in_reg_ = true;
147*fae548d3Szrj this->in_real_elf_ = true;
148*fae548d3Szrj this->is_predefined_ = is_predefined;
149*fae548d3Szrj }
150*fae548d3Szrj
151*fae548d3Szrj // Initialize the fields in the base class Symbol for a symbol defined
152*fae548d3Szrj // in an Output_segment.
153*fae548d3Szrj
154*fae548d3Szrj void
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,Segment_offset_base offset_base,bool is_predefined)155*fae548d3Szrj Symbol::init_base_output_segment(const char* name, const char* version,
156*fae548d3Szrj Output_segment* os, elfcpp::STT type,
157*fae548d3Szrj elfcpp::STB binding, elfcpp::STV visibility,
158*fae548d3Szrj unsigned char nonvis,
159*fae548d3Szrj Segment_offset_base offset_base,
160*fae548d3Szrj bool is_predefined)
161*fae548d3Szrj {
162*fae548d3Szrj this->init_fields(name, version, type, binding, visibility, nonvis);
163*fae548d3Szrj this->u1_.output_segment = os;
164*fae548d3Szrj this->u2_.offset_base = offset_base;
165*fae548d3Szrj this->source_ = IN_OUTPUT_SEGMENT;
166*fae548d3Szrj this->in_reg_ = true;
167*fae548d3Szrj this->in_real_elf_ = true;
168*fae548d3Szrj this->is_predefined_ = is_predefined;
169*fae548d3Szrj }
170*fae548d3Szrj
171*fae548d3Szrj // Initialize the fields in the base class Symbol for a symbol defined
172*fae548d3Szrj // as a constant.
173*fae548d3Szrj
174*fae548d3Szrj void
init_base_constant(const char * name,const char * version,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis,bool is_predefined)175*fae548d3Szrj Symbol::init_base_constant(const char* name, const char* version,
176*fae548d3Szrj elfcpp::STT type, elfcpp::STB binding,
177*fae548d3Szrj elfcpp::STV visibility, unsigned char nonvis,
178*fae548d3Szrj bool is_predefined)
179*fae548d3Szrj {
180*fae548d3Szrj this->init_fields(name, version, type, binding, visibility, nonvis);
181*fae548d3Szrj this->source_ = IS_CONSTANT;
182*fae548d3Szrj this->in_reg_ = true;
183*fae548d3Szrj this->in_real_elf_ = true;
184*fae548d3Szrj this->is_predefined_ = is_predefined;
185*fae548d3Szrj }
186*fae548d3Szrj
187*fae548d3Szrj // Initialize the fields in the base class Symbol for an undefined
188*fae548d3Szrj // symbol.
189*fae548d3Szrj
190*fae548d3Szrj void
init_base_undefined(const char * name,const char * version,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis)191*fae548d3Szrj Symbol::init_base_undefined(const char* name, const char* version,
192*fae548d3Szrj elfcpp::STT type, elfcpp::STB binding,
193*fae548d3Szrj elfcpp::STV visibility, unsigned char nonvis)
194*fae548d3Szrj {
195*fae548d3Szrj this->init_fields(name, version, type, binding, visibility, nonvis);
196*fae548d3Szrj this->dynsym_index_ = -1U;
197*fae548d3Szrj this->source_ = IS_UNDEFINED;
198*fae548d3Szrj this->in_reg_ = true;
199*fae548d3Szrj this->in_real_elf_ = true;
200*fae548d3Szrj }
201*fae548d3Szrj
202*fae548d3Szrj // Allocate a common symbol in the base.
203*fae548d3Szrj
204*fae548d3Szrj void
allocate_base_common(Output_data * od)205*fae548d3Szrj Symbol::allocate_base_common(Output_data* od)
206*fae548d3Szrj {
207*fae548d3Szrj gold_assert(this->is_common());
208*fae548d3Szrj this->source_ = IN_OUTPUT_DATA;
209*fae548d3Szrj this->u1_.output_data = od;
210*fae548d3Szrj this->u2_.offset_is_from_end = false;
211*fae548d3Szrj }
212*fae548d3Szrj
213*fae548d3Szrj // Initialize the fields in Sized_symbol for SYM in OBJECT.
214*fae548d3Szrj
215*fae548d3Szrj template<int size>
216*fae548d3Szrj template<bool big_endian>
217*fae548d3Szrj void
init_object(const char * name,const char * version,Object * object,const elfcpp::Sym<size,big_endian> & sym,unsigned int st_shndx,bool is_ordinary)218*fae548d3Szrj Sized_symbol<size>::init_object(const char* name, const char* version,
219*fae548d3Szrj Object* object,
220*fae548d3Szrj const elfcpp::Sym<size, big_endian>& sym,
221*fae548d3Szrj unsigned int st_shndx, bool is_ordinary)
222*fae548d3Szrj {
223*fae548d3Szrj this->init_base_object(name, version, object, sym, st_shndx, is_ordinary);
224*fae548d3Szrj this->value_ = sym.get_st_value();
225*fae548d3Szrj this->symsize_ = sym.get_st_size();
226*fae548d3Szrj }
227*fae548d3Szrj
228*fae548d3Szrj // Initialize the fields in Sized_symbol for a symbol defined in an
229*fae548d3Szrj // Output_data.
230*fae548d3Szrj
231*fae548d3Szrj template<int size>
232*fae548d3Szrj void
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)233*fae548d3Szrj Sized_symbol<size>::init_output_data(const char* name, const char* version,
234*fae548d3Szrj Output_data* od, Value_type value,
235*fae548d3Szrj Size_type symsize, elfcpp::STT type,
236*fae548d3Szrj elfcpp::STB binding,
237*fae548d3Szrj elfcpp::STV visibility,
238*fae548d3Szrj unsigned char nonvis,
239*fae548d3Szrj bool offset_is_from_end,
240*fae548d3Szrj bool is_predefined)
241*fae548d3Szrj {
242*fae548d3Szrj this->init_base_output_data(name, version, od, type, binding, visibility,
243*fae548d3Szrj nonvis, offset_is_from_end, is_predefined);
244*fae548d3Szrj this->value_ = value;
245*fae548d3Szrj this->symsize_ = symsize;
246*fae548d3Szrj }
247*fae548d3Szrj
248*fae548d3Szrj // Initialize the fields in Sized_symbol for a symbol defined in an
249*fae548d3Szrj // Output_segment.
250*fae548d3Szrj
251*fae548d3Szrj template<int size>
252*fae548d3Szrj void
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,Segment_offset_base offset_base,bool is_predefined)253*fae548d3Szrj Sized_symbol<size>::init_output_segment(const char* name, const char* version,
254*fae548d3Szrj Output_segment* os, Value_type value,
255*fae548d3Szrj Size_type symsize, elfcpp::STT type,
256*fae548d3Szrj elfcpp::STB binding,
257*fae548d3Szrj elfcpp::STV visibility,
258*fae548d3Szrj unsigned char nonvis,
259*fae548d3Szrj Segment_offset_base offset_base,
260*fae548d3Szrj bool is_predefined)
261*fae548d3Szrj {
262*fae548d3Szrj this->init_base_output_segment(name, version, os, type, binding, visibility,
263*fae548d3Szrj nonvis, offset_base, is_predefined);
264*fae548d3Szrj this->value_ = value;
265*fae548d3Szrj this->symsize_ = symsize;
266*fae548d3Szrj }
267*fae548d3Szrj
268*fae548d3Szrj // Initialize the fields in Sized_symbol for a symbol defined as a
269*fae548d3Szrj // constant.
270*fae548d3Szrj
271*fae548d3Szrj template<int size>
272*fae548d3Szrj void
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)273*fae548d3Szrj Sized_symbol<size>::init_constant(const char* name, const char* version,
274*fae548d3Szrj Value_type value, Size_type symsize,
275*fae548d3Szrj elfcpp::STT type, elfcpp::STB binding,
276*fae548d3Szrj elfcpp::STV visibility, unsigned char nonvis,
277*fae548d3Szrj bool is_predefined)
278*fae548d3Szrj {
279*fae548d3Szrj this->init_base_constant(name, version, type, binding, visibility, nonvis,
280*fae548d3Szrj is_predefined);
281*fae548d3Szrj this->value_ = value;
282*fae548d3Szrj this->symsize_ = symsize;
283*fae548d3Szrj }
284*fae548d3Szrj
285*fae548d3Szrj // Initialize the fields in Sized_symbol for an undefined symbol.
286*fae548d3Szrj
287*fae548d3Szrj template<int size>
288*fae548d3Szrj void
init_undefined(const char * name,const char * version,Value_type value,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis)289*fae548d3Szrj Sized_symbol<size>::init_undefined(const char* name, const char* version,
290*fae548d3Szrj Value_type value, elfcpp::STT type,
291*fae548d3Szrj elfcpp::STB binding, elfcpp::STV visibility,
292*fae548d3Szrj unsigned char nonvis)
293*fae548d3Szrj {
294*fae548d3Szrj this->init_base_undefined(name, version, type, binding, visibility, nonvis);
295*fae548d3Szrj this->value_ = value;
296*fae548d3Szrj this->symsize_ = 0;
297*fae548d3Szrj }
298*fae548d3Szrj
299*fae548d3Szrj // Return an allocated string holding the symbol's name as
300*fae548d3Szrj // name@version. This is used for relocatable links.
301*fae548d3Szrj
302*fae548d3Szrj std::string
versioned_name() const303*fae548d3Szrj Symbol::versioned_name() const
304*fae548d3Szrj {
305*fae548d3Szrj gold_assert(this->version_ != NULL);
306*fae548d3Szrj std::string ret = this->name_;
307*fae548d3Szrj ret.push_back('@');
308*fae548d3Szrj if (this->is_def_)
309*fae548d3Szrj ret.push_back('@');
310*fae548d3Szrj ret += this->version_;
311*fae548d3Szrj return ret;
312*fae548d3Szrj }
313*fae548d3Szrj
314*fae548d3Szrj // Return true if SHNDX represents a common symbol.
315*fae548d3Szrj
316*fae548d3Szrj bool
is_common_shndx(unsigned int shndx)317*fae548d3Szrj Symbol::is_common_shndx(unsigned int shndx)
318*fae548d3Szrj {
319*fae548d3Szrj return (shndx == elfcpp::SHN_COMMON
320*fae548d3Szrj || shndx == parameters->target().small_common_shndx()
321*fae548d3Szrj || shndx == parameters->target().large_common_shndx());
322*fae548d3Szrj }
323*fae548d3Szrj
324*fae548d3Szrj // Allocate a common symbol.
325*fae548d3Szrj
326*fae548d3Szrj template<int size>
327*fae548d3Szrj void
allocate_common(Output_data * od,Value_type value)328*fae548d3Szrj Sized_symbol<size>::allocate_common(Output_data* od, Value_type value)
329*fae548d3Szrj {
330*fae548d3Szrj this->allocate_base_common(od);
331*fae548d3Szrj this->value_ = value;
332*fae548d3Szrj }
333*fae548d3Szrj
334*fae548d3Szrj // The ""'s around str ensure str is a string literal, so sizeof works.
335*fae548d3Szrj #define strprefix(var, str) (strncmp(var, str, sizeof("" str "") - 1) == 0)
336*fae548d3Szrj
337*fae548d3Szrj // Return true if this symbol should be added to the dynamic symbol
338*fae548d3Szrj // table.
339*fae548d3Szrj
340*fae548d3Szrj bool
should_add_dynsym_entry(Symbol_table * symtab) const341*fae548d3Szrj Symbol::should_add_dynsym_entry(Symbol_table* symtab) const
342*fae548d3Szrj {
343*fae548d3Szrj // If the symbol is only present on plugin files, the plugin decided we
344*fae548d3Szrj // don't need it.
345*fae548d3Szrj if (!this->in_real_elf())
346*fae548d3Szrj return false;
347*fae548d3Szrj
348*fae548d3Szrj // If the symbol is used by a dynamic relocation, we need to add it.
349*fae548d3Szrj if (this->needs_dynsym_entry())
350*fae548d3Szrj return true;
351*fae548d3Szrj
352*fae548d3Szrj // If this symbol's section is not added, the symbol need not be added.
353*fae548d3Szrj // The section may have been GCed. Note that export_dynamic is being
354*fae548d3Szrj // overridden here. This should not be done for shared objects.
355*fae548d3Szrj if (parameters->options().gc_sections()
356*fae548d3Szrj && !parameters->options().shared()
357*fae548d3Szrj && this->source() == Symbol::FROM_OBJECT
358*fae548d3Szrj && !this->object()->is_dynamic())
359*fae548d3Szrj {
360*fae548d3Szrj Relobj* relobj = static_cast<Relobj*>(this->object());
361*fae548d3Szrj bool is_ordinary;
362*fae548d3Szrj unsigned int shndx = this->shndx(&is_ordinary);
363*fae548d3Szrj if (is_ordinary && shndx != elfcpp::SHN_UNDEF
364*fae548d3Szrj && !relobj->is_section_included(shndx)
365*fae548d3Szrj && !symtab->is_section_folded(relobj, shndx))
366*fae548d3Szrj return false;
367*fae548d3Szrj }
368*fae548d3Szrj
369*fae548d3Szrj // If the symbol was forced dynamic in a --dynamic-list file
370*fae548d3Szrj // or an --export-dynamic-symbol option, add it.
371*fae548d3Szrj if (!this->is_from_dynobj()
372*fae548d3Szrj && (parameters->options().in_dynamic_list(this->name())
373*fae548d3Szrj || parameters->options().is_export_dynamic_symbol(this->name())))
374*fae548d3Szrj {
375*fae548d3Szrj if (!this->is_forced_local())
376*fae548d3Szrj return true;
377*fae548d3Szrj gold_warning(_("Cannot export local symbol '%s'"),
378*fae548d3Szrj this->demangled_name().c_str());
379*fae548d3Szrj return false;
380*fae548d3Szrj }
381*fae548d3Szrj
382*fae548d3Szrj // If the symbol was forced local in a version script, do not add it.
383*fae548d3Szrj if (this->is_forced_local())
384*fae548d3Szrj return false;
385*fae548d3Szrj
386*fae548d3Szrj // If dynamic-list-data was specified, add any STT_OBJECT.
387*fae548d3Szrj if (parameters->options().dynamic_list_data()
388*fae548d3Szrj && !this->is_from_dynobj()
389*fae548d3Szrj && this->type() == elfcpp::STT_OBJECT)
390*fae548d3Szrj return true;
391*fae548d3Szrj
392*fae548d3Szrj // If --dynamic-list-cpp-new was specified, add any new/delete symbol.
393*fae548d3Szrj // If --dynamic-list-cpp-typeinfo was specified, add any typeinfo symbols.
394*fae548d3Szrj if ((parameters->options().dynamic_list_cpp_new()
395*fae548d3Szrj || parameters->options().dynamic_list_cpp_typeinfo())
396*fae548d3Szrj && !this->is_from_dynobj())
397*fae548d3Szrj {
398*fae548d3Szrj // TODO(csilvers): We could probably figure out if we're an operator
399*fae548d3Szrj // new/delete or typeinfo without the need to demangle.
400*fae548d3Szrj char* demangled_name = cplus_demangle(this->name(),
401*fae548d3Szrj DMGL_ANSI | DMGL_PARAMS);
402*fae548d3Szrj if (demangled_name == NULL)
403*fae548d3Szrj {
404*fae548d3Szrj // Not a C++ symbol, so it can't satisfy these flags
405*fae548d3Szrj }
406*fae548d3Szrj else if (parameters->options().dynamic_list_cpp_new()
407*fae548d3Szrj && (strprefix(demangled_name, "operator new")
408*fae548d3Szrj || strprefix(demangled_name, "operator delete")))
409*fae548d3Szrj {
410*fae548d3Szrj free(demangled_name);
411*fae548d3Szrj return true;
412*fae548d3Szrj }
413*fae548d3Szrj else if (parameters->options().dynamic_list_cpp_typeinfo()
414*fae548d3Szrj && (strprefix(demangled_name, "typeinfo name for")
415*fae548d3Szrj || strprefix(demangled_name, "typeinfo for")))
416*fae548d3Szrj {
417*fae548d3Szrj free(demangled_name);
418*fae548d3Szrj return true;
419*fae548d3Szrj }
420*fae548d3Szrj else
421*fae548d3Szrj free(demangled_name);
422*fae548d3Szrj }
423*fae548d3Szrj
424*fae548d3Szrj // If exporting all symbols or building a shared library,
425*fae548d3Szrj // or the symbol should be globally unique (GNU_UNIQUE),
426*fae548d3Szrj // and the symbol is defined in a regular object and is
427*fae548d3Szrj // externally visible, we need to add it.
428*fae548d3Szrj if ((parameters->options().export_dynamic()
429*fae548d3Szrj || parameters->options().shared()
430*fae548d3Szrj || (parameters->options().gnu_unique()
431*fae548d3Szrj && this->binding() == elfcpp::STB_GNU_UNIQUE))
432*fae548d3Szrj && !this->is_from_dynobj()
433*fae548d3Szrj && !this->is_undefined()
434*fae548d3Szrj && this->is_externally_visible())
435*fae548d3Szrj return true;
436*fae548d3Szrj
437*fae548d3Szrj return false;
438*fae548d3Szrj }
439*fae548d3Szrj
440*fae548d3Szrj // Return true if the final value of this symbol is known at link
441*fae548d3Szrj // time.
442*fae548d3Szrj
443*fae548d3Szrj bool
final_value_is_known() const444*fae548d3Szrj Symbol::final_value_is_known() const
445*fae548d3Szrj {
446*fae548d3Szrj // If we are not generating an executable, then no final values are
447*fae548d3Szrj // known, since they will change at runtime, with the exception of
448*fae548d3Szrj // TLS symbols in a position-independent executable.
449*fae548d3Szrj if ((parameters->options().output_is_position_independent()
450*fae548d3Szrj || parameters->options().relocatable())
451*fae548d3Szrj && !(this->type() == elfcpp::STT_TLS
452*fae548d3Szrj && parameters->options().pie()))
453*fae548d3Szrj return false;
454*fae548d3Szrj
455*fae548d3Szrj // If the symbol is not from an object file, and is not undefined,
456*fae548d3Szrj // then it is defined, and known.
457*fae548d3Szrj if (this->source_ != FROM_OBJECT)
458*fae548d3Szrj {
459*fae548d3Szrj if (this->source_ != IS_UNDEFINED)
460*fae548d3Szrj return true;
461*fae548d3Szrj }
462*fae548d3Szrj else
463*fae548d3Szrj {
464*fae548d3Szrj // If the symbol is from a dynamic object, then the final value
465*fae548d3Szrj // is not known.
466*fae548d3Szrj if (this->object()->is_dynamic())
467*fae548d3Szrj return false;
468*fae548d3Szrj
469*fae548d3Szrj // If the symbol is not undefined (it is defined or common),
470*fae548d3Szrj // then the final value is known.
471*fae548d3Szrj if (!this->is_undefined())
472*fae548d3Szrj return true;
473*fae548d3Szrj }
474*fae548d3Szrj
475*fae548d3Szrj // If the symbol is undefined, then whether the final value is known
476*fae548d3Szrj // depends on whether we are doing a static link. If we are doing a
477*fae548d3Szrj // dynamic link, then the final value could be filled in at runtime.
478*fae548d3Szrj // This could reasonably be the case for a weak undefined symbol.
479*fae548d3Szrj return parameters->doing_static_link();
480*fae548d3Szrj }
481*fae548d3Szrj
482*fae548d3Szrj // Return the output section where this symbol is defined.
483*fae548d3Szrj
484*fae548d3Szrj Output_section*
output_section() const485*fae548d3Szrj Symbol::output_section() const
486*fae548d3Szrj {
487*fae548d3Szrj switch (this->source_)
488*fae548d3Szrj {
489*fae548d3Szrj case FROM_OBJECT:
490*fae548d3Szrj {
491*fae548d3Szrj unsigned int shndx = this->u2_.shndx;
492*fae548d3Szrj if (shndx != elfcpp::SHN_UNDEF && this->is_ordinary_shndx_)
493*fae548d3Szrj {
494*fae548d3Szrj gold_assert(!this->u1_.object->is_dynamic());
495*fae548d3Szrj gold_assert(this->u1_.object->pluginobj() == NULL);
496*fae548d3Szrj Relobj* relobj = static_cast<Relobj*>(this->u1_.object);
497*fae548d3Szrj return relobj->output_section(shndx);
498*fae548d3Szrj }
499*fae548d3Szrj return NULL;
500*fae548d3Szrj }
501*fae548d3Szrj
502*fae548d3Szrj case IN_OUTPUT_DATA:
503*fae548d3Szrj return this->u1_.output_data->output_section();
504*fae548d3Szrj
505*fae548d3Szrj case IN_OUTPUT_SEGMENT:
506*fae548d3Szrj case IS_CONSTANT:
507*fae548d3Szrj case IS_UNDEFINED:
508*fae548d3Szrj return NULL;
509*fae548d3Szrj
510*fae548d3Szrj default:
511*fae548d3Szrj gold_unreachable();
512*fae548d3Szrj }
513*fae548d3Szrj }
514*fae548d3Szrj
515*fae548d3Szrj // Set the symbol's output section. This is used for symbols defined
516*fae548d3Szrj // in scripts. This should only be called after the symbol table has
517*fae548d3Szrj // been finalized.
518*fae548d3Szrj
519*fae548d3Szrj void
set_output_section(Output_section * os)520*fae548d3Szrj Symbol::set_output_section(Output_section* os)
521*fae548d3Szrj {
522*fae548d3Szrj switch (this->source_)
523*fae548d3Szrj {
524*fae548d3Szrj case FROM_OBJECT:
525*fae548d3Szrj case IN_OUTPUT_DATA:
526*fae548d3Szrj gold_assert(this->output_section() == os);
527*fae548d3Szrj break;
528*fae548d3Szrj case IS_CONSTANT:
529*fae548d3Szrj this->source_ = IN_OUTPUT_DATA;
530*fae548d3Szrj this->u1_.output_data = os;
531*fae548d3Szrj this->u2_.offset_is_from_end = false;
532*fae548d3Szrj break;
533*fae548d3Szrj case IN_OUTPUT_SEGMENT:
534*fae548d3Szrj case IS_UNDEFINED:
535*fae548d3Szrj default:
536*fae548d3Szrj gold_unreachable();
537*fae548d3Szrj }
538*fae548d3Szrj }
539*fae548d3Szrj
540*fae548d3Szrj // Set the symbol's output segment. This is used for pre-defined
541*fae548d3Szrj // symbols whose segments aren't known until after layout is done
542*fae548d3Szrj // (e.g., __ehdr_start).
543*fae548d3Szrj
544*fae548d3Szrj void
set_output_segment(Output_segment * os,Segment_offset_base base)545*fae548d3Szrj Symbol::set_output_segment(Output_segment* os, Segment_offset_base base)
546*fae548d3Szrj {
547*fae548d3Szrj gold_assert(this->is_predefined_);
548*fae548d3Szrj this->source_ = IN_OUTPUT_SEGMENT;
549*fae548d3Szrj this->u1_.output_segment = os;
550*fae548d3Szrj this->u2_.offset_base = base;
551*fae548d3Szrj }
552*fae548d3Szrj
553*fae548d3Szrj // Set the symbol to undefined. This is used for pre-defined
554*fae548d3Szrj // symbols whose segments aren't known until after layout is done
555*fae548d3Szrj // (e.g., __ehdr_start).
556*fae548d3Szrj
557*fae548d3Szrj void
set_undefined()558*fae548d3Szrj Symbol::set_undefined()
559*fae548d3Szrj {
560*fae548d3Szrj this->source_ = IS_UNDEFINED;
561*fae548d3Szrj this->is_predefined_ = false;
562*fae548d3Szrj }
563*fae548d3Szrj
564*fae548d3Szrj // Class Symbol_table.
565*fae548d3Szrj
Symbol_table(unsigned int count,const Version_script_info & version_script)566*fae548d3Szrj Symbol_table::Symbol_table(unsigned int count,
567*fae548d3Szrj const Version_script_info& version_script)
568*fae548d3Szrj : saw_undefined_(0), offset_(0), has_gnu_output_(false), table_(count),
569*fae548d3Szrj namepool_(), forwarders_(), commons_(), tls_commons_(), small_commons_(),
570*fae548d3Szrj large_commons_(), forced_locals_(), warnings_(),
571*fae548d3Szrj version_script_(version_script), gc_(NULL), icf_(NULL),
572*fae548d3Szrj target_symbols_()
573*fae548d3Szrj {
574*fae548d3Szrj namepool_.reserve(count);
575*fae548d3Szrj }
576*fae548d3Szrj
~Symbol_table()577*fae548d3Szrj Symbol_table::~Symbol_table()
578*fae548d3Szrj {
579*fae548d3Szrj }
580*fae548d3Szrj
581*fae548d3Szrj // The symbol table key equality function. This is called with
582*fae548d3Szrj // Stringpool keys.
583*fae548d3Szrj
584*fae548d3Szrj inline bool
operator ()(const Symbol_table_key & k1,const Symbol_table_key & k2) const585*fae548d3Szrj Symbol_table::Symbol_table_eq::operator()(const Symbol_table_key& k1,
586*fae548d3Szrj const Symbol_table_key& k2) const
587*fae548d3Szrj {
588*fae548d3Szrj return k1.first == k2.first && k1.second == k2.second;
589*fae548d3Szrj }
590*fae548d3Szrj
591*fae548d3Szrj bool
is_section_folded(Relobj * obj,unsigned int shndx) const592*fae548d3Szrj Symbol_table::is_section_folded(Relobj* obj, unsigned int shndx) const
593*fae548d3Szrj {
594*fae548d3Szrj return (parameters->options().icf_enabled()
595*fae548d3Szrj && this->icf_->is_section_folded(obj, shndx));
596*fae548d3Szrj }
597*fae548d3Szrj
598*fae548d3Szrj // For symbols that have been listed with a -u or --export-dynamic-symbol
599*fae548d3Szrj // option, add them to the work list to avoid gc'ing them.
600*fae548d3Szrj
601*fae548d3Szrj void
gc_mark_undef_symbols(Layout * layout)602*fae548d3Szrj Symbol_table::gc_mark_undef_symbols(Layout* layout)
603*fae548d3Szrj {
604*fae548d3Szrj for (options::String_set::const_iterator p =
605*fae548d3Szrj parameters->options().undefined_begin();
606*fae548d3Szrj p != parameters->options().undefined_end();
607*fae548d3Szrj ++p)
608*fae548d3Szrj {
609*fae548d3Szrj const char* name = p->c_str();
610*fae548d3Szrj Symbol* sym = this->lookup(name);
611*fae548d3Szrj gold_assert(sym != NULL);
612*fae548d3Szrj if (sym->source() == Symbol::FROM_OBJECT
613*fae548d3Szrj && !sym->object()->is_dynamic())
614*fae548d3Szrj {
615*fae548d3Szrj this->gc_mark_symbol(sym);
616*fae548d3Szrj }
617*fae548d3Szrj }
618*fae548d3Szrj
619*fae548d3Szrj for (options::String_set::const_iterator p =
620*fae548d3Szrj parameters->options().export_dynamic_symbol_begin();
621*fae548d3Szrj p != parameters->options().export_dynamic_symbol_end();
622*fae548d3Szrj ++p)
623*fae548d3Szrj {
624*fae548d3Szrj const char* name = p->c_str();
625*fae548d3Szrj Symbol* sym = this->lookup(name);
626*fae548d3Szrj // It's not an error if a symbol named by --export-dynamic-symbol
627*fae548d3Szrj // is undefined.
628*fae548d3Szrj if (sym != NULL
629*fae548d3Szrj && sym->source() == Symbol::FROM_OBJECT
630*fae548d3Szrj && !sym->object()->is_dynamic())
631*fae548d3Szrj {
632*fae548d3Szrj this->gc_mark_symbol(sym);
633*fae548d3Szrj }
634*fae548d3Szrj }
635*fae548d3Szrj
636*fae548d3Szrj for (Script_options::referenced_const_iterator p =
637*fae548d3Szrj layout->script_options()->referenced_begin();
638*fae548d3Szrj p != layout->script_options()->referenced_end();
639*fae548d3Szrj ++p)
640*fae548d3Szrj {
641*fae548d3Szrj Symbol* sym = this->lookup(p->c_str());
642*fae548d3Szrj gold_assert(sym != NULL);
643*fae548d3Szrj if (sym->source() == Symbol::FROM_OBJECT
644*fae548d3Szrj && !sym->object()->is_dynamic())
645*fae548d3Szrj {
646*fae548d3Szrj this->gc_mark_symbol(sym);
647*fae548d3Szrj }
648*fae548d3Szrj }
649*fae548d3Szrj }
650*fae548d3Szrj
651*fae548d3Szrj void
gc_mark_symbol(Symbol * sym)652*fae548d3Szrj Symbol_table::gc_mark_symbol(Symbol* sym)
653*fae548d3Szrj {
654*fae548d3Szrj // Add the object and section to the work list.
655*fae548d3Szrj bool is_ordinary;
656*fae548d3Szrj unsigned int shndx = sym->shndx(&is_ordinary);
657*fae548d3Szrj if (is_ordinary && shndx != elfcpp::SHN_UNDEF && !sym->object()->is_dynamic())
658*fae548d3Szrj {
659*fae548d3Szrj gold_assert(this->gc_!= NULL);
660*fae548d3Szrj Relobj* relobj = static_cast<Relobj*>(sym->object());
661*fae548d3Szrj this->gc_->worklist().push_back(Section_id(relobj, shndx));
662*fae548d3Szrj }
663*fae548d3Szrj parameters->target().gc_mark_symbol(this, sym);
664*fae548d3Szrj }
665*fae548d3Szrj
666*fae548d3Szrj // When doing garbage collection, keep symbols that have been seen in
667*fae548d3Szrj // dynamic objects.
668*fae548d3Szrj inline void
gc_mark_dyn_syms(Symbol * sym)669*fae548d3Szrj Symbol_table::gc_mark_dyn_syms(Symbol* sym)
670*fae548d3Szrj {
671*fae548d3Szrj if (sym->in_dyn() && sym->source() == Symbol::FROM_OBJECT
672*fae548d3Szrj && !sym->object()->is_dynamic())
673*fae548d3Szrj this->gc_mark_symbol(sym);
674*fae548d3Szrj }
675*fae548d3Szrj
676*fae548d3Szrj // Make TO a symbol which forwards to FROM.
677*fae548d3Szrj
678*fae548d3Szrj void
make_forwarder(Symbol * from,Symbol * to)679*fae548d3Szrj Symbol_table::make_forwarder(Symbol* from, Symbol* to)
680*fae548d3Szrj {
681*fae548d3Szrj gold_assert(from != to);
682*fae548d3Szrj gold_assert(!from->is_forwarder() && !to->is_forwarder());
683*fae548d3Szrj this->forwarders_[from] = to;
684*fae548d3Szrj from->set_forwarder();
685*fae548d3Szrj }
686*fae548d3Szrj
687*fae548d3Szrj // Resolve the forwards from FROM, returning the real symbol.
688*fae548d3Szrj
689*fae548d3Szrj Symbol*
resolve_forwards(const Symbol * from) const690*fae548d3Szrj Symbol_table::resolve_forwards(const Symbol* from) const
691*fae548d3Szrj {
692*fae548d3Szrj gold_assert(from->is_forwarder());
693*fae548d3Szrj Unordered_map<const Symbol*, Symbol*>::const_iterator p =
694*fae548d3Szrj this->forwarders_.find(from);
695*fae548d3Szrj gold_assert(p != this->forwarders_.end());
696*fae548d3Szrj return p->second;
697*fae548d3Szrj }
698*fae548d3Szrj
699*fae548d3Szrj // Look up a symbol by name.
700*fae548d3Szrj
701*fae548d3Szrj Symbol*
lookup(const char * name,const char * version) const702*fae548d3Szrj Symbol_table::lookup(const char* name, const char* version) const
703*fae548d3Szrj {
704*fae548d3Szrj Stringpool::Key name_key;
705*fae548d3Szrj name = this->namepool_.find(name, &name_key);
706*fae548d3Szrj if (name == NULL)
707*fae548d3Szrj return NULL;
708*fae548d3Szrj
709*fae548d3Szrj Stringpool::Key version_key = 0;
710*fae548d3Szrj if (version != NULL)
711*fae548d3Szrj {
712*fae548d3Szrj version = this->namepool_.find(version, &version_key);
713*fae548d3Szrj if (version == NULL)
714*fae548d3Szrj return NULL;
715*fae548d3Szrj }
716*fae548d3Szrj
717*fae548d3Szrj Symbol_table_key key(name_key, version_key);
718*fae548d3Szrj Symbol_table::Symbol_table_type::const_iterator p = this->table_.find(key);
719*fae548d3Szrj if (p == this->table_.end())
720*fae548d3Szrj return NULL;
721*fae548d3Szrj return p->second;
722*fae548d3Szrj }
723*fae548d3Szrj
724*fae548d3Szrj // Resolve a Symbol with another Symbol. This is only used in the
725*fae548d3Szrj // unusual case where there are references to both an unversioned
726*fae548d3Szrj // symbol and a symbol with a version, and we then discover that that
727*fae548d3Szrj // version is the default version. Because this is unusual, we do
728*fae548d3Szrj // this the slow way, by converting back to an ELF symbol.
729*fae548d3Szrj
730*fae548d3Szrj template<int size, bool big_endian>
731*fae548d3Szrj void
resolve(Sized_symbol<size> * to,const Sized_symbol<size> * from)732*fae548d3Szrj Symbol_table::resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from)
733*fae548d3Szrj {
734*fae548d3Szrj unsigned char buf[elfcpp::Elf_sizes<size>::sym_size];
735*fae548d3Szrj elfcpp::Sym_write<size, big_endian> esym(buf);
736*fae548d3Szrj // We don't bother to set the st_name or the st_shndx field.
737*fae548d3Szrj esym.put_st_value(from->value());
738*fae548d3Szrj esym.put_st_size(from->symsize());
739*fae548d3Szrj esym.put_st_info(from->binding(), from->type());
740*fae548d3Szrj esym.put_st_other(from->visibility(), from->nonvis());
741*fae548d3Szrj bool is_ordinary;
742*fae548d3Szrj unsigned int shndx = from->shndx(&is_ordinary);
743*fae548d3Szrj this->resolve(to, esym.sym(), shndx, is_ordinary, shndx, from->object(),
744*fae548d3Szrj from->version(), true);
745*fae548d3Szrj if (from->in_reg())
746*fae548d3Szrj to->set_in_reg();
747*fae548d3Szrj if (from->in_dyn())
748*fae548d3Szrj to->set_in_dyn();
749*fae548d3Szrj if (parameters->options().gc_sections())
750*fae548d3Szrj this->gc_mark_dyn_syms(to);
751*fae548d3Szrj }
752*fae548d3Szrj
753*fae548d3Szrj // Record that a symbol is forced to be local by a version script or
754*fae548d3Szrj // by visibility.
755*fae548d3Szrj
756*fae548d3Szrj void
force_local(Symbol * sym)757*fae548d3Szrj Symbol_table::force_local(Symbol* sym)
758*fae548d3Szrj {
759*fae548d3Szrj if (!sym->is_defined() && !sym->is_common())
760*fae548d3Szrj return;
761*fae548d3Szrj if (sym->is_forced_local())
762*fae548d3Szrj {
763*fae548d3Szrj // We already got this one.
764*fae548d3Szrj return;
765*fae548d3Szrj }
766*fae548d3Szrj sym->set_is_forced_local();
767*fae548d3Szrj this->forced_locals_.push_back(sym);
768*fae548d3Szrj }
769*fae548d3Szrj
770*fae548d3Szrj // Adjust NAME for wrapping, and update *NAME_KEY if necessary. This
771*fae548d3Szrj // is only called for undefined symbols, when at least one --wrap
772*fae548d3Szrj // option was used.
773*fae548d3Szrj
774*fae548d3Szrj const char*
wrap_symbol(const char * name,Stringpool::Key * name_key)775*fae548d3Szrj Symbol_table::wrap_symbol(const char* name, Stringpool::Key* name_key)
776*fae548d3Szrj {
777*fae548d3Szrj // For some targets, we need to ignore a specific character when
778*fae548d3Szrj // wrapping, and add it back later.
779*fae548d3Szrj char prefix = '\0';
780*fae548d3Szrj if (name[0] == parameters->target().wrap_char())
781*fae548d3Szrj {
782*fae548d3Szrj prefix = name[0];
783*fae548d3Szrj ++name;
784*fae548d3Szrj }
785*fae548d3Szrj
786*fae548d3Szrj if (parameters->options().is_wrap(name))
787*fae548d3Szrj {
788*fae548d3Szrj // Turn NAME into __wrap_NAME.
789*fae548d3Szrj std::string s;
790*fae548d3Szrj if (prefix != '\0')
791*fae548d3Szrj s += prefix;
792*fae548d3Szrj s += "__wrap_";
793*fae548d3Szrj s += name;
794*fae548d3Szrj
795*fae548d3Szrj // This will give us both the old and new name in NAMEPOOL_, but
796*fae548d3Szrj // that is OK. Only the versions we need will wind up in the
797*fae548d3Szrj // real string table in the output file.
798*fae548d3Szrj return this->namepool_.add(s.c_str(), true, name_key);
799*fae548d3Szrj }
800*fae548d3Szrj
801*fae548d3Szrj const char* const real_prefix = "__real_";
802*fae548d3Szrj const size_t real_prefix_length = strlen(real_prefix);
803*fae548d3Szrj if (strncmp(name, real_prefix, real_prefix_length) == 0
804*fae548d3Szrj && parameters->options().is_wrap(name + real_prefix_length))
805*fae548d3Szrj {
806*fae548d3Szrj // Turn __real_NAME into NAME.
807*fae548d3Szrj std::string s;
808*fae548d3Szrj if (prefix != '\0')
809*fae548d3Szrj s += prefix;
810*fae548d3Szrj s += name + real_prefix_length;
811*fae548d3Szrj return this->namepool_.add(s.c_str(), true, name_key);
812*fae548d3Szrj }
813*fae548d3Szrj
814*fae548d3Szrj return name;
815*fae548d3Szrj }
816*fae548d3Szrj
817*fae548d3Szrj // This is called when we see a symbol NAME/VERSION, and the symbol
818*fae548d3Szrj // already exists in the symbol table, and VERSION is marked as being
819*fae548d3Szrj // the default version. SYM is the NAME/VERSION symbol we just added.
820*fae548d3Szrj // DEFAULT_IS_NEW is true if this is the first time we have seen the
821*fae548d3Szrj // symbol NAME/NULL. PDEF points to the entry for NAME/NULL.
822*fae548d3Szrj
823*fae548d3Szrj template<int size, bool big_endian>
824*fae548d3Szrj void
define_default_version(Sized_symbol<size> * sym,bool default_is_new,Symbol_table_type::iterator pdef)825*fae548d3Szrj Symbol_table::define_default_version(Sized_symbol<size>* sym,
826*fae548d3Szrj bool default_is_new,
827*fae548d3Szrj Symbol_table_type::iterator pdef)
828*fae548d3Szrj {
829*fae548d3Szrj if (default_is_new)
830*fae548d3Szrj {
831*fae548d3Szrj // This is the first time we have seen NAME/NULL. Make
832*fae548d3Szrj // NAME/NULL point to NAME/VERSION, and mark SYM as the default
833*fae548d3Szrj // version.
834*fae548d3Szrj pdef->second = sym;
835*fae548d3Szrj sym->set_is_default();
836*fae548d3Szrj }
837*fae548d3Szrj else if (pdef->second == sym)
838*fae548d3Szrj {
839*fae548d3Szrj // NAME/NULL already points to NAME/VERSION. Don't mark the
840*fae548d3Szrj // symbol as the default if it is not already the default.
841*fae548d3Szrj }
842*fae548d3Szrj else
843*fae548d3Szrj {
844*fae548d3Szrj // This is the unfortunate case where we already have entries
845*fae548d3Szrj // for both NAME/VERSION and NAME/NULL. We now see a symbol
846*fae548d3Szrj // NAME/VERSION where VERSION is the default version. We have
847*fae548d3Szrj // already resolved this new symbol with the existing
848*fae548d3Szrj // NAME/VERSION symbol.
849*fae548d3Szrj
850*fae548d3Szrj // It's possible that NAME/NULL and NAME/VERSION are both
851*fae548d3Szrj // defined in regular objects. This can only happen if one
852*fae548d3Szrj // object file defines foo and another defines foo@@ver. This
853*fae548d3Szrj // is somewhat obscure, but we call it a multiple definition
854*fae548d3Szrj // error.
855*fae548d3Szrj
856*fae548d3Szrj // It's possible that NAME/NULL actually has a version, in which
857*fae548d3Szrj // case it won't be the same as VERSION. This happens with
858*fae548d3Szrj // ver_test_7.so in the testsuite for the symbol t2_2. We see
859*fae548d3Szrj // t2_2@@VER2, so we define both t2_2/VER2 and t2_2/NULL. We
860*fae548d3Szrj // then see an unadorned t2_2 in an object file and give it
861*fae548d3Szrj // version VER1 from the version script. This looks like a
862*fae548d3Szrj // default definition for VER1, so it looks like we should merge
863*fae548d3Szrj // t2_2/NULL with t2_2/VER1. That doesn't make sense, but it's
864*fae548d3Szrj // not obvious that this is an error, either. So we just punt.
865*fae548d3Szrj
866*fae548d3Szrj // If one of the symbols has non-default visibility, and the
867*fae548d3Szrj // other is defined in a shared object, then they are different
868*fae548d3Szrj // symbols.
869*fae548d3Szrj
870*fae548d3Szrj // If the two symbols are from different shared objects,
871*fae548d3Szrj // they are different symbols.
872*fae548d3Szrj
873*fae548d3Szrj // Otherwise, we just resolve the symbols as though they were
874*fae548d3Szrj // the same.
875*fae548d3Szrj
876*fae548d3Szrj if (pdef->second->version() != NULL)
877*fae548d3Szrj gold_assert(pdef->second->version() != sym->version());
878*fae548d3Szrj else if (sym->visibility() != elfcpp::STV_DEFAULT
879*fae548d3Szrj && pdef->second->is_from_dynobj())
880*fae548d3Szrj ;
881*fae548d3Szrj else if (pdef->second->visibility() != elfcpp::STV_DEFAULT
882*fae548d3Szrj && sym->is_from_dynobj())
883*fae548d3Szrj ;
884*fae548d3Szrj else if (pdef->second->is_from_dynobj()
885*fae548d3Szrj && sym->is_from_dynobj()
886*fae548d3Szrj && pdef->second->is_defined()
887*fae548d3Szrj && pdef->second->object() != sym->object())
888*fae548d3Szrj ;
889*fae548d3Szrj else
890*fae548d3Szrj {
891*fae548d3Szrj const Sized_symbol<size>* symdef;
892*fae548d3Szrj symdef = this->get_sized_symbol<size>(pdef->second);
893*fae548d3Szrj Symbol_table::resolve<size, big_endian>(sym, symdef);
894*fae548d3Szrj this->make_forwarder(pdef->second, sym);
895*fae548d3Szrj pdef->second = sym;
896*fae548d3Szrj sym->set_is_default();
897*fae548d3Szrj }
898*fae548d3Szrj }
899*fae548d3Szrj }
900*fae548d3Szrj
901*fae548d3Szrj // Add one symbol from OBJECT to the symbol table. NAME is symbol
902*fae548d3Szrj // name and VERSION is the version; both are canonicalized. DEF is
903*fae548d3Szrj // whether this is the default version. ST_SHNDX is the symbol's
904*fae548d3Szrj // section index; IS_ORDINARY is whether this is a normal section
905*fae548d3Szrj // rather than a special code.
906*fae548d3Szrj
907*fae548d3Szrj // If IS_DEFAULT_VERSION is true, then this is the definition of a
908*fae548d3Szrj // default version of a symbol. That means that any lookup of
909*fae548d3Szrj // NAME/NULL and any lookup of NAME/VERSION should always return the
910*fae548d3Szrj // same symbol. This is obvious for references, but in particular we
911*fae548d3Szrj // want to do this for definitions: overriding NAME/NULL should also
912*fae548d3Szrj // override NAME/VERSION. If we don't do that, it would be very hard
913*fae548d3Szrj // to override functions in a shared library which uses versioning.
914*fae548d3Szrj
915*fae548d3Szrj // We implement this by simply making both entries in the hash table
916*fae548d3Szrj // point to the same Symbol structure. That is easy enough if this is
917*fae548d3Szrj // the first time we see NAME/NULL or NAME/VERSION, but it is possible
918*fae548d3Szrj // that we have seen both already, in which case they will both have
919*fae548d3Szrj // independent entries in the symbol table. We can't simply change
920*fae548d3Szrj // the symbol table entry, because we have pointers to the entries
921*fae548d3Szrj // attached to the object files. So we mark the entry attached to the
922*fae548d3Szrj // object file as a forwarder, and record it in the forwarders_ map.
923*fae548d3Szrj // Note that entries in the hash table will never be marked as
924*fae548d3Szrj // forwarders.
925*fae548d3Szrj //
926*fae548d3Szrj // ORIG_ST_SHNDX and ST_SHNDX are almost always the same.
927*fae548d3Szrj // ORIG_ST_SHNDX is the section index in the input file, or SHN_UNDEF
928*fae548d3Szrj // for a special section code. ST_SHNDX may be modified if the symbol
929*fae548d3Szrj // is defined in a section being discarded.
930*fae548d3Szrj
931*fae548d3Szrj template<int size, bool big_endian>
932*fae548d3Szrj Sized_symbol<size>*
add_from_object(Object * object,const char * name,Stringpool::Key name_key,const char * version,Stringpool::Key version_key,bool is_default_version,const elfcpp::Sym<size,big_endian> & sym,unsigned int st_shndx,bool is_ordinary,unsigned int orig_st_shndx)933*fae548d3Szrj Symbol_table::add_from_object(Object* object,
934*fae548d3Szrj const char* name,
935*fae548d3Szrj Stringpool::Key name_key,
936*fae548d3Szrj const char* version,
937*fae548d3Szrj Stringpool::Key version_key,
938*fae548d3Szrj bool is_default_version,
939*fae548d3Szrj const elfcpp::Sym<size, big_endian>& sym,
940*fae548d3Szrj unsigned int st_shndx,
941*fae548d3Szrj bool is_ordinary,
942*fae548d3Szrj unsigned int orig_st_shndx)
943*fae548d3Szrj {
944*fae548d3Szrj // Print a message if this symbol is being traced.
945*fae548d3Szrj if (parameters->options().is_trace_symbol(name))
946*fae548d3Szrj {
947*fae548d3Szrj if (orig_st_shndx == elfcpp::SHN_UNDEF)
948*fae548d3Szrj gold_info(_("%s: reference to %s"), object->name().c_str(), name);
949*fae548d3Szrj else
950*fae548d3Szrj gold_info(_("%s: definition of %s"), object->name().c_str(), name);
951*fae548d3Szrj }
952*fae548d3Szrj
953*fae548d3Szrj // For an undefined symbol, we may need to adjust the name using
954*fae548d3Szrj // --wrap.
955*fae548d3Szrj if (orig_st_shndx == elfcpp::SHN_UNDEF
956*fae548d3Szrj && parameters->options().any_wrap())
957*fae548d3Szrj {
958*fae548d3Szrj const char* wrap_name = this->wrap_symbol(name, &name_key);
959*fae548d3Szrj if (wrap_name != name)
960*fae548d3Szrj {
961*fae548d3Szrj // If we see a reference to malloc with version GLIBC_2.0,
962*fae548d3Szrj // and we turn it into a reference to __wrap_malloc, then we
963*fae548d3Szrj // discard the version number. Otherwise the user would be
964*fae548d3Szrj // required to specify the correct version for
965*fae548d3Szrj // __wrap_malloc.
966*fae548d3Szrj version = NULL;
967*fae548d3Szrj version_key = 0;
968*fae548d3Szrj name = wrap_name;
969*fae548d3Szrj }
970*fae548d3Szrj }
971*fae548d3Szrj
972*fae548d3Szrj Symbol* const snull = NULL;
973*fae548d3Szrj std::pair<typename Symbol_table_type::iterator, bool> ins =
974*fae548d3Szrj this->table_.insert(std::make_pair(std::make_pair(name_key, version_key),
975*fae548d3Szrj snull));
976*fae548d3Szrj
977*fae548d3Szrj std::pair<typename Symbol_table_type::iterator, bool> insdefault =
978*fae548d3Szrj std::make_pair(this->table_.end(), false);
979*fae548d3Szrj if (is_default_version)
980*fae548d3Szrj {
981*fae548d3Szrj const Stringpool::Key vnull_key = 0;
982*fae548d3Szrj insdefault = this->table_.insert(std::make_pair(std::make_pair(name_key,
983*fae548d3Szrj vnull_key),
984*fae548d3Szrj snull));
985*fae548d3Szrj }
986*fae548d3Szrj
987*fae548d3Szrj // ins.first: an iterator, which is a pointer to a pair.
988*fae548d3Szrj // ins.first->first: the key (a pair of name and version).
989*fae548d3Szrj // ins.first->second: the value (Symbol*).
990*fae548d3Szrj // ins.second: true if new entry was inserted, false if not.
991*fae548d3Szrj
992*fae548d3Szrj Sized_symbol<size>* ret = NULL;
993*fae548d3Szrj bool was_undefined_in_reg;
994*fae548d3Szrj bool was_common;
995*fae548d3Szrj if (!ins.second)
996*fae548d3Szrj {
997*fae548d3Szrj // We already have an entry for NAME/VERSION.
998*fae548d3Szrj ret = this->get_sized_symbol<size>(ins.first->second);
999*fae548d3Szrj gold_assert(ret != NULL);
1000*fae548d3Szrj
1001*fae548d3Szrj was_undefined_in_reg = ret->is_undefined() && ret->in_reg();
1002*fae548d3Szrj // Commons from plugins are just placeholders.
1003*fae548d3Szrj was_common = ret->is_common() && ret->object()->pluginobj() == NULL;
1004*fae548d3Szrj
1005*fae548d3Szrj this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object,
1006*fae548d3Szrj version, is_default_version);
1007*fae548d3Szrj if (parameters->options().gc_sections())
1008*fae548d3Szrj this->gc_mark_dyn_syms(ret);
1009*fae548d3Szrj
1010*fae548d3Szrj if (is_default_version)
1011*fae548d3Szrj this->define_default_version<size, big_endian>(ret, insdefault.second,
1012*fae548d3Szrj insdefault.first);
1013*fae548d3Szrj else
1014*fae548d3Szrj {
1015*fae548d3Szrj bool dummy;
1016*fae548d3Szrj if (version != NULL
1017*fae548d3Szrj && ret->source() == Symbol::FROM_OBJECT
1018*fae548d3Szrj && ret->object() == object
1019*fae548d3Szrj && is_ordinary
1020*fae548d3Szrj && ret->shndx(&dummy) == st_shndx
1021*fae548d3Szrj && ret->is_default())
1022*fae548d3Szrj {
1023*fae548d3Szrj // We have seen NAME/VERSION already, and marked it as the
1024*fae548d3Szrj // default version, but now we see a definition for
1025*fae548d3Szrj // NAME/VERSION that is not the default version. This can
1026*fae548d3Szrj // happen when the assembler generates two symbols for
1027*fae548d3Szrj // a symbol as a result of a ".symver foo,foo@VER"
1028*fae548d3Szrj // directive. We see the first unversioned symbol and
1029*fae548d3Szrj // we may mark it as the default version (from a
1030*fae548d3Szrj // version script); then we see the second versioned
1031*fae548d3Szrj // symbol and we need to override the first.
1032*fae548d3Szrj // In any other case, the two symbols should have generated
1033*fae548d3Szrj // a multiple definition error.
1034*fae548d3Szrj // (See PR gold/18703.)
1035*fae548d3Szrj ret->set_is_not_default();
1036*fae548d3Szrj const Stringpool::Key vnull_key = 0;
1037*fae548d3Szrj this->table_.erase(std::make_pair(name_key, vnull_key));
1038*fae548d3Szrj }
1039*fae548d3Szrj }
1040*fae548d3Szrj }
1041*fae548d3Szrj else
1042*fae548d3Szrj {
1043*fae548d3Szrj // This is the first time we have seen NAME/VERSION.
1044*fae548d3Szrj gold_assert(ins.first->second == NULL);
1045*fae548d3Szrj
1046*fae548d3Szrj if (is_default_version && !insdefault.second)
1047*fae548d3Szrj {
1048*fae548d3Szrj // We already have an entry for NAME/NULL. If we override
1049*fae548d3Szrj // it, then change it to NAME/VERSION.
1050*fae548d3Szrj ret = this->get_sized_symbol<size>(insdefault.first->second);
1051*fae548d3Szrj
1052*fae548d3Szrj // If the existing symbol already has a version,
1053*fae548d3Szrj // don't override it with the new symbol.
1054*fae548d3Szrj // This should only happen when the new symbol
1055*fae548d3Szrj // is from a shared library.
1056*fae548d3Szrj if (ret->version() != NULL)
1057*fae548d3Szrj {
1058*fae548d3Szrj if (!object->is_dynamic())
1059*fae548d3Szrj {
1060*fae548d3Szrj gold_warning(_("%s: conflicting default version definition"
1061*fae548d3Szrj " for %s@@%s"),
1062*fae548d3Szrj object->name().c_str(), name, version);
1063*fae548d3Szrj if (ret->source() == Symbol::FROM_OBJECT)
1064*fae548d3Szrj gold_info(_("%s: %s: previous definition of %s@@%s here"),
1065*fae548d3Szrj program_name,
1066*fae548d3Szrj ret->object()->name().c_str(),
1067*fae548d3Szrj name, ret->version());
1068*fae548d3Szrj }
1069*fae548d3Szrj ret = NULL;
1070*fae548d3Szrj is_default_version = false;
1071*fae548d3Szrj }
1072*fae548d3Szrj else
1073*fae548d3Szrj {
1074*fae548d3Szrj was_undefined_in_reg = ret->is_undefined() && ret->in_reg();
1075*fae548d3Szrj // Commons from plugins are just placeholders.
1076*fae548d3Szrj was_common = (ret->is_common()
1077*fae548d3Szrj && ret->object()->pluginobj() == NULL);
1078*fae548d3Szrj
1079*fae548d3Szrj this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx,
1080*fae548d3Szrj object, version, is_default_version);
1081*fae548d3Szrj if (parameters->options().gc_sections())
1082*fae548d3Szrj this->gc_mark_dyn_syms(ret);
1083*fae548d3Szrj ins.first->second = ret;
1084*fae548d3Szrj }
1085*fae548d3Szrj }
1086*fae548d3Szrj
1087*fae548d3Szrj if (ret == NULL)
1088*fae548d3Szrj {
1089*fae548d3Szrj was_undefined_in_reg = false;
1090*fae548d3Szrj was_common = false;
1091*fae548d3Szrj
1092*fae548d3Szrj Sized_target<size, big_endian>* target =
1093*fae548d3Szrj parameters->sized_target<size, big_endian>();
1094*fae548d3Szrj if (!target->has_make_symbol())
1095*fae548d3Szrj ret = new Sized_symbol<size>();
1096*fae548d3Szrj else
1097*fae548d3Szrj {
1098*fae548d3Szrj ret = target->make_symbol(name, sym.get_st_type(), object,
1099*fae548d3Szrj st_shndx, sym.get_st_value());
1100*fae548d3Szrj if (ret == NULL)
1101*fae548d3Szrj {
1102*fae548d3Szrj // This means that we don't want a symbol table
1103*fae548d3Szrj // entry after all.
1104*fae548d3Szrj if (!is_default_version)
1105*fae548d3Szrj this->table_.erase(ins.first);
1106*fae548d3Szrj else
1107*fae548d3Szrj {
1108*fae548d3Szrj this->table_.erase(insdefault.first);
1109*fae548d3Szrj // Inserting INSDEFAULT invalidated INS.
1110*fae548d3Szrj this->table_.erase(std::make_pair(name_key,
1111*fae548d3Szrj version_key));
1112*fae548d3Szrj }
1113*fae548d3Szrj return NULL;
1114*fae548d3Szrj }
1115*fae548d3Szrj }
1116*fae548d3Szrj
1117*fae548d3Szrj ret->init_object(name, version, object, sym, st_shndx, is_ordinary);
1118*fae548d3Szrj
1119*fae548d3Szrj ins.first->second = ret;
1120*fae548d3Szrj if (is_default_version)
1121*fae548d3Szrj {
1122*fae548d3Szrj // This is the first time we have seen NAME/NULL. Point
1123*fae548d3Szrj // it at the new entry for NAME/VERSION.
1124*fae548d3Szrj gold_assert(insdefault.second);
1125*fae548d3Szrj insdefault.first->second = ret;
1126*fae548d3Szrj }
1127*fae548d3Szrj }
1128*fae548d3Szrj
1129*fae548d3Szrj if (is_default_version)
1130*fae548d3Szrj ret->set_is_default();
1131*fae548d3Szrj }
1132*fae548d3Szrj
1133*fae548d3Szrj // Record every time we see a new undefined symbol, to speed up archive
1134*fae548d3Szrj // groups. We only care about symbols undefined in regular objects here
1135*fae548d3Szrj // because undefined symbols only in dynamic objects should't trigger rescans.
1136*fae548d3Szrj if (!was_undefined_in_reg && ret->is_undefined() && ret->in_reg())
1137*fae548d3Szrj {
1138*fae548d3Szrj ++this->saw_undefined_;
1139*fae548d3Szrj if (parameters->options().has_plugins())
1140*fae548d3Szrj parameters->options().plugins()->new_undefined_symbol(ret);
1141*fae548d3Szrj }
1142*fae548d3Szrj
1143*fae548d3Szrj // Keep track of common symbols, to speed up common symbol
1144*fae548d3Szrj // allocation. Don't record commons from plugin objects;
1145*fae548d3Szrj // we need to wait until we see the real symbol in the
1146*fae548d3Szrj // replacement file.
1147*fae548d3Szrj if (!was_common && ret->is_common() && ret->object()->pluginobj() == NULL)
1148*fae548d3Szrj {
1149*fae548d3Szrj if (ret->type() == elfcpp::STT_TLS)
1150*fae548d3Szrj this->tls_commons_.push_back(ret);
1151*fae548d3Szrj else if (!is_ordinary
1152*fae548d3Szrj && st_shndx == parameters->target().small_common_shndx())
1153*fae548d3Szrj this->small_commons_.push_back(ret);
1154*fae548d3Szrj else if (!is_ordinary
1155*fae548d3Szrj && st_shndx == parameters->target().large_common_shndx())
1156*fae548d3Szrj this->large_commons_.push_back(ret);
1157*fae548d3Szrj else
1158*fae548d3Szrj this->commons_.push_back(ret);
1159*fae548d3Szrj }
1160*fae548d3Szrj
1161*fae548d3Szrj // If we're not doing a relocatable link, then any symbol with
1162*fae548d3Szrj // hidden or internal visibility is local.
1163*fae548d3Szrj if ((ret->visibility() == elfcpp::STV_HIDDEN
1164*fae548d3Szrj || ret->visibility() == elfcpp::STV_INTERNAL)
1165*fae548d3Szrj && (ret->binding() == elfcpp::STB_GLOBAL
1166*fae548d3Szrj || ret->binding() == elfcpp::STB_GNU_UNIQUE
1167*fae548d3Szrj || ret->binding() == elfcpp::STB_WEAK)
1168*fae548d3Szrj && !parameters->options().relocatable())
1169*fae548d3Szrj this->force_local(ret);
1170*fae548d3Szrj
1171*fae548d3Szrj return ret;
1172*fae548d3Szrj }
1173*fae548d3Szrj
1174*fae548d3Szrj // Add all the symbols in a relocatable object to the hash table.
1175*fae548d3Szrj
1176*fae548d3Szrj template<int size, bool big_endian>
1177*fae548d3Szrj void
add_from_relobj(Sized_relobj_file<size,big_endian> * relobj,const unsigned char * syms,size_t count,size_t symndx_offset,const char * sym_names,size_t sym_name_size,typename Sized_relobj_file<size,big_endian>::Symbols * sympointers,size_t * defined)1178*fae548d3Szrj Symbol_table::add_from_relobj(
1179*fae548d3Szrj Sized_relobj_file<size, big_endian>* relobj,
1180*fae548d3Szrj const unsigned char* syms,
1181*fae548d3Szrj size_t count,
1182*fae548d3Szrj size_t symndx_offset,
1183*fae548d3Szrj const char* sym_names,
1184*fae548d3Szrj size_t sym_name_size,
1185*fae548d3Szrj typename Sized_relobj_file<size, big_endian>::Symbols* sympointers,
1186*fae548d3Szrj size_t* defined)
1187*fae548d3Szrj {
1188*fae548d3Szrj *defined = 0;
1189*fae548d3Szrj
1190*fae548d3Szrj gold_assert(size == parameters->target().get_size());
1191*fae548d3Szrj
1192*fae548d3Szrj const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1193*fae548d3Szrj
1194*fae548d3Szrj const bool just_symbols = relobj->just_symbols();
1195*fae548d3Szrj
1196*fae548d3Szrj const unsigned char* p = syms;
1197*fae548d3Szrj for (size_t i = 0; i < count; ++i, p += sym_size)
1198*fae548d3Szrj {
1199*fae548d3Szrj (*sympointers)[i] = NULL;
1200*fae548d3Szrj
1201*fae548d3Szrj elfcpp::Sym<size, big_endian> sym(p);
1202*fae548d3Szrj
1203*fae548d3Szrj unsigned int st_name = sym.get_st_name();
1204*fae548d3Szrj if (st_name >= sym_name_size)
1205*fae548d3Szrj {
1206*fae548d3Szrj relobj->error(_("bad global symbol name offset %u at %zu"),
1207*fae548d3Szrj st_name, i);
1208*fae548d3Szrj continue;
1209*fae548d3Szrj }
1210*fae548d3Szrj
1211*fae548d3Szrj const char* name = sym_names + st_name;
1212*fae548d3Szrj
1213*fae548d3Szrj if (!parameters->options().relocatable()
1214*fae548d3Szrj && name[0] == '_'
1215*fae548d3Szrj && name[1] == '_'
1216*fae548d3Szrj && strcmp (name + (name[2] == '_'), "__gnu_lto_slim") == 0)
1217*fae548d3Szrj gold_info(_("%s: plugin needed to handle lto object"),
1218*fae548d3Szrj relobj->name().c_str());
1219*fae548d3Szrj
1220*fae548d3Szrj bool is_ordinary;
1221*fae548d3Szrj unsigned int st_shndx = relobj->adjust_sym_shndx(i + symndx_offset,
1222*fae548d3Szrj sym.get_st_shndx(),
1223*fae548d3Szrj &is_ordinary);
1224*fae548d3Szrj unsigned int orig_st_shndx = st_shndx;
1225*fae548d3Szrj if (!is_ordinary)
1226*fae548d3Szrj orig_st_shndx = elfcpp::SHN_UNDEF;
1227*fae548d3Szrj
1228*fae548d3Szrj if (st_shndx != elfcpp::SHN_UNDEF)
1229*fae548d3Szrj ++*defined;
1230*fae548d3Szrj
1231*fae548d3Szrj // A symbol defined in a section which we are not including must
1232*fae548d3Szrj // be treated as an undefined symbol.
1233*fae548d3Szrj bool is_defined_in_discarded_section = false;
1234*fae548d3Szrj if (st_shndx != elfcpp::SHN_UNDEF
1235*fae548d3Szrj && is_ordinary
1236*fae548d3Szrj && !relobj->is_section_included(st_shndx)
1237*fae548d3Szrj && !this->is_section_folded(relobj, st_shndx))
1238*fae548d3Szrj {
1239*fae548d3Szrj st_shndx = elfcpp::SHN_UNDEF;
1240*fae548d3Szrj is_defined_in_discarded_section = true;
1241*fae548d3Szrj }
1242*fae548d3Szrj
1243*fae548d3Szrj // In an object file, an '@' in the name separates the symbol
1244*fae548d3Szrj // name from the version name. If there are two '@' characters,
1245*fae548d3Szrj // this is the default version.
1246*fae548d3Szrj const char* ver = strchr(name, '@');
1247*fae548d3Szrj Stringpool::Key ver_key = 0;
1248*fae548d3Szrj int namelen = 0;
1249*fae548d3Szrj // IS_DEFAULT_VERSION: is the version default?
1250*fae548d3Szrj // IS_FORCED_LOCAL: is the symbol forced local?
1251*fae548d3Szrj bool is_default_version = false;
1252*fae548d3Szrj bool is_forced_local = false;
1253*fae548d3Szrj
1254*fae548d3Szrj // FIXME: For incremental links, we don't store version information,
1255*fae548d3Szrj // so we need to ignore version symbols for now.
1256*fae548d3Szrj if (parameters->incremental_update() && ver != NULL)
1257*fae548d3Szrj {
1258*fae548d3Szrj namelen = ver - name;
1259*fae548d3Szrj ver = NULL;
1260*fae548d3Szrj }
1261*fae548d3Szrj
1262*fae548d3Szrj if (ver != NULL)
1263*fae548d3Szrj {
1264*fae548d3Szrj // The symbol name is of the form foo@VERSION or foo@@VERSION
1265*fae548d3Szrj namelen = ver - name;
1266*fae548d3Szrj ++ver;
1267*fae548d3Szrj if (*ver == '@')
1268*fae548d3Szrj {
1269*fae548d3Szrj is_default_version = true;
1270*fae548d3Szrj ++ver;
1271*fae548d3Szrj }
1272*fae548d3Szrj ver = this->namepool_.add(ver, true, &ver_key);
1273*fae548d3Szrj }
1274*fae548d3Szrj // We don't want to assign a version to an undefined symbol,
1275*fae548d3Szrj // even if it is listed in the version script. FIXME: What
1276*fae548d3Szrj // about a common symbol?
1277*fae548d3Szrj else
1278*fae548d3Szrj {
1279*fae548d3Szrj namelen = strlen(name);
1280*fae548d3Szrj if (!this->version_script_.empty()
1281*fae548d3Szrj && st_shndx != elfcpp::SHN_UNDEF)
1282*fae548d3Szrj {
1283*fae548d3Szrj // The symbol name did not have a version, but the
1284*fae548d3Szrj // version script may assign a version anyway.
1285*fae548d3Szrj std::string version;
1286*fae548d3Szrj bool is_global;
1287*fae548d3Szrj if (this->version_script_.get_symbol_version(name, &version,
1288*fae548d3Szrj &is_global))
1289*fae548d3Szrj {
1290*fae548d3Szrj if (!is_global)
1291*fae548d3Szrj is_forced_local = true;
1292*fae548d3Szrj else if (!version.empty())
1293*fae548d3Szrj {
1294*fae548d3Szrj ver = this->namepool_.add_with_length(version.c_str(),
1295*fae548d3Szrj version.length(),
1296*fae548d3Szrj true,
1297*fae548d3Szrj &ver_key);
1298*fae548d3Szrj is_default_version = true;
1299*fae548d3Szrj }
1300*fae548d3Szrj }
1301*fae548d3Szrj }
1302*fae548d3Szrj }
1303*fae548d3Szrj
1304*fae548d3Szrj elfcpp::Sym<size, big_endian>* psym = &sym;
1305*fae548d3Szrj unsigned char symbuf[sym_size];
1306*fae548d3Szrj elfcpp::Sym<size, big_endian> sym2(symbuf);
1307*fae548d3Szrj if (just_symbols)
1308*fae548d3Szrj {
1309*fae548d3Szrj memcpy(symbuf, p, sym_size);
1310*fae548d3Szrj elfcpp::Sym_write<size, big_endian> sw(symbuf);
1311*fae548d3Szrj if (orig_st_shndx != elfcpp::SHN_UNDEF
1312*fae548d3Szrj && is_ordinary
1313*fae548d3Szrj && relobj->e_type() == elfcpp::ET_REL)
1314*fae548d3Szrj {
1315*fae548d3Szrj // Symbol values in relocatable object files are section
1316*fae548d3Szrj // relative. This is normally what we want, but since here
1317*fae548d3Szrj // we are converting the symbol to absolute we need to add
1318*fae548d3Szrj // the section address. The section address in an object
1319*fae548d3Szrj // file is normally zero, but people can use a linker
1320*fae548d3Szrj // script to change it.
1321*fae548d3Szrj sw.put_st_value(sym.get_st_value()
1322*fae548d3Szrj + relobj->section_address(orig_st_shndx));
1323*fae548d3Szrj }
1324*fae548d3Szrj st_shndx = elfcpp::SHN_ABS;
1325*fae548d3Szrj is_ordinary = false;
1326*fae548d3Szrj psym = &sym2;
1327*fae548d3Szrj }
1328*fae548d3Szrj
1329*fae548d3Szrj // Fix up visibility if object has no-export set.
1330*fae548d3Szrj if (relobj->no_export()
1331*fae548d3Szrj && (orig_st_shndx != elfcpp::SHN_UNDEF || !is_ordinary))
1332*fae548d3Szrj {
1333*fae548d3Szrj // We may have copied symbol already above.
1334*fae548d3Szrj if (psym != &sym2)
1335*fae548d3Szrj {
1336*fae548d3Szrj memcpy(symbuf, p, sym_size);
1337*fae548d3Szrj psym = &sym2;
1338*fae548d3Szrj }
1339*fae548d3Szrj
1340*fae548d3Szrj elfcpp::STV visibility = sym2.get_st_visibility();
1341*fae548d3Szrj if (visibility == elfcpp::STV_DEFAULT
1342*fae548d3Szrj || visibility == elfcpp::STV_PROTECTED)
1343*fae548d3Szrj {
1344*fae548d3Szrj elfcpp::Sym_write<size, big_endian> sw(symbuf);
1345*fae548d3Szrj unsigned char nonvis = sym2.get_st_nonvis();
1346*fae548d3Szrj sw.put_st_other(elfcpp::STV_HIDDEN, nonvis);
1347*fae548d3Szrj }
1348*fae548d3Szrj }
1349*fae548d3Szrj
1350*fae548d3Szrj Stringpool::Key name_key;
1351*fae548d3Szrj name = this->namepool_.add_with_length(name, namelen, true,
1352*fae548d3Szrj &name_key);
1353*fae548d3Szrj
1354*fae548d3Szrj Sized_symbol<size>* res;
1355*fae548d3Szrj res = this->add_from_object(relobj, name, name_key, ver, ver_key,
1356*fae548d3Szrj is_default_version, *psym, st_shndx,
1357*fae548d3Szrj is_ordinary, orig_st_shndx);
1358*fae548d3Szrj
1359*fae548d3Szrj if (res == NULL)
1360*fae548d3Szrj continue;
1361*fae548d3Szrj
1362*fae548d3Szrj if (is_forced_local)
1363*fae548d3Szrj this->force_local(res);
1364*fae548d3Szrj
1365*fae548d3Szrj // Do not treat this symbol as garbage if this symbol will be
1366*fae548d3Szrj // exported to the dynamic symbol table. This is true when
1367*fae548d3Szrj // building a shared library or using --export-dynamic and
1368*fae548d3Szrj // the symbol is externally visible.
1369*fae548d3Szrj if (parameters->options().gc_sections()
1370*fae548d3Szrj && res->is_externally_visible()
1371*fae548d3Szrj && !res->is_from_dynobj()
1372*fae548d3Szrj && (parameters->options().shared()
1373*fae548d3Szrj || parameters->options().export_dynamic()
1374*fae548d3Szrj || parameters->options().in_dynamic_list(res->name())))
1375*fae548d3Szrj this->gc_mark_symbol(res);
1376*fae548d3Szrj
1377*fae548d3Szrj if (is_defined_in_discarded_section)
1378*fae548d3Szrj res->set_is_defined_in_discarded_section();
1379*fae548d3Szrj
1380*fae548d3Szrj (*sympointers)[i] = res;
1381*fae548d3Szrj }
1382*fae548d3Szrj }
1383*fae548d3Szrj
1384*fae548d3Szrj // Add a symbol from a plugin-claimed file.
1385*fae548d3Szrj
1386*fae548d3Szrj template<int size, bool big_endian>
1387*fae548d3Szrj Symbol*
add_from_pluginobj(Sized_pluginobj<size,big_endian> * obj,const char * name,const char * ver,elfcpp::Sym<size,big_endian> * sym)1388*fae548d3Szrj Symbol_table::add_from_pluginobj(
1389*fae548d3Szrj Sized_pluginobj<size, big_endian>* obj,
1390*fae548d3Szrj const char* name,
1391*fae548d3Szrj const char* ver,
1392*fae548d3Szrj elfcpp::Sym<size, big_endian>* sym)
1393*fae548d3Szrj {
1394*fae548d3Szrj unsigned int st_shndx = sym->get_st_shndx();
1395*fae548d3Szrj bool is_ordinary = st_shndx < elfcpp::SHN_LORESERVE;
1396*fae548d3Szrj
1397*fae548d3Szrj Stringpool::Key ver_key = 0;
1398*fae548d3Szrj bool is_default_version = false;
1399*fae548d3Szrj bool is_forced_local = false;
1400*fae548d3Szrj
1401*fae548d3Szrj if (ver != NULL)
1402*fae548d3Szrj {
1403*fae548d3Szrj ver = this->namepool_.add(ver, true, &ver_key);
1404*fae548d3Szrj }
1405*fae548d3Szrj // We don't want to assign a version to an undefined symbol,
1406*fae548d3Szrj // even if it is listed in the version script. FIXME: What
1407*fae548d3Szrj // about a common symbol?
1408*fae548d3Szrj else
1409*fae548d3Szrj {
1410*fae548d3Szrj if (!this->version_script_.empty()
1411*fae548d3Szrj && st_shndx != elfcpp::SHN_UNDEF)
1412*fae548d3Szrj {
1413*fae548d3Szrj // The symbol name did not have a version, but the
1414*fae548d3Szrj // version script may assign a version anyway.
1415*fae548d3Szrj std::string version;
1416*fae548d3Szrj bool is_global;
1417*fae548d3Szrj if (this->version_script_.get_symbol_version(name, &version,
1418*fae548d3Szrj &is_global))
1419*fae548d3Szrj {
1420*fae548d3Szrj if (!is_global)
1421*fae548d3Szrj is_forced_local = true;
1422*fae548d3Szrj else if (!version.empty())
1423*fae548d3Szrj {
1424*fae548d3Szrj ver = this->namepool_.add_with_length(version.c_str(),
1425*fae548d3Szrj version.length(),
1426*fae548d3Szrj true,
1427*fae548d3Szrj &ver_key);
1428*fae548d3Szrj is_default_version = true;
1429*fae548d3Szrj }
1430*fae548d3Szrj }
1431*fae548d3Szrj }
1432*fae548d3Szrj }
1433*fae548d3Szrj
1434*fae548d3Szrj Stringpool::Key name_key;
1435*fae548d3Szrj name = this->namepool_.add(name, true, &name_key);
1436*fae548d3Szrj
1437*fae548d3Szrj Sized_symbol<size>* res;
1438*fae548d3Szrj res = this->add_from_object(obj, name, name_key, ver, ver_key,
1439*fae548d3Szrj is_default_version, *sym, st_shndx,
1440*fae548d3Szrj is_ordinary, st_shndx);
1441*fae548d3Szrj
1442*fae548d3Szrj if (res == NULL)
1443*fae548d3Szrj return NULL;
1444*fae548d3Szrj
1445*fae548d3Szrj if (is_forced_local)
1446*fae548d3Szrj this->force_local(res);
1447*fae548d3Szrj
1448*fae548d3Szrj return res;
1449*fae548d3Szrj }
1450*fae548d3Szrj
1451*fae548d3Szrj // Add all the symbols in a dynamic object to the hash table.
1452*fae548d3Szrj
1453*fae548d3Szrj template<int size, bool big_endian>
1454*fae548d3Szrj void
add_from_dynobj(Sized_dynobj<size,big_endian> * dynobj,const unsigned char * syms,size_t count,const char * sym_names,size_t sym_name_size,const unsigned char * versym,size_t versym_size,const std::vector<const char * > * version_map,typename Sized_relobj_file<size,big_endian>::Symbols * sympointers,size_t * defined)1455*fae548d3Szrj Symbol_table::add_from_dynobj(
1456*fae548d3Szrj Sized_dynobj<size, big_endian>* dynobj,
1457*fae548d3Szrj const unsigned char* syms,
1458*fae548d3Szrj size_t count,
1459*fae548d3Szrj const char* sym_names,
1460*fae548d3Szrj size_t sym_name_size,
1461*fae548d3Szrj const unsigned char* versym,
1462*fae548d3Szrj size_t versym_size,
1463*fae548d3Szrj const std::vector<const char*>* version_map,
1464*fae548d3Szrj typename Sized_relobj_file<size, big_endian>::Symbols* sympointers,
1465*fae548d3Szrj size_t* defined)
1466*fae548d3Szrj {
1467*fae548d3Szrj *defined = 0;
1468*fae548d3Szrj
1469*fae548d3Szrj gold_assert(size == parameters->target().get_size());
1470*fae548d3Szrj
1471*fae548d3Szrj if (dynobj->just_symbols())
1472*fae548d3Szrj {
1473*fae548d3Szrj gold_error(_("--just-symbols does not make sense with a shared object"));
1474*fae548d3Szrj return;
1475*fae548d3Szrj }
1476*fae548d3Szrj
1477*fae548d3Szrj // FIXME: For incremental links, we don't store version information,
1478*fae548d3Szrj // so we need to ignore version symbols for now.
1479*fae548d3Szrj if (parameters->incremental_update())
1480*fae548d3Szrj versym = NULL;
1481*fae548d3Szrj
1482*fae548d3Szrj if (versym != NULL && versym_size / 2 < count)
1483*fae548d3Szrj {
1484*fae548d3Szrj dynobj->error(_("too few symbol versions"));
1485*fae548d3Szrj return;
1486*fae548d3Szrj }
1487*fae548d3Szrj
1488*fae548d3Szrj const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1489*fae548d3Szrj
1490*fae548d3Szrj // We keep a list of all STT_OBJECT symbols, so that we can resolve
1491*fae548d3Szrj // weak aliases. This is necessary because if the dynamic object
1492*fae548d3Szrj // provides the same variable under two names, one of which is a
1493*fae548d3Szrj // weak definition, and the regular object refers to the weak
1494*fae548d3Szrj // definition, we have to put both the weak definition and the
1495*fae548d3Szrj // strong definition into the dynamic symbol table. Given a weak
1496*fae548d3Szrj // definition, the only way that we can find the corresponding
1497*fae548d3Szrj // strong definition, if any, is to search the symbol table.
1498*fae548d3Szrj std::vector<Sized_symbol<size>*> object_symbols;
1499*fae548d3Szrj
1500*fae548d3Szrj const unsigned char* p = syms;
1501*fae548d3Szrj const unsigned char* vs = versym;
1502*fae548d3Szrj for (size_t i = 0; i < count; ++i, p += sym_size, vs += 2)
1503*fae548d3Szrj {
1504*fae548d3Szrj elfcpp::Sym<size, big_endian> sym(p);
1505*fae548d3Szrj
1506*fae548d3Szrj if (sympointers != NULL)
1507*fae548d3Szrj (*sympointers)[i] = NULL;
1508*fae548d3Szrj
1509*fae548d3Szrj // Ignore symbols with local binding or that have
1510*fae548d3Szrj // internal or hidden visibility.
1511*fae548d3Szrj if (sym.get_st_bind() == elfcpp::STB_LOCAL
1512*fae548d3Szrj || sym.get_st_visibility() == elfcpp::STV_INTERNAL
1513*fae548d3Szrj || sym.get_st_visibility() == elfcpp::STV_HIDDEN)
1514*fae548d3Szrj continue;
1515*fae548d3Szrj
1516*fae548d3Szrj // A protected symbol in a shared library must be treated as a
1517*fae548d3Szrj // normal symbol when viewed from outside the shared library.
1518*fae548d3Szrj // Implement this by overriding the visibility here.
1519*fae548d3Szrj // Likewise, an IFUNC symbol in a shared library must be treated
1520*fae548d3Szrj // as a normal FUNC symbol.
1521*fae548d3Szrj elfcpp::Sym<size, big_endian>* psym = &sym;
1522*fae548d3Szrj unsigned char symbuf[sym_size];
1523*fae548d3Szrj elfcpp::Sym<size, big_endian> sym2(symbuf);
1524*fae548d3Szrj if (sym.get_st_visibility() == elfcpp::STV_PROTECTED
1525*fae548d3Szrj || sym.get_st_type() == elfcpp::STT_GNU_IFUNC)
1526*fae548d3Szrj {
1527*fae548d3Szrj memcpy(symbuf, p, sym_size);
1528*fae548d3Szrj elfcpp::Sym_write<size, big_endian> sw(symbuf);
1529*fae548d3Szrj if (sym.get_st_visibility() == elfcpp::STV_PROTECTED)
1530*fae548d3Szrj sw.put_st_other(elfcpp::STV_DEFAULT, sym.get_st_nonvis());
1531*fae548d3Szrj if (sym.get_st_type() == elfcpp::STT_GNU_IFUNC)
1532*fae548d3Szrj sw.put_st_info(sym.get_st_bind(), elfcpp::STT_FUNC);
1533*fae548d3Szrj psym = &sym2;
1534*fae548d3Szrj }
1535*fae548d3Szrj
1536*fae548d3Szrj unsigned int st_name = psym->get_st_name();
1537*fae548d3Szrj if (st_name >= sym_name_size)
1538*fae548d3Szrj {
1539*fae548d3Szrj dynobj->error(_("bad symbol name offset %u at %zu"),
1540*fae548d3Szrj st_name, i);
1541*fae548d3Szrj continue;
1542*fae548d3Szrj }
1543*fae548d3Szrj
1544*fae548d3Szrj const char* name = sym_names + st_name;
1545*fae548d3Szrj
1546*fae548d3Szrj bool is_ordinary;
1547*fae548d3Szrj unsigned int st_shndx = dynobj->adjust_sym_shndx(i, psym->get_st_shndx(),
1548*fae548d3Szrj &is_ordinary);
1549*fae548d3Szrj
1550*fae548d3Szrj if (st_shndx != elfcpp::SHN_UNDEF)
1551*fae548d3Szrj ++*defined;
1552*fae548d3Szrj
1553*fae548d3Szrj Sized_symbol<size>* res;
1554*fae548d3Szrj
1555*fae548d3Szrj if (versym == NULL)
1556*fae548d3Szrj {
1557*fae548d3Szrj Stringpool::Key name_key;
1558*fae548d3Szrj name = this->namepool_.add(name, true, &name_key);
1559*fae548d3Szrj res = this->add_from_object(dynobj, name, name_key, NULL, 0,
1560*fae548d3Szrj false, *psym, st_shndx, is_ordinary,
1561*fae548d3Szrj st_shndx);
1562*fae548d3Szrj }
1563*fae548d3Szrj else
1564*fae548d3Szrj {
1565*fae548d3Szrj // Read the version information.
1566*fae548d3Szrj
1567*fae548d3Szrj unsigned int v = elfcpp::Swap<16, big_endian>::readval(vs);
1568*fae548d3Szrj
1569*fae548d3Szrj bool hidden = (v & elfcpp::VERSYM_HIDDEN) != 0;
1570*fae548d3Szrj v &= elfcpp::VERSYM_VERSION;
1571*fae548d3Szrj
1572*fae548d3Szrj // The Sun documentation says that V can be VER_NDX_LOCAL,
1573*fae548d3Szrj // or VER_NDX_GLOBAL, or a version index. The meaning of
1574*fae548d3Szrj // VER_NDX_LOCAL is defined as "Symbol has local scope."
1575*fae548d3Szrj // The old GNU linker will happily generate VER_NDX_LOCAL
1576*fae548d3Szrj // for an undefined symbol. I don't know what the Sun
1577*fae548d3Szrj // linker will generate.
1578*fae548d3Szrj
1579*fae548d3Szrj if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
1580*fae548d3Szrj && st_shndx != elfcpp::SHN_UNDEF)
1581*fae548d3Szrj {
1582*fae548d3Szrj // This symbol should not be visible outside the object.
1583*fae548d3Szrj continue;
1584*fae548d3Szrj }
1585*fae548d3Szrj
1586*fae548d3Szrj // At this point we are definitely going to add this symbol.
1587*fae548d3Szrj Stringpool::Key name_key;
1588*fae548d3Szrj name = this->namepool_.add(name, true, &name_key);
1589*fae548d3Szrj
1590*fae548d3Szrj if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL)
1591*fae548d3Szrj || v == static_cast<unsigned int>(elfcpp::VER_NDX_GLOBAL))
1592*fae548d3Szrj {
1593*fae548d3Szrj // This symbol does not have a version.
1594*fae548d3Szrj res = this->add_from_object(dynobj, name, name_key, NULL, 0,
1595*fae548d3Szrj false, *psym, st_shndx, is_ordinary,
1596*fae548d3Szrj st_shndx);
1597*fae548d3Szrj }
1598*fae548d3Szrj else
1599*fae548d3Szrj {
1600*fae548d3Szrj if (v >= version_map->size())
1601*fae548d3Szrj {
1602*fae548d3Szrj dynobj->error(_("versym for symbol %zu out of range: %u"),
1603*fae548d3Szrj i, v);
1604*fae548d3Szrj continue;
1605*fae548d3Szrj }
1606*fae548d3Szrj
1607*fae548d3Szrj const char* version = (*version_map)[v];
1608*fae548d3Szrj if (version == NULL)
1609*fae548d3Szrj {
1610*fae548d3Szrj dynobj->error(_("versym for symbol %zu has no name: %u"),
1611*fae548d3Szrj i, v);
1612*fae548d3Szrj continue;
1613*fae548d3Szrj }
1614*fae548d3Szrj
1615*fae548d3Szrj Stringpool::Key version_key;
1616*fae548d3Szrj version = this->namepool_.add(version, true, &version_key);
1617*fae548d3Szrj
1618*fae548d3Szrj // If this is an absolute symbol, and the version name
1619*fae548d3Szrj // and symbol name are the same, then this is the
1620*fae548d3Szrj // version definition symbol. These symbols exist to
1621*fae548d3Szrj // support using -u to pull in particular versions. We
1622*fae548d3Szrj // do not want to record a version for them.
1623*fae548d3Szrj if (st_shndx == elfcpp::SHN_ABS
1624*fae548d3Szrj && !is_ordinary
1625*fae548d3Szrj && name_key == version_key)
1626*fae548d3Szrj res = this->add_from_object(dynobj, name, name_key, NULL, 0,
1627*fae548d3Szrj false, *psym, st_shndx, is_ordinary,
1628*fae548d3Szrj st_shndx);
1629*fae548d3Szrj else
1630*fae548d3Szrj {
1631*fae548d3Szrj const bool is_default_version =
1632*fae548d3Szrj !hidden && st_shndx != elfcpp::SHN_UNDEF;
1633*fae548d3Szrj res = this->add_from_object(dynobj, name, name_key, version,
1634*fae548d3Szrj version_key, is_default_version,
1635*fae548d3Szrj *psym, st_shndx,
1636*fae548d3Szrj is_ordinary, st_shndx);
1637*fae548d3Szrj }
1638*fae548d3Szrj }
1639*fae548d3Szrj }
1640*fae548d3Szrj
1641*fae548d3Szrj if (res == NULL)
1642*fae548d3Szrj continue;
1643*fae548d3Szrj
1644*fae548d3Szrj // Note that it is possible that RES was overridden by an
1645*fae548d3Szrj // earlier object, in which case it can't be aliased here.
1646*fae548d3Szrj if (st_shndx != elfcpp::SHN_UNDEF
1647*fae548d3Szrj && is_ordinary
1648*fae548d3Szrj && psym->get_st_type() == elfcpp::STT_OBJECT
1649*fae548d3Szrj && res->source() == Symbol::FROM_OBJECT
1650*fae548d3Szrj && res->object() == dynobj)
1651*fae548d3Szrj object_symbols.push_back(res);
1652*fae548d3Szrj
1653*fae548d3Szrj // If the symbol has protected visibility in the dynobj,
1654*fae548d3Szrj // mark it as such if it was not overridden.
1655*fae548d3Szrj if (res->source() == Symbol::FROM_OBJECT
1656*fae548d3Szrj && res->object() == dynobj
1657*fae548d3Szrj && sym.get_st_visibility() == elfcpp::STV_PROTECTED)
1658*fae548d3Szrj res->set_is_protected();
1659*fae548d3Szrj
1660*fae548d3Szrj if (sympointers != NULL)
1661*fae548d3Szrj (*sympointers)[i] = res;
1662*fae548d3Szrj }
1663*fae548d3Szrj
1664*fae548d3Szrj this->record_weak_aliases(&object_symbols);
1665*fae548d3Szrj }
1666*fae548d3Szrj
1667*fae548d3Szrj // Add a symbol from a incremental object file.
1668*fae548d3Szrj
1669*fae548d3Szrj template<int size, bool big_endian>
1670*fae548d3Szrj Sized_symbol<size>*
add_from_incrobj(Object * obj,const char * name,const char * ver,elfcpp::Sym<size,big_endian> * sym)1671*fae548d3Szrj Symbol_table::add_from_incrobj(
1672*fae548d3Szrj Object* obj,
1673*fae548d3Szrj const char* name,
1674*fae548d3Szrj const char* ver,
1675*fae548d3Szrj elfcpp::Sym<size, big_endian>* sym)
1676*fae548d3Szrj {
1677*fae548d3Szrj unsigned int st_shndx = sym->get_st_shndx();
1678*fae548d3Szrj bool is_ordinary = st_shndx < elfcpp::SHN_LORESERVE;
1679*fae548d3Szrj
1680*fae548d3Szrj Stringpool::Key ver_key = 0;
1681*fae548d3Szrj bool is_default_version = false;
1682*fae548d3Szrj
1683*fae548d3Szrj Stringpool::Key name_key;
1684*fae548d3Szrj name = this->namepool_.add(name, true, &name_key);
1685*fae548d3Szrj
1686*fae548d3Szrj Sized_symbol<size>* res;
1687*fae548d3Szrj res = this->add_from_object(obj, name, name_key, ver, ver_key,
1688*fae548d3Szrj is_default_version, *sym, st_shndx,
1689*fae548d3Szrj is_ordinary, st_shndx);
1690*fae548d3Szrj
1691*fae548d3Szrj return res;
1692*fae548d3Szrj }
1693*fae548d3Szrj
1694*fae548d3Szrj // This is used to sort weak aliases. We sort them first by section
1695*fae548d3Szrj // index, then by offset, then by weak ahead of strong.
1696*fae548d3Szrj
1697*fae548d3Szrj template<int size>
1698*fae548d3Szrj class Weak_alias_sorter
1699*fae548d3Szrj {
1700*fae548d3Szrj public:
1701*fae548d3Szrj bool operator()(const Sized_symbol<size>*, const Sized_symbol<size>*) const;
1702*fae548d3Szrj };
1703*fae548d3Szrj
1704*fae548d3Szrj template<int size>
1705*fae548d3Szrj bool
operator ()(const Sized_symbol<size> * s1,const Sized_symbol<size> * s2) const1706*fae548d3Szrj Weak_alias_sorter<size>::operator()(const Sized_symbol<size>* s1,
1707*fae548d3Szrj const Sized_symbol<size>* s2) const
1708*fae548d3Szrj {
1709*fae548d3Szrj bool is_ordinary;
1710*fae548d3Szrj unsigned int s1_shndx = s1->shndx(&is_ordinary);
1711*fae548d3Szrj gold_assert(is_ordinary);
1712*fae548d3Szrj unsigned int s2_shndx = s2->shndx(&is_ordinary);
1713*fae548d3Szrj gold_assert(is_ordinary);
1714*fae548d3Szrj if (s1_shndx != s2_shndx)
1715*fae548d3Szrj return s1_shndx < s2_shndx;
1716*fae548d3Szrj
1717*fae548d3Szrj if (s1->value() != s2->value())
1718*fae548d3Szrj return s1->value() < s2->value();
1719*fae548d3Szrj if (s1->binding() != s2->binding())
1720*fae548d3Szrj {
1721*fae548d3Szrj if (s1->binding() == elfcpp::STB_WEAK)
1722*fae548d3Szrj return true;
1723*fae548d3Szrj if (s2->binding() == elfcpp::STB_WEAK)
1724*fae548d3Szrj return false;
1725*fae548d3Szrj }
1726*fae548d3Szrj return std::string(s1->name()) < std::string(s2->name());
1727*fae548d3Szrj }
1728*fae548d3Szrj
1729*fae548d3Szrj // SYMBOLS is a list of object symbols from a dynamic object. Look
1730*fae548d3Szrj // for any weak aliases, and record them so that if we add the weak
1731*fae548d3Szrj // alias to the dynamic symbol table, we also add the corresponding
1732*fae548d3Szrj // strong symbol.
1733*fae548d3Szrj
1734*fae548d3Szrj template<int size>
1735*fae548d3Szrj void
record_weak_aliases(std::vector<Sized_symbol<size> * > * symbols)1736*fae548d3Szrj Symbol_table::record_weak_aliases(std::vector<Sized_symbol<size>*>* symbols)
1737*fae548d3Szrj {
1738*fae548d3Szrj // Sort the vector by section index, then by offset, then by weak
1739*fae548d3Szrj // ahead of strong.
1740*fae548d3Szrj std::sort(symbols->begin(), symbols->end(), Weak_alias_sorter<size>());
1741*fae548d3Szrj
1742*fae548d3Szrj // Walk through the vector. For each weak definition, record
1743*fae548d3Szrj // aliases.
1744*fae548d3Szrj for (typename std::vector<Sized_symbol<size>*>::const_iterator p =
1745*fae548d3Szrj symbols->begin();
1746*fae548d3Szrj p != symbols->end();
1747*fae548d3Szrj ++p)
1748*fae548d3Szrj {
1749*fae548d3Szrj if ((*p)->binding() != elfcpp::STB_WEAK)
1750*fae548d3Szrj continue;
1751*fae548d3Szrj
1752*fae548d3Szrj // Build a circular list of weak aliases. Each symbol points to
1753*fae548d3Szrj // the next one in the circular list.
1754*fae548d3Szrj
1755*fae548d3Szrj Sized_symbol<size>* from_sym = *p;
1756*fae548d3Szrj typename std::vector<Sized_symbol<size>*>::const_iterator q;
1757*fae548d3Szrj for (q = p + 1; q != symbols->end(); ++q)
1758*fae548d3Szrj {
1759*fae548d3Szrj bool dummy;
1760*fae548d3Szrj if ((*q)->shndx(&dummy) != from_sym->shndx(&dummy)
1761*fae548d3Szrj || (*q)->value() != from_sym->value())
1762*fae548d3Szrj break;
1763*fae548d3Szrj
1764*fae548d3Szrj this->weak_aliases_[from_sym] = *q;
1765*fae548d3Szrj from_sym->set_has_alias();
1766*fae548d3Szrj from_sym = *q;
1767*fae548d3Szrj }
1768*fae548d3Szrj
1769*fae548d3Szrj if (from_sym != *p)
1770*fae548d3Szrj {
1771*fae548d3Szrj this->weak_aliases_[from_sym] = *p;
1772*fae548d3Szrj from_sym->set_has_alias();
1773*fae548d3Szrj }
1774*fae548d3Szrj
1775*fae548d3Szrj p = q - 1;
1776*fae548d3Szrj }
1777*fae548d3Szrj }
1778*fae548d3Szrj
1779*fae548d3Szrj // Create and return a specially defined symbol. If ONLY_IF_REF is
1780*fae548d3Szrj // true, then only create the symbol if there is a reference to it.
1781*fae548d3Szrj // If this does not return NULL, it sets *POLDSYM to the existing
1782*fae548d3Szrj // symbol if there is one. This sets *RESOLVE_OLDSYM if we should
1783*fae548d3Szrj // resolve the newly created symbol to the old one. This
1784*fae548d3Szrj // canonicalizes *PNAME and *PVERSION.
1785*fae548d3Szrj
1786*fae548d3Szrj template<int size, bool big_endian>
1787*fae548d3Szrj Sized_symbol<size>*
define_special_symbol(const char ** pname,const char ** pversion,bool only_if_ref,elfcpp::STV visibility,Sized_symbol<size> ** poldsym,bool * resolve_oldsym,bool is_forced_local)1788*fae548d3Szrj Symbol_table::define_special_symbol(const char** pname, const char** pversion,
1789*fae548d3Szrj bool only_if_ref,
1790*fae548d3Szrj elfcpp::STV visibility,
1791*fae548d3Szrj Sized_symbol<size>** poldsym,
1792*fae548d3Szrj bool* resolve_oldsym, bool is_forced_local)
1793*fae548d3Szrj {
1794*fae548d3Szrj *resolve_oldsym = false;
1795*fae548d3Szrj *poldsym = NULL;
1796*fae548d3Szrj
1797*fae548d3Szrj // If the caller didn't give us a version, see if we get one from
1798*fae548d3Szrj // the version script.
1799*fae548d3Szrj std::string v;
1800*fae548d3Szrj bool is_default_version = false;
1801*fae548d3Szrj if (!is_forced_local && *pversion == NULL)
1802*fae548d3Szrj {
1803*fae548d3Szrj bool is_global;
1804*fae548d3Szrj if (this->version_script_.get_symbol_version(*pname, &v, &is_global))
1805*fae548d3Szrj {
1806*fae548d3Szrj if (is_global && !v.empty())
1807*fae548d3Szrj {
1808*fae548d3Szrj *pversion = v.c_str();
1809*fae548d3Szrj // If we get the version from a version script, then we
1810*fae548d3Szrj // are also the default version.
1811*fae548d3Szrj is_default_version = true;
1812*fae548d3Szrj }
1813*fae548d3Szrj }
1814*fae548d3Szrj }
1815*fae548d3Szrj
1816*fae548d3Szrj Symbol* oldsym;
1817*fae548d3Szrj Sized_symbol<size>* sym;
1818*fae548d3Szrj
1819*fae548d3Szrj bool add_to_table = false;
1820*fae548d3Szrj typename Symbol_table_type::iterator add_loc = this->table_.end();
1821*fae548d3Szrj bool add_def_to_table = false;
1822*fae548d3Szrj typename Symbol_table_type::iterator add_def_loc = this->table_.end();
1823*fae548d3Szrj
1824*fae548d3Szrj if (only_if_ref)
1825*fae548d3Szrj {
1826*fae548d3Szrj oldsym = this->lookup(*pname, *pversion);
1827*fae548d3Szrj if (oldsym == NULL && is_default_version)
1828*fae548d3Szrj oldsym = this->lookup(*pname, NULL);
1829*fae548d3Szrj if (oldsym == NULL)
1830*fae548d3Szrj return NULL;
1831*fae548d3Szrj if (!oldsym->is_undefined())
1832*fae548d3Szrj {
1833*fae548d3Szrj // Skip if the old definition is from a regular object.
1834*fae548d3Szrj if (!oldsym->is_from_dynobj())
1835*fae548d3Szrj return NULL;
1836*fae548d3Szrj
1837*fae548d3Szrj // If the symbol has hidden or internal visibility, ignore
1838*fae548d3Szrj // definition and reference from a dynamic object.
1839*fae548d3Szrj if ((visibility == elfcpp::STV_HIDDEN
1840*fae548d3Szrj || visibility == elfcpp::STV_INTERNAL)
1841*fae548d3Szrj && !oldsym->in_reg())
1842*fae548d3Szrj return NULL;
1843*fae548d3Szrj }
1844*fae548d3Szrj
1845*fae548d3Szrj *pname = oldsym->name();
1846*fae548d3Szrj if (is_default_version)
1847*fae548d3Szrj *pversion = this->namepool_.add(*pversion, true, NULL);
1848*fae548d3Szrj else
1849*fae548d3Szrj *pversion = oldsym->version();
1850*fae548d3Szrj }
1851*fae548d3Szrj else
1852*fae548d3Szrj {
1853*fae548d3Szrj // Canonicalize NAME and VERSION.
1854*fae548d3Szrj Stringpool::Key name_key;
1855*fae548d3Szrj *pname = this->namepool_.add(*pname, true, &name_key);
1856*fae548d3Szrj
1857*fae548d3Szrj Stringpool::Key version_key = 0;
1858*fae548d3Szrj if (*pversion != NULL)
1859*fae548d3Szrj *pversion = this->namepool_.add(*pversion, true, &version_key);
1860*fae548d3Szrj
1861*fae548d3Szrj Symbol* const snull = NULL;
1862*fae548d3Szrj std::pair<typename Symbol_table_type::iterator, bool> ins =
1863*fae548d3Szrj this->table_.insert(std::make_pair(std::make_pair(name_key,
1864*fae548d3Szrj version_key),
1865*fae548d3Szrj snull));
1866*fae548d3Szrj
1867*fae548d3Szrj std::pair<typename Symbol_table_type::iterator, bool> insdefault =
1868*fae548d3Szrj std::make_pair(this->table_.end(), false);
1869*fae548d3Szrj if (is_default_version)
1870*fae548d3Szrj {
1871*fae548d3Szrj const Stringpool::Key vnull = 0;
1872*fae548d3Szrj insdefault =
1873*fae548d3Szrj this->table_.insert(std::make_pair(std::make_pair(name_key,
1874*fae548d3Szrj vnull),
1875*fae548d3Szrj snull));
1876*fae548d3Szrj }
1877*fae548d3Szrj
1878*fae548d3Szrj if (!ins.second)
1879*fae548d3Szrj {
1880*fae548d3Szrj // We already have a symbol table entry for NAME/VERSION.
1881*fae548d3Szrj oldsym = ins.first->second;
1882*fae548d3Szrj gold_assert(oldsym != NULL);
1883*fae548d3Szrj
1884*fae548d3Szrj if (is_default_version)
1885*fae548d3Szrj {
1886*fae548d3Szrj Sized_symbol<size>* soldsym =
1887*fae548d3Szrj this->get_sized_symbol<size>(oldsym);
1888*fae548d3Szrj this->define_default_version<size, big_endian>(soldsym,
1889*fae548d3Szrj insdefault.second,
1890*fae548d3Szrj insdefault.first);
1891*fae548d3Szrj }
1892*fae548d3Szrj }
1893*fae548d3Szrj else
1894*fae548d3Szrj {
1895*fae548d3Szrj // We haven't seen this symbol before.
1896*fae548d3Szrj gold_assert(ins.first->second == NULL);
1897*fae548d3Szrj
1898*fae548d3Szrj add_to_table = true;
1899*fae548d3Szrj add_loc = ins.first;
1900*fae548d3Szrj
1901*fae548d3Szrj if (is_default_version
1902*fae548d3Szrj && !insdefault.second
1903*fae548d3Szrj && insdefault.first->second->version() == NULL)
1904*fae548d3Szrj {
1905*fae548d3Szrj // We are adding NAME/VERSION, and it is the default
1906*fae548d3Szrj // version. We already have an entry for NAME/NULL
1907*fae548d3Szrj // that does not already have a version.
1908*fae548d3Szrj oldsym = insdefault.first->second;
1909*fae548d3Szrj *resolve_oldsym = true;
1910*fae548d3Szrj }
1911*fae548d3Szrj else
1912*fae548d3Szrj {
1913*fae548d3Szrj oldsym = NULL;
1914*fae548d3Szrj
1915*fae548d3Szrj if (is_default_version)
1916*fae548d3Szrj {
1917*fae548d3Szrj add_def_to_table = true;
1918*fae548d3Szrj add_def_loc = insdefault.first;
1919*fae548d3Szrj }
1920*fae548d3Szrj }
1921*fae548d3Szrj }
1922*fae548d3Szrj }
1923*fae548d3Szrj
1924*fae548d3Szrj const Target& target = parameters->target();
1925*fae548d3Szrj if (!target.has_make_symbol())
1926*fae548d3Szrj sym = new Sized_symbol<size>();
1927*fae548d3Szrj else
1928*fae548d3Szrj {
1929*fae548d3Szrj Sized_target<size, big_endian>* sized_target =
1930*fae548d3Szrj parameters->sized_target<size, big_endian>();
1931*fae548d3Szrj sym = sized_target->make_symbol(*pname, elfcpp::STT_NOTYPE,
1932*fae548d3Szrj NULL, elfcpp::SHN_UNDEF, 0);
1933*fae548d3Szrj if (sym == NULL)
1934*fae548d3Szrj return NULL;
1935*fae548d3Szrj }
1936*fae548d3Szrj
1937*fae548d3Szrj if (add_to_table)
1938*fae548d3Szrj add_loc->second = sym;
1939*fae548d3Szrj else
1940*fae548d3Szrj gold_assert(oldsym != NULL);
1941*fae548d3Szrj
1942*fae548d3Szrj if (add_def_to_table)
1943*fae548d3Szrj add_def_loc->second = sym;
1944*fae548d3Szrj
1945*fae548d3Szrj *poldsym = this->get_sized_symbol<size>(oldsym);
1946*fae548d3Szrj
1947*fae548d3Szrj return sym;
1948*fae548d3Szrj }
1949*fae548d3Szrj
1950*fae548d3Szrj // Define a symbol based on an Output_data.
1951*fae548d3Szrj
1952*fae548d3Szrj Symbol*
define_in_output_data(const char * name,const char * version,Defined defined,Output_data * od,uint64_t value,uint64_t symsize,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis,bool offset_is_from_end,bool only_if_ref)1953*fae548d3Szrj Symbol_table::define_in_output_data(const char* name,
1954*fae548d3Szrj const char* version,
1955*fae548d3Szrj Defined defined,
1956*fae548d3Szrj Output_data* od,
1957*fae548d3Szrj uint64_t value,
1958*fae548d3Szrj uint64_t symsize,
1959*fae548d3Szrj elfcpp::STT type,
1960*fae548d3Szrj elfcpp::STB binding,
1961*fae548d3Szrj elfcpp::STV visibility,
1962*fae548d3Szrj unsigned char nonvis,
1963*fae548d3Szrj bool offset_is_from_end,
1964*fae548d3Szrj bool only_if_ref)
1965*fae548d3Szrj {
1966*fae548d3Szrj if (parameters->target().get_size() == 32)
1967*fae548d3Szrj {
1968*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1969*fae548d3Szrj return this->do_define_in_output_data<32>(name, version, defined, od,
1970*fae548d3Szrj value, symsize, type, binding,
1971*fae548d3Szrj visibility, nonvis,
1972*fae548d3Szrj offset_is_from_end,
1973*fae548d3Szrj only_if_ref);
1974*fae548d3Szrj #else
1975*fae548d3Szrj gold_unreachable();
1976*fae548d3Szrj #endif
1977*fae548d3Szrj }
1978*fae548d3Szrj else if (parameters->target().get_size() == 64)
1979*fae548d3Szrj {
1980*fae548d3Szrj #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1981*fae548d3Szrj return this->do_define_in_output_data<64>(name, version, defined, od,
1982*fae548d3Szrj value, symsize, type, binding,
1983*fae548d3Szrj visibility, nonvis,
1984*fae548d3Szrj offset_is_from_end,
1985*fae548d3Szrj only_if_ref);
1986*fae548d3Szrj #else
1987*fae548d3Szrj gold_unreachable();
1988*fae548d3Szrj #endif
1989*fae548d3Szrj }
1990*fae548d3Szrj else
1991*fae548d3Szrj gold_unreachable();
1992*fae548d3Szrj }
1993*fae548d3Szrj
1994*fae548d3Szrj // Define a symbol in an Output_data, sized version.
1995*fae548d3Szrj
1996*fae548d3Szrj template<int size>
1997*fae548d3Szrj Sized_symbol<size>*
do_define_in_output_data(const char * name,const char * version,Defined defined,Output_data * od,typename elfcpp::Elf_types<size>::Elf_Addr value,typename elfcpp::Elf_types<size>::Elf_WXword symsize,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis,bool offset_is_from_end,bool only_if_ref)1998*fae548d3Szrj Symbol_table::do_define_in_output_data(
1999*fae548d3Szrj const char* name,
2000*fae548d3Szrj const char* version,
2001*fae548d3Szrj Defined defined,
2002*fae548d3Szrj Output_data* od,
2003*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_Addr value,
2004*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_WXword symsize,
2005*fae548d3Szrj elfcpp::STT type,
2006*fae548d3Szrj elfcpp::STB binding,
2007*fae548d3Szrj elfcpp::STV visibility,
2008*fae548d3Szrj unsigned char nonvis,
2009*fae548d3Szrj bool offset_is_from_end,
2010*fae548d3Szrj bool only_if_ref)
2011*fae548d3Szrj {
2012*fae548d3Szrj Sized_symbol<size>* sym;
2013*fae548d3Szrj Sized_symbol<size>* oldsym;
2014*fae548d3Szrj bool resolve_oldsym;
2015*fae548d3Szrj const bool is_forced_local = binding == elfcpp::STB_LOCAL;
2016*fae548d3Szrj
2017*fae548d3Szrj if (parameters->target().is_big_endian())
2018*fae548d3Szrj {
2019*fae548d3Szrj #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
2020*fae548d3Szrj sym = this->define_special_symbol<size, true>(&name, &version,
2021*fae548d3Szrj only_if_ref,
2022*fae548d3Szrj visibility,
2023*fae548d3Szrj &oldsym,
2024*fae548d3Szrj &resolve_oldsym,
2025*fae548d3Szrj is_forced_local);
2026*fae548d3Szrj #else
2027*fae548d3Szrj gold_unreachable();
2028*fae548d3Szrj #endif
2029*fae548d3Szrj }
2030*fae548d3Szrj else
2031*fae548d3Szrj {
2032*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
2033*fae548d3Szrj sym = this->define_special_symbol<size, false>(&name, &version,
2034*fae548d3Szrj only_if_ref,
2035*fae548d3Szrj visibility,
2036*fae548d3Szrj &oldsym,
2037*fae548d3Szrj &resolve_oldsym,
2038*fae548d3Szrj is_forced_local);
2039*fae548d3Szrj #else
2040*fae548d3Szrj gold_unreachable();
2041*fae548d3Szrj #endif
2042*fae548d3Szrj }
2043*fae548d3Szrj
2044*fae548d3Szrj if (sym == NULL)
2045*fae548d3Szrj return NULL;
2046*fae548d3Szrj
2047*fae548d3Szrj sym->init_output_data(name, version, od, value, symsize, type, binding,
2048*fae548d3Szrj visibility, nonvis, offset_is_from_end,
2049*fae548d3Szrj defined == PREDEFINED);
2050*fae548d3Szrj
2051*fae548d3Szrj if (oldsym == NULL)
2052*fae548d3Szrj {
2053*fae548d3Szrj if (is_forced_local || this->version_script_.symbol_is_local(name))
2054*fae548d3Szrj this->force_local(sym);
2055*fae548d3Szrj else if (version != NULL)
2056*fae548d3Szrj sym->set_is_default();
2057*fae548d3Szrj return sym;
2058*fae548d3Szrj }
2059*fae548d3Szrj
2060*fae548d3Szrj if (Symbol_table::should_override_with_special(oldsym, type, defined))
2061*fae548d3Szrj this->override_with_special(oldsym, sym);
2062*fae548d3Szrj
2063*fae548d3Szrj if (resolve_oldsym)
2064*fae548d3Szrj return sym;
2065*fae548d3Szrj else
2066*fae548d3Szrj {
2067*fae548d3Szrj if (defined == PREDEFINED
2068*fae548d3Szrj && (is_forced_local || this->version_script_.symbol_is_local(name)))
2069*fae548d3Szrj this->force_local(oldsym);
2070*fae548d3Szrj delete sym;
2071*fae548d3Szrj return oldsym;
2072*fae548d3Szrj }
2073*fae548d3Szrj }
2074*fae548d3Szrj
2075*fae548d3Szrj // Define a symbol based on an Output_segment.
2076*fae548d3Szrj
2077*fae548d3Szrj Symbol*
define_in_output_segment(const char * name,const char * version,Defined defined,Output_segment * os,uint64_t value,uint64_t symsize,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis,Symbol::Segment_offset_base offset_base,bool only_if_ref)2078*fae548d3Szrj Symbol_table::define_in_output_segment(const char* name,
2079*fae548d3Szrj const char* version,
2080*fae548d3Szrj Defined defined,
2081*fae548d3Szrj Output_segment* os,
2082*fae548d3Szrj uint64_t value,
2083*fae548d3Szrj uint64_t symsize,
2084*fae548d3Szrj elfcpp::STT type,
2085*fae548d3Szrj elfcpp::STB binding,
2086*fae548d3Szrj elfcpp::STV visibility,
2087*fae548d3Szrj unsigned char nonvis,
2088*fae548d3Szrj Symbol::Segment_offset_base offset_base,
2089*fae548d3Szrj bool only_if_ref)
2090*fae548d3Szrj {
2091*fae548d3Szrj if (parameters->target().get_size() == 32)
2092*fae548d3Szrj {
2093*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
2094*fae548d3Szrj return this->do_define_in_output_segment<32>(name, version, defined, os,
2095*fae548d3Szrj value, symsize, type,
2096*fae548d3Szrj binding, visibility, nonvis,
2097*fae548d3Szrj offset_base, only_if_ref);
2098*fae548d3Szrj #else
2099*fae548d3Szrj gold_unreachable();
2100*fae548d3Szrj #endif
2101*fae548d3Szrj }
2102*fae548d3Szrj else if (parameters->target().get_size() == 64)
2103*fae548d3Szrj {
2104*fae548d3Szrj #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
2105*fae548d3Szrj return this->do_define_in_output_segment<64>(name, version, defined, os,
2106*fae548d3Szrj value, symsize, type,
2107*fae548d3Szrj binding, visibility, nonvis,
2108*fae548d3Szrj offset_base, only_if_ref);
2109*fae548d3Szrj #else
2110*fae548d3Szrj gold_unreachable();
2111*fae548d3Szrj #endif
2112*fae548d3Szrj }
2113*fae548d3Szrj else
2114*fae548d3Szrj gold_unreachable();
2115*fae548d3Szrj }
2116*fae548d3Szrj
2117*fae548d3Szrj // Define a symbol in an Output_segment, sized version.
2118*fae548d3Szrj
2119*fae548d3Szrj template<int size>
2120*fae548d3Szrj Sized_symbol<size>*
do_define_in_output_segment(const char * name,const char * version,Defined defined,Output_segment * os,typename elfcpp::Elf_types<size>::Elf_Addr value,typename elfcpp::Elf_types<size>::Elf_WXword symsize,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis,Symbol::Segment_offset_base offset_base,bool only_if_ref)2121*fae548d3Szrj Symbol_table::do_define_in_output_segment(
2122*fae548d3Szrj const char* name,
2123*fae548d3Szrj const char* version,
2124*fae548d3Szrj Defined defined,
2125*fae548d3Szrj Output_segment* os,
2126*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_Addr value,
2127*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_WXword symsize,
2128*fae548d3Szrj elfcpp::STT type,
2129*fae548d3Szrj elfcpp::STB binding,
2130*fae548d3Szrj elfcpp::STV visibility,
2131*fae548d3Szrj unsigned char nonvis,
2132*fae548d3Szrj Symbol::Segment_offset_base offset_base,
2133*fae548d3Szrj bool only_if_ref)
2134*fae548d3Szrj {
2135*fae548d3Szrj Sized_symbol<size>* sym;
2136*fae548d3Szrj Sized_symbol<size>* oldsym;
2137*fae548d3Szrj bool resolve_oldsym;
2138*fae548d3Szrj const bool is_forced_local = binding == elfcpp::STB_LOCAL;
2139*fae548d3Szrj
2140*fae548d3Szrj if (parameters->target().is_big_endian())
2141*fae548d3Szrj {
2142*fae548d3Szrj #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
2143*fae548d3Szrj sym = this->define_special_symbol<size, true>(&name, &version,
2144*fae548d3Szrj only_if_ref,
2145*fae548d3Szrj visibility,
2146*fae548d3Szrj &oldsym,
2147*fae548d3Szrj &resolve_oldsym,
2148*fae548d3Szrj is_forced_local);
2149*fae548d3Szrj #else
2150*fae548d3Szrj gold_unreachable();
2151*fae548d3Szrj #endif
2152*fae548d3Szrj }
2153*fae548d3Szrj else
2154*fae548d3Szrj {
2155*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
2156*fae548d3Szrj sym = this->define_special_symbol<size, false>(&name, &version,
2157*fae548d3Szrj only_if_ref,
2158*fae548d3Szrj visibility,
2159*fae548d3Szrj &oldsym,
2160*fae548d3Szrj &resolve_oldsym,
2161*fae548d3Szrj is_forced_local);
2162*fae548d3Szrj #else
2163*fae548d3Szrj gold_unreachable();
2164*fae548d3Szrj #endif
2165*fae548d3Szrj }
2166*fae548d3Szrj
2167*fae548d3Szrj if (sym == NULL)
2168*fae548d3Szrj return NULL;
2169*fae548d3Szrj
2170*fae548d3Szrj sym->init_output_segment(name, version, os, value, symsize, type, binding,
2171*fae548d3Szrj visibility, nonvis, offset_base,
2172*fae548d3Szrj defined == PREDEFINED);
2173*fae548d3Szrj
2174*fae548d3Szrj if (oldsym == NULL)
2175*fae548d3Szrj {
2176*fae548d3Szrj if (is_forced_local || this->version_script_.symbol_is_local(name))
2177*fae548d3Szrj this->force_local(sym);
2178*fae548d3Szrj else if (version != NULL)
2179*fae548d3Szrj sym->set_is_default();
2180*fae548d3Szrj return sym;
2181*fae548d3Szrj }
2182*fae548d3Szrj
2183*fae548d3Szrj if (Symbol_table::should_override_with_special(oldsym, type, defined))
2184*fae548d3Szrj this->override_with_special(oldsym, sym);
2185*fae548d3Szrj
2186*fae548d3Szrj if (resolve_oldsym)
2187*fae548d3Szrj return sym;
2188*fae548d3Szrj else
2189*fae548d3Szrj {
2190*fae548d3Szrj if (is_forced_local || this->version_script_.symbol_is_local(name))
2191*fae548d3Szrj this->force_local(oldsym);
2192*fae548d3Szrj delete sym;
2193*fae548d3Szrj return oldsym;
2194*fae548d3Szrj }
2195*fae548d3Szrj }
2196*fae548d3Szrj
2197*fae548d3Szrj // Define a special symbol with a constant value. It is a multiple
2198*fae548d3Szrj // definition error if this symbol is already defined.
2199*fae548d3Szrj
2200*fae548d3Szrj Symbol*
define_as_constant(const char * name,const char * version,Defined defined,uint64_t value,uint64_t symsize,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis,bool only_if_ref,bool force_override)2201*fae548d3Szrj Symbol_table::define_as_constant(const char* name,
2202*fae548d3Szrj const char* version,
2203*fae548d3Szrj Defined defined,
2204*fae548d3Szrj uint64_t value,
2205*fae548d3Szrj uint64_t symsize,
2206*fae548d3Szrj elfcpp::STT type,
2207*fae548d3Szrj elfcpp::STB binding,
2208*fae548d3Szrj elfcpp::STV visibility,
2209*fae548d3Szrj unsigned char nonvis,
2210*fae548d3Szrj bool only_if_ref,
2211*fae548d3Szrj bool force_override)
2212*fae548d3Szrj {
2213*fae548d3Szrj if (parameters->target().get_size() == 32)
2214*fae548d3Szrj {
2215*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
2216*fae548d3Szrj return this->do_define_as_constant<32>(name, version, defined, value,
2217*fae548d3Szrj symsize, type, binding,
2218*fae548d3Szrj visibility, nonvis, only_if_ref,
2219*fae548d3Szrj force_override);
2220*fae548d3Szrj #else
2221*fae548d3Szrj gold_unreachable();
2222*fae548d3Szrj #endif
2223*fae548d3Szrj }
2224*fae548d3Szrj else if (parameters->target().get_size() == 64)
2225*fae548d3Szrj {
2226*fae548d3Szrj #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
2227*fae548d3Szrj return this->do_define_as_constant<64>(name, version, defined, value,
2228*fae548d3Szrj symsize, type, binding,
2229*fae548d3Szrj visibility, nonvis, only_if_ref,
2230*fae548d3Szrj force_override);
2231*fae548d3Szrj #else
2232*fae548d3Szrj gold_unreachable();
2233*fae548d3Szrj #endif
2234*fae548d3Szrj }
2235*fae548d3Szrj else
2236*fae548d3Szrj gold_unreachable();
2237*fae548d3Szrj }
2238*fae548d3Szrj
2239*fae548d3Szrj // Define a symbol as a constant, sized version.
2240*fae548d3Szrj
2241*fae548d3Szrj template<int size>
2242*fae548d3Szrj Sized_symbol<size>*
do_define_as_constant(const char * name,const char * version,Defined defined,typename elfcpp::Elf_types<size>::Elf_Addr value,typename elfcpp::Elf_types<size>::Elf_WXword symsize,elfcpp::STT type,elfcpp::STB binding,elfcpp::STV visibility,unsigned char nonvis,bool only_if_ref,bool force_override)2243*fae548d3Szrj Symbol_table::do_define_as_constant(
2244*fae548d3Szrj const char* name,
2245*fae548d3Szrj const char* version,
2246*fae548d3Szrj Defined defined,
2247*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_Addr value,
2248*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_WXword symsize,
2249*fae548d3Szrj elfcpp::STT type,
2250*fae548d3Szrj elfcpp::STB binding,
2251*fae548d3Szrj elfcpp::STV visibility,
2252*fae548d3Szrj unsigned char nonvis,
2253*fae548d3Szrj bool only_if_ref,
2254*fae548d3Szrj bool force_override)
2255*fae548d3Szrj {
2256*fae548d3Szrj Sized_symbol<size>* sym;
2257*fae548d3Szrj Sized_symbol<size>* oldsym;
2258*fae548d3Szrj bool resolve_oldsym;
2259*fae548d3Szrj const bool is_forced_local = binding == elfcpp::STB_LOCAL;
2260*fae548d3Szrj
2261*fae548d3Szrj if (parameters->target().is_big_endian())
2262*fae548d3Szrj {
2263*fae548d3Szrj #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
2264*fae548d3Szrj sym = this->define_special_symbol<size, true>(&name, &version,
2265*fae548d3Szrj only_if_ref,
2266*fae548d3Szrj visibility,
2267*fae548d3Szrj &oldsym,
2268*fae548d3Szrj &resolve_oldsym,
2269*fae548d3Szrj is_forced_local);
2270*fae548d3Szrj #else
2271*fae548d3Szrj gold_unreachable();
2272*fae548d3Szrj #endif
2273*fae548d3Szrj }
2274*fae548d3Szrj else
2275*fae548d3Szrj {
2276*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
2277*fae548d3Szrj sym = this->define_special_symbol<size, false>(&name, &version,
2278*fae548d3Szrj only_if_ref,
2279*fae548d3Szrj visibility,
2280*fae548d3Szrj &oldsym,
2281*fae548d3Szrj &resolve_oldsym,
2282*fae548d3Szrj is_forced_local);
2283*fae548d3Szrj #else
2284*fae548d3Szrj gold_unreachable();
2285*fae548d3Szrj #endif
2286*fae548d3Szrj }
2287*fae548d3Szrj
2288*fae548d3Szrj if (sym == NULL)
2289*fae548d3Szrj return NULL;
2290*fae548d3Szrj
2291*fae548d3Szrj sym->init_constant(name, version, value, symsize, type, binding, visibility,
2292*fae548d3Szrj nonvis, defined == PREDEFINED);
2293*fae548d3Szrj
2294*fae548d3Szrj if (oldsym == NULL)
2295*fae548d3Szrj {
2296*fae548d3Szrj // Version symbols are absolute symbols with name == version.
2297*fae548d3Szrj // We don't want to force them to be local.
2298*fae548d3Szrj if ((version == NULL
2299*fae548d3Szrj || name != version
2300*fae548d3Szrj || value != 0)
2301*fae548d3Szrj && (is_forced_local || this->version_script_.symbol_is_local(name)))
2302*fae548d3Szrj this->force_local(sym);
2303*fae548d3Szrj else if (version != NULL
2304*fae548d3Szrj && (name != version || value != 0))
2305*fae548d3Szrj sym->set_is_default();
2306*fae548d3Szrj return sym;
2307*fae548d3Szrj }
2308*fae548d3Szrj
2309*fae548d3Szrj if (force_override
2310*fae548d3Szrj || Symbol_table::should_override_with_special(oldsym, type, defined))
2311*fae548d3Szrj this->override_with_special(oldsym, sym);
2312*fae548d3Szrj
2313*fae548d3Szrj if (resolve_oldsym)
2314*fae548d3Szrj return sym;
2315*fae548d3Szrj else
2316*fae548d3Szrj {
2317*fae548d3Szrj if (is_forced_local || this->version_script_.symbol_is_local(name))
2318*fae548d3Szrj this->force_local(oldsym);
2319*fae548d3Szrj delete sym;
2320*fae548d3Szrj return oldsym;
2321*fae548d3Szrj }
2322*fae548d3Szrj }
2323*fae548d3Szrj
2324*fae548d3Szrj // Define a set of symbols in output sections.
2325*fae548d3Szrj
2326*fae548d3Szrj void
define_symbols(const Layout * layout,int count,const Define_symbol_in_section * p,bool only_if_ref)2327*fae548d3Szrj Symbol_table::define_symbols(const Layout* layout, int count,
2328*fae548d3Szrj const Define_symbol_in_section* p,
2329*fae548d3Szrj bool only_if_ref)
2330*fae548d3Szrj {
2331*fae548d3Szrj for (int i = 0; i < count; ++i, ++p)
2332*fae548d3Szrj {
2333*fae548d3Szrj Output_section* os = layout->find_output_section(p->output_section);
2334*fae548d3Szrj if (os != NULL)
2335*fae548d3Szrj this->define_in_output_data(p->name, NULL, PREDEFINED, os, p->value,
2336*fae548d3Szrj p->size, p->type, p->binding,
2337*fae548d3Szrj p->visibility, p->nonvis,
2338*fae548d3Szrj p->offset_is_from_end,
2339*fae548d3Szrj only_if_ref || p->only_if_ref);
2340*fae548d3Szrj else
2341*fae548d3Szrj this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size,
2342*fae548d3Szrj p->type, p->binding, p->visibility, p->nonvis,
2343*fae548d3Szrj only_if_ref || p->only_if_ref,
2344*fae548d3Szrj false);
2345*fae548d3Szrj }
2346*fae548d3Szrj }
2347*fae548d3Szrj
2348*fae548d3Szrj // Define a set of symbols in output segments.
2349*fae548d3Szrj
2350*fae548d3Szrj void
define_symbols(const Layout * layout,int count,const Define_symbol_in_segment * p,bool only_if_ref)2351*fae548d3Szrj Symbol_table::define_symbols(const Layout* layout, int count,
2352*fae548d3Szrj const Define_symbol_in_segment* p,
2353*fae548d3Szrj bool only_if_ref)
2354*fae548d3Szrj {
2355*fae548d3Szrj for (int i = 0; i < count; ++i, ++p)
2356*fae548d3Szrj {
2357*fae548d3Szrj Output_segment* os = layout->find_output_segment(p->segment_type,
2358*fae548d3Szrj p->segment_flags_set,
2359*fae548d3Szrj p->segment_flags_clear);
2360*fae548d3Szrj if (os != NULL)
2361*fae548d3Szrj this->define_in_output_segment(p->name, NULL, PREDEFINED, os, p->value,
2362*fae548d3Szrj p->size, p->type, p->binding,
2363*fae548d3Szrj p->visibility, p->nonvis,
2364*fae548d3Szrj p->offset_base,
2365*fae548d3Szrj only_if_ref || p->only_if_ref);
2366*fae548d3Szrj else
2367*fae548d3Szrj this->define_as_constant(p->name, NULL, PREDEFINED, 0, p->size,
2368*fae548d3Szrj p->type, p->binding, p->visibility, p->nonvis,
2369*fae548d3Szrj only_if_ref || p->only_if_ref,
2370*fae548d3Szrj false);
2371*fae548d3Szrj }
2372*fae548d3Szrj }
2373*fae548d3Szrj
2374*fae548d3Szrj // Define CSYM using a COPY reloc. POSD is the Output_data where the
2375*fae548d3Szrj // symbol should be defined--typically a .dyn.bss section. VALUE is
2376*fae548d3Szrj // the offset within POSD.
2377*fae548d3Szrj
2378*fae548d3Szrj template<int size>
2379*fae548d3Szrj void
define_with_copy_reloc(Sized_symbol<size> * csym,Output_data * posd,typename elfcpp::Elf_types<size>::Elf_Addr value)2380*fae548d3Szrj Symbol_table::define_with_copy_reloc(
2381*fae548d3Szrj Sized_symbol<size>* csym,
2382*fae548d3Szrj Output_data* posd,
2383*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_Addr value)
2384*fae548d3Szrj {
2385*fae548d3Szrj gold_assert(csym->is_from_dynobj());
2386*fae548d3Szrj gold_assert(!csym->is_copied_from_dynobj());
2387*fae548d3Szrj Object* object = csym->object();
2388*fae548d3Szrj gold_assert(object->is_dynamic());
2389*fae548d3Szrj Dynobj* dynobj = static_cast<Dynobj*>(object);
2390*fae548d3Szrj
2391*fae548d3Szrj // Our copied variable has to override any variable in a shared
2392*fae548d3Szrj // library.
2393*fae548d3Szrj elfcpp::STB binding = csym->binding();
2394*fae548d3Szrj if (binding == elfcpp::STB_WEAK)
2395*fae548d3Szrj binding = elfcpp::STB_GLOBAL;
2396*fae548d3Szrj
2397*fae548d3Szrj this->define_in_output_data(csym->name(), csym->version(), COPY,
2398*fae548d3Szrj posd, value, csym->symsize(),
2399*fae548d3Szrj csym->type(), binding,
2400*fae548d3Szrj csym->visibility(), csym->nonvis(),
2401*fae548d3Szrj false, false);
2402*fae548d3Szrj
2403*fae548d3Szrj csym->set_is_copied_from_dynobj();
2404*fae548d3Szrj csym->set_needs_dynsym_entry();
2405*fae548d3Szrj
2406*fae548d3Szrj this->copied_symbol_dynobjs_[csym] = dynobj;
2407*fae548d3Szrj
2408*fae548d3Szrj // We have now defined all aliases, but we have not entered them all
2409*fae548d3Szrj // in the copied_symbol_dynobjs_ map.
2410*fae548d3Szrj if (csym->has_alias())
2411*fae548d3Szrj {
2412*fae548d3Szrj Symbol* sym = csym;
2413*fae548d3Szrj while (true)
2414*fae548d3Szrj {
2415*fae548d3Szrj sym = this->weak_aliases_[sym];
2416*fae548d3Szrj if (sym == csym)
2417*fae548d3Szrj break;
2418*fae548d3Szrj gold_assert(sym->output_data() == posd);
2419*fae548d3Szrj
2420*fae548d3Szrj sym->set_is_copied_from_dynobj();
2421*fae548d3Szrj this->copied_symbol_dynobjs_[sym] = dynobj;
2422*fae548d3Szrj }
2423*fae548d3Szrj }
2424*fae548d3Szrj }
2425*fae548d3Szrj
2426*fae548d3Szrj // SYM is defined using a COPY reloc. Return the dynamic object where
2427*fae548d3Szrj // the original definition was found.
2428*fae548d3Szrj
2429*fae548d3Szrj Dynobj*
get_copy_source(const Symbol * sym) const2430*fae548d3Szrj Symbol_table::get_copy_source(const Symbol* sym) const
2431*fae548d3Szrj {
2432*fae548d3Szrj gold_assert(sym->is_copied_from_dynobj());
2433*fae548d3Szrj Copied_symbol_dynobjs::const_iterator p =
2434*fae548d3Szrj this->copied_symbol_dynobjs_.find(sym);
2435*fae548d3Szrj gold_assert(p != this->copied_symbol_dynobjs_.end());
2436*fae548d3Szrj return p->second;
2437*fae548d3Szrj }
2438*fae548d3Szrj
2439*fae548d3Szrj // Add any undefined symbols named on the command line.
2440*fae548d3Szrj
2441*fae548d3Szrj void
add_undefined_symbols_from_command_line(Layout * layout)2442*fae548d3Szrj Symbol_table::add_undefined_symbols_from_command_line(Layout* layout)
2443*fae548d3Szrj {
2444*fae548d3Szrj if (parameters->options().any_undefined()
2445*fae548d3Szrj || layout->script_options()->any_unreferenced())
2446*fae548d3Szrj {
2447*fae548d3Szrj if (parameters->target().get_size() == 32)
2448*fae548d3Szrj {
2449*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
2450*fae548d3Szrj this->do_add_undefined_symbols_from_command_line<32>(layout);
2451*fae548d3Szrj #else
2452*fae548d3Szrj gold_unreachable();
2453*fae548d3Szrj #endif
2454*fae548d3Szrj }
2455*fae548d3Szrj else if (parameters->target().get_size() == 64)
2456*fae548d3Szrj {
2457*fae548d3Szrj #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
2458*fae548d3Szrj this->do_add_undefined_symbols_from_command_line<64>(layout);
2459*fae548d3Szrj #else
2460*fae548d3Szrj gold_unreachable();
2461*fae548d3Szrj #endif
2462*fae548d3Szrj }
2463*fae548d3Szrj else
2464*fae548d3Szrj gold_unreachable();
2465*fae548d3Szrj }
2466*fae548d3Szrj }
2467*fae548d3Szrj
2468*fae548d3Szrj template<int size>
2469*fae548d3Szrj void
do_add_undefined_symbols_from_command_line(Layout * layout)2470*fae548d3Szrj Symbol_table::do_add_undefined_symbols_from_command_line(Layout* layout)
2471*fae548d3Szrj {
2472*fae548d3Szrj for (options::String_set::const_iterator p =
2473*fae548d3Szrj parameters->options().undefined_begin();
2474*fae548d3Szrj p != parameters->options().undefined_end();
2475*fae548d3Szrj ++p)
2476*fae548d3Szrj this->add_undefined_symbol_from_command_line<size>(p->c_str());
2477*fae548d3Szrj
2478*fae548d3Szrj for (options::String_set::const_iterator p =
2479*fae548d3Szrj parameters->options().export_dynamic_symbol_begin();
2480*fae548d3Szrj p != parameters->options().export_dynamic_symbol_end();
2481*fae548d3Szrj ++p)
2482*fae548d3Szrj this->add_undefined_symbol_from_command_line<size>(p->c_str());
2483*fae548d3Szrj
2484*fae548d3Szrj for (Script_options::referenced_const_iterator p =
2485*fae548d3Szrj layout->script_options()->referenced_begin();
2486*fae548d3Szrj p != layout->script_options()->referenced_end();
2487*fae548d3Szrj ++p)
2488*fae548d3Szrj this->add_undefined_symbol_from_command_line<size>(p->c_str());
2489*fae548d3Szrj }
2490*fae548d3Szrj
2491*fae548d3Szrj template<int size>
2492*fae548d3Szrj void
add_undefined_symbol_from_command_line(const char * name)2493*fae548d3Szrj Symbol_table::add_undefined_symbol_from_command_line(const char* name)
2494*fae548d3Szrj {
2495*fae548d3Szrj if (this->lookup(name) != NULL)
2496*fae548d3Szrj return;
2497*fae548d3Szrj
2498*fae548d3Szrj const char* version = NULL;
2499*fae548d3Szrj
2500*fae548d3Szrj Sized_symbol<size>* sym;
2501*fae548d3Szrj Sized_symbol<size>* oldsym;
2502*fae548d3Szrj bool resolve_oldsym;
2503*fae548d3Szrj if (parameters->target().is_big_endian())
2504*fae548d3Szrj {
2505*fae548d3Szrj #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
2506*fae548d3Szrj sym = this->define_special_symbol<size, true>(&name, &version,
2507*fae548d3Szrj false,
2508*fae548d3Szrj elfcpp::STV_DEFAULT,
2509*fae548d3Szrj &oldsym,
2510*fae548d3Szrj &resolve_oldsym,
2511*fae548d3Szrj false);
2512*fae548d3Szrj #else
2513*fae548d3Szrj gold_unreachable();
2514*fae548d3Szrj #endif
2515*fae548d3Szrj }
2516*fae548d3Szrj else
2517*fae548d3Szrj {
2518*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
2519*fae548d3Szrj sym = this->define_special_symbol<size, false>(&name, &version,
2520*fae548d3Szrj false,
2521*fae548d3Szrj elfcpp::STV_DEFAULT,
2522*fae548d3Szrj &oldsym,
2523*fae548d3Szrj &resolve_oldsym,
2524*fae548d3Szrj false);
2525*fae548d3Szrj #else
2526*fae548d3Szrj gold_unreachable();
2527*fae548d3Szrj #endif
2528*fae548d3Szrj }
2529*fae548d3Szrj
2530*fae548d3Szrj gold_assert(oldsym == NULL);
2531*fae548d3Szrj
2532*fae548d3Szrj sym->init_undefined(name, version, 0, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
2533*fae548d3Szrj elfcpp::STV_DEFAULT, 0);
2534*fae548d3Szrj ++this->saw_undefined_;
2535*fae548d3Szrj }
2536*fae548d3Szrj
2537*fae548d3Szrj // Set the dynamic symbol indexes. INDEX is the index of the first
2538*fae548d3Szrj // global dynamic symbol. Pointers to the global symbols are stored
2539*fae548d3Szrj // into the vector SYMS. The names are added to DYNPOOL.
2540*fae548d3Szrj // This returns an updated dynamic symbol index.
2541*fae548d3Szrj
2542*fae548d3Szrj unsigned int
set_dynsym_indexes(unsigned int index,unsigned int * pforced_local_count,std::vector<Symbol * > * syms,Stringpool * dynpool,Versions * versions)2543*fae548d3Szrj Symbol_table::set_dynsym_indexes(unsigned int index,
2544*fae548d3Szrj unsigned int* pforced_local_count,
2545*fae548d3Szrj std::vector<Symbol*>* syms,
2546*fae548d3Szrj Stringpool* dynpool,
2547*fae548d3Szrj Versions* versions)
2548*fae548d3Szrj {
2549*fae548d3Szrj // First process all the symbols which have been forced to be local,
2550*fae548d3Szrj // as they must appear before all global symbols.
2551*fae548d3Szrj unsigned int forced_local_count = 0;
2552*fae548d3Szrj for (Forced_locals::iterator p = this->forced_locals_.begin();
2553*fae548d3Szrj p != this->forced_locals_.end();
2554*fae548d3Szrj ++p)
2555*fae548d3Szrj {
2556*fae548d3Szrj Symbol* sym = *p;
2557*fae548d3Szrj gold_assert(sym->is_forced_local());
2558*fae548d3Szrj if (sym->has_dynsym_index())
2559*fae548d3Szrj continue;
2560*fae548d3Szrj if (!sym->should_add_dynsym_entry(this))
2561*fae548d3Szrj sym->set_dynsym_index(-1U);
2562*fae548d3Szrj else
2563*fae548d3Szrj {
2564*fae548d3Szrj sym->set_dynsym_index(index);
2565*fae548d3Szrj ++index;
2566*fae548d3Szrj ++forced_local_count;
2567*fae548d3Szrj dynpool->add(sym->name(), false, NULL);
2568*fae548d3Szrj if (sym->type() == elfcpp::STT_GNU_IFUNC)
2569*fae548d3Szrj this->set_has_gnu_output();
2570*fae548d3Szrj }
2571*fae548d3Szrj }
2572*fae548d3Szrj *pforced_local_count = forced_local_count;
2573*fae548d3Szrj
2574*fae548d3Szrj // Allow a target to set dynsym indexes.
2575*fae548d3Szrj if (parameters->target().has_custom_set_dynsym_indexes())
2576*fae548d3Szrj {
2577*fae548d3Szrj std::vector<Symbol*> dyn_symbols;
2578*fae548d3Szrj for (Symbol_table_type::iterator p = this->table_.begin();
2579*fae548d3Szrj p != this->table_.end();
2580*fae548d3Szrj ++p)
2581*fae548d3Szrj {
2582*fae548d3Szrj Symbol* sym = p->second;
2583*fae548d3Szrj if (sym->is_forced_local())
2584*fae548d3Szrj continue;
2585*fae548d3Szrj if (!sym->should_add_dynsym_entry(this))
2586*fae548d3Szrj sym->set_dynsym_index(-1U);
2587*fae548d3Szrj else
2588*fae548d3Szrj {
2589*fae548d3Szrj dyn_symbols.push_back(sym);
2590*fae548d3Szrj if (sym->type() == elfcpp::STT_GNU_IFUNC
2591*fae548d3Szrj || (sym->binding() == elfcpp::STB_GNU_UNIQUE
2592*fae548d3Szrj && parameters->options().gnu_unique()))
2593*fae548d3Szrj this->set_has_gnu_output();
2594*fae548d3Szrj }
2595*fae548d3Szrj }
2596*fae548d3Szrj
2597*fae548d3Szrj return parameters->target().set_dynsym_indexes(&dyn_symbols, index, syms,
2598*fae548d3Szrj dynpool, versions, this);
2599*fae548d3Szrj }
2600*fae548d3Szrj
2601*fae548d3Szrj for (Symbol_table_type::iterator p = this->table_.begin();
2602*fae548d3Szrj p != this->table_.end();
2603*fae548d3Szrj ++p)
2604*fae548d3Szrj {
2605*fae548d3Szrj Symbol* sym = p->second;
2606*fae548d3Szrj
2607*fae548d3Szrj if (sym->is_forced_local())
2608*fae548d3Szrj continue;
2609*fae548d3Szrj
2610*fae548d3Szrj // Note that SYM may already have a dynamic symbol index, since
2611*fae548d3Szrj // some symbols appear more than once in the symbol table, with
2612*fae548d3Szrj // and without a version.
2613*fae548d3Szrj
2614*fae548d3Szrj if (!sym->should_add_dynsym_entry(this))
2615*fae548d3Szrj sym->set_dynsym_index(-1U);
2616*fae548d3Szrj else if (!sym->has_dynsym_index())
2617*fae548d3Szrj {
2618*fae548d3Szrj sym->set_dynsym_index(index);
2619*fae548d3Szrj ++index;
2620*fae548d3Szrj syms->push_back(sym);
2621*fae548d3Szrj dynpool->add(sym->name(), false, NULL);
2622*fae548d3Szrj if (sym->type() == elfcpp::STT_GNU_IFUNC
2623*fae548d3Szrj || (sym->binding() == elfcpp::STB_GNU_UNIQUE
2624*fae548d3Szrj && parameters->options().gnu_unique()))
2625*fae548d3Szrj this->set_has_gnu_output();
2626*fae548d3Szrj
2627*fae548d3Szrj // Record any version information, except those from
2628*fae548d3Szrj // as-needed libraries not seen to be needed. Note that the
2629*fae548d3Szrj // is_needed state for such libraries can change in this loop.
2630*fae548d3Szrj if (sym->version() != NULL)
2631*fae548d3Szrj {
2632*fae548d3Szrj if (!sym->is_from_dynobj()
2633*fae548d3Szrj || !sym->object()->as_needed()
2634*fae548d3Szrj || sym->object()->is_needed())
2635*fae548d3Szrj versions->record_version(this, dynpool, sym);
2636*fae548d3Szrj else
2637*fae548d3Szrj {
2638*fae548d3Szrj if (parameters->options().warn_drop_version())
2639*fae548d3Szrj gold_warning(_("discarding version information for "
2640*fae548d3Szrj "%s@%s, defined in unused shared library %s "
2641*fae548d3Szrj "(linked with --as-needed)"),
2642*fae548d3Szrj sym->name(), sym->version(),
2643*fae548d3Szrj sym->object()->name().c_str());
2644*fae548d3Szrj sym->clear_version();
2645*fae548d3Szrj }
2646*fae548d3Szrj }
2647*fae548d3Szrj }
2648*fae548d3Szrj }
2649*fae548d3Szrj
2650*fae548d3Szrj // Finish up the versions. In some cases this may add new dynamic
2651*fae548d3Szrj // symbols.
2652*fae548d3Szrj index = versions->finalize(this, index, syms);
2653*fae548d3Szrj
2654*fae548d3Szrj // Process target-specific symbols.
2655*fae548d3Szrj for (std::vector<Symbol*>::iterator p = this->target_symbols_.begin();
2656*fae548d3Szrj p != this->target_symbols_.end();
2657*fae548d3Szrj ++p)
2658*fae548d3Szrj {
2659*fae548d3Szrj (*p)->set_dynsym_index(index);
2660*fae548d3Szrj ++index;
2661*fae548d3Szrj syms->push_back(*p);
2662*fae548d3Szrj dynpool->add((*p)->name(), false, NULL);
2663*fae548d3Szrj }
2664*fae548d3Szrj
2665*fae548d3Szrj return index;
2666*fae548d3Szrj }
2667*fae548d3Szrj
2668*fae548d3Szrj // Set the final values for all the symbols. The index of the first
2669*fae548d3Szrj // global symbol in the output file is *PLOCAL_SYMCOUNT. Record the
2670*fae548d3Szrj // file offset OFF. Add their names to POOL. Return the new file
2671*fae548d3Szrj // offset. Update *PLOCAL_SYMCOUNT if necessary. DYNOFF and
2672*fae548d3Szrj // DYN_GLOBAL_INDEX refer to the start of the symbols that will be
2673*fae548d3Szrj // written from the global symbol table in Symtab::write_globals(),
2674*fae548d3Szrj // which will include forced-local symbols. DYN_GLOBAL_INDEX is
2675*fae548d3Szrj // not necessarily the same as the sh_info field for the .dynsym
2676*fae548d3Szrj // section, which will point to the first real global symbol.
2677*fae548d3Szrj
2678*fae548d3Szrj off_t
finalize(off_t off,off_t dynoff,size_t dyn_global_index,size_t dyncount,Stringpool * pool,unsigned int * plocal_symcount)2679*fae548d3Szrj Symbol_table::finalize(off_t off, off_t dynoff, size_t dyn_global_index,
2680*fae548d3Szrj size_t dyncount, Stringpool* pool,
2681*fae548d3Szrj unsigned int* plocal_symcount)
2682*fae548d3Szrj {
2683*fae548d3Szrj off_t ret;
2684*fae548d3Szrj
2685*fae548d3Szrj gold_assert(*plocal_symcount != 0);
2686*fae548d3Szrj this->first_global_index_ = *plocal_symcount;
2687*fae548d3Szrj
2688*fae548d3Szrj this->dynamic_offset_ = dynoff;
2689*fae548d3Szrj this->first_dynamic_global_index_ = dyn_global_index;
2690*fae548d3Szrj this->dynamic_count_ = dyncount;
2691*fae548d3Szrj
2692*fae548d3Szrj if (parameters->target().get_size() == 32)
2693*fae548d3Szrj {
2694*fae548d3Szrj #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_32_LITTLE)
2695*fae548d3Szrj ret = this->sized_finalize<32>(off, pool, plocal_symcount);
2696*fae548d3Szrj #else
2697*fae548d3Szrj gold_unreachable();
2698*fae548d3Szrj #endif
2699*fae548d3Szrj }
2700*fae548d3Szrj else if (parameters->target().get_size() == 64)
2701*fae548d3Szrj {
2702*fae548d3Szrj #if defined(HAVE_TARGET_64_BIG) || defined(HAVE_TARGET_64_LITTLE)
2703*fae548d3Szrj ret = this->sized_finalize<64>(off, pool, plocal_symcount);
2704*fae548d3Szrj #else
2705*fae548d3Szrj gold_unreachable();
2706*fae548d3Szrj #endif
2707*fae548d3Szrj }
2708*fae548d3Szrj else
2709*fae548d3Szrj gold_unreachable();
2710*fae548d3Szrj
2711*fae548d3Szrj if (this->has_gnu_output_)
2712*fae548d3Szrj {
2713*fae548d3Szrj Target* target = const_cast<Target*>(¶meters->target());
2714*fae548d3Szrj if (target->osabi() == elfcpp::ELFOSABI_NONE)
2715*fae548d3Szrj target->set_osabi(elfcpp::ELFOSABI_GNU);
2716*fae548d3Szrj }
2717*fae548d3Szrj
2718*fae548d3Szrj // Now that we have the final symbol table, we can reliably note
2719*fae548d3Szrj // which symbols should get warnings.
2720*fae548d3Szrj this->warnings_.note_warnings(this);
2721*fae548d3Szrj
2722*fae548d3Szrj return ret;
2723*fae548d3Szrj }
2724*fae548d3Szrj
2725*fae548d3Szrj // SYM is going into the symbol table at *PINDEX. Add the name to
2726*fae548d3Szrj // POOL, update *PINDEX and *POFF.
2727*fae548d3Szrj
2728*fae548d3Szrj template<int size>
2729*fae548d3Szrj void
add_to_final_symtab(Symbol * sym,Stringpool * pool,unsigned int * pindex,off_t * poff)2730*fae548d3Szrj Symbol_table::add_to_final_symtab(Symbol* sym, Stringpool* pool,
2731*fae548d3Szrj unsigned int* pindex, off_t* poff)
2732*fae548d3Szrj {
2733*fae548d3Szrj sym->set_symtab_index(*pindex);
2734*fae548d3Szrj if (sym->version() == NULL || !parameters->options().relocatable())
2735*fae548d3Szrj pool->add(sym->name(), false, NULL);
2736*fae548d3Szrj else
2737*fae548d3Szrj pool->add(sym->versioned_name(), true, NULL);
2738*fae548d3Szrj ++*pindex;
2739*fae548d3Szrj *poff += elfcpp::Elf_sizes<size>::sym_size;
2740*fae548d3Szrj }
2741*fae548d3Szrj
2742*fae548d3Szrj // Set the final value for all the symbols. This is called after
2743*fae548d3Szrj // Layout::finalize, so all the output sections have their final
2744*fae548d3Szrj // address.
2745*fae548d3Szrj
2746*fae548d3Szrj template<int size>
2747*fae548d3Szrj off_t
sized_finalize(off_t off,Stringpool * pool,unsigned int * plocal_symcount)2748*fae548d3Szrj Symbol_table::sized_finalize(off_t off, Stringpool* pool,
2749*fae548d3Szrj unsigned int* plocal_symcount)
2750*fae548d3Szrj {
2751*fae548d3Szrj off = align_address(off, size >> 3);
2752*fae548d3Szrj this->offset_ = off;
2753*fae548d3Szrj
2754*fae548d3Szrj unsigned int index = *plocal_symcount;
2755*fae548d3Szrj const unsigned int orig_index = index;
2756*fae548d3Szrj
2757*fae548d3Szrj // First do all the symbols which have been forced to be local, as
2758*fae548d3Szrj // they must appear before all global symbols.
2759*fae548d3Szrj for (Forced_locals::iterator p = this->forced_locals_.begin();
2760*fae548d3Szrj p != this->forced_locals_.end();
2761*fae548d3Szrj ++p)
2762*fae548d3Szrj {
2763*fae548d3Szrj Symbol* sym = *p;
2764*fae548d3Szrj gold_assert(sym->is_forced_local());
2765*fae548d3Szrj if (this->sized_finalize_symbol<size>(sym))
2766*fae548d3Szrj {
2767*fae548d3Szrj this->add_to_final_symtab<size>(sym, pool, &index, &off);
2768*fae548d3Szrj ++*plocal_symcount;
2769*fae548d3Szrj if (sym->type() == elfcpp::STT_GNU_IFUNC)
2770*fae548d3Szrj this->set_has_gnu_output();
2771*fae548d3Szrj }
2772*fae548d3Szrj }
2773*fae548d3Szrj
2774*fae548d3Szrj // Now do all the remaining symbols.
2775*fae548d3Szrj for (Symbol_table_type::iterator p = this->table_.begin();
2776*fae548d3Szrj p != this->table_.end();
2777*fae548d3Szrj ++p)
2778*fae548d3Szrj {
2779*fae548d3Szrj Symbol* sym = p->second;
2780*fae548d3Szrj if (this->sized_finalize_symbol<size>(sym))
2781*fae548d3Szrj {
2782*fae548d3Szrj this->add_to_final_symtab<size>(sym, pool, &index, &off);
2783*fae548d3Szrj if (sym->type() == elfcpp::STT_GNU_IFUNC
2784*fae548d3Szrj || (sym->binding() == elfcpp::STB_GNU_UNIQUE
2785*fae548d3Szrj && parameters->options().gnu_unique()))
2786*fae548d3Szrj this->set_has_gnu_output();
2787*fae548d3Szrj }
2788*fae548d3Szrj }
2789*fae548d3Szrj
2790*fae548d3Szrj // Now do target-specific symbols.
2791*fae548d3Szrj for (std::vector<Symbol*>::iterator p = this->target_symbols_.begin();
2792*fae548d3Szrj p != this->target_symbols_.end();
2793*fae548d3Szrj ++p)
2794*fae548d3Szrj {
2795*fae548d3Szrj this->add_to_final_symtab<size>(*p, pool, &index, &off);
2796*fae548d3Szrj }
2797*fae548d3Szrj
2798*fae548d3Szrj this->output_count_ = index - orig_index;
2799*fae548d3Szrj
2800*fae548d3Szrj return off;
2801*fae548d3Szrj }
2802*fae548d3Szrj
2803*fae548d3Szrj // Compute the final value of SYM and store status in location PSTATUS.
2804*fae548d3Szrj // During relaxation, this may be called multiple times for a symbol to
2805*fae548d3Szrj // compute its would-be final value in each relaxation pass.
2806*fae548d3Szrj
2807*fae548d3Szrj template<int size>
2808*fae548d3Szrj typename Sized_symbol<size>::Value_type
compute_final_value(const Sized_symbol<size> * sym,Compute_final_value_status * pstatus) const2809*fae548d3Szrj Symbol_table::compute_final_value(
2810*fae548d3Szrj const Sized_symbol<size>* sym,
2811*fae548d3Szrj Compute_final_value_status* pstatus) const
2812*fae548d3Szrj {
2813*fae548d3Szrj typedef typename Sized_symbol<size>::Value_type Value_type;
2814*fae548d3Szrj Value_type value;
2815*fae548d3Szrj
2816*fae548d3Szrj switch (sym->source())
2817*fae548d3Szrj {
2818*fae548d3Szrj case Symbol::FROM_OBJECT:
2819*fae548d3Szrj {
2820*fae548d3Szrj bool is_ordinary;
2821*fae548d3Szrj unsigned int shndx = sym->shndx(&is_ordinary);
2822*fae548d3Szrj
2823*fae548d3Szrj if (!is_ordinary
2824*fae548d3Szrj && shndx != elfcpp::SHN_ABS
2825*fae548d3Szrj && !Symbol::is_common_shndx(shndx))
2826*fae548d3Szrj {
2827*fae548d3Szrj *pstatus = CFVS_UNSUPPORTED_SYMBOL_SECTION;
2828*fae548d3Szrj return 0;
2829*fae548d3Szrj }
2830*fae548d3Szrj
2831*fae548d3Szrj Object* symobj = sym->object();
2832*fae548d3Szrj if (symobj->is_dynamic())
2833*fae548d3Szrj {
2834*fae548d3Szrj value = 0;
2835*fae548d3Szrj shndx = elfcpp::SHN_UNDEF;
2836*fae548d3Szrj }
2837*fae548d3Szrj else if (symobj->pluginobj() != NULL)
2838*fae548d3Szrj {
2839*fae548d3Szrj value = 0;
2840*fae548d3Szrj shndx = elfcpp::SHN_UNDEF;
2841*fae548d3Szrj }
2842*fae548d3Szrj else if (shndx == elfcpp::SHN_UNDEF)
2843*fae548d3Szrj value = 0;
2844*fae548d3Szrj else if (!is_ordinary
2845*fae548d3Szrj && (shndx == elfcpp::SHN_ABS
2846*fae548d3Szrj || Symbol::is_common_shndx(shndx)))
2847*fae548d3Szrj value = sym->value();
2848*fae548d3Szrj else
2849*fae548d3Szrj {
2850*fae548d3Szrj Relobj* relobj = static_cast<Relobj*>(symobj);
2851*fae548d3Szrj Output_section* os = relobj->output_section(shndx);
2852*fae548d3Szrj
2853*fae548d3Szrj if (this->is_section_folded(relobj, shndx))
2854*fae548d3Szrj {
2855*fae548d3Szrj gold_assert(os == NULL);
2856*fae548d3Szrj // Get the os of the section it is folded onto.
2857*fae548d3Szrj Section_id folded = this->icf_->get_folded_section(relobj,
2858*fae548d3Szrj shndx);
2859*fae548d3Szrj gold_assert(folded.first != NULL);
2860*fae548d3Szrj Relobj* folded_obj = reinterpret_cast<Relobj*>(folded.first);
2861*fae548d3Szrj unsigned folded_shndx = folded.second;
2862*fae548d3Szrj
2863*fae548d3Szrj os = folded_obj->output_section(folded_shndx);
2864*fae548d3Szrj gold_assert(os != NULL);
2865*fae548d3Szrj
2866*fae548d3Szrj // Replace (relobj, shndx) with canonical ICF input section.
2867*fae548d3Szrj shndx = folded_shndx;
2868*fae548d3Szrj relobj = folded_obj;
2869*fae548d3Szrj }
2870*fae548d3Szrj
2871*fae548d3Szrj uint64_t secoff64 = relobj->output_section_offset(shndx);
2872*fae548d3Szrj if (os == NULL)
2873*fae548d3Szrj {
2874*fae548d3Szrj bool static_or_reloc = (parameters->doing_static_link() ||
2875*fae548d3Szrj parameters->options().relocatable());
2876*fae548d3Szrj gold_assert(static_or_reloc || sym->dynsym_index() == -1U);
2877*fae548d3Szrj
2878*fae548d3Szrj *pstatus = CFVS_NO_OUTPUT_SECTION;
2879*fae548d3Szrj return 0;
2880*fae548d3Szrj }
2881*fae548d3Szrj
2882*fae548d3Szrj if (secoff64 == -1ULL)
2883*fae548d3Szrj {
2884*fae548d3Szrj // The section needs special handling (e.g., a merge section).
2885*fae548d3Szrj
2886*fae548d3Szrj value = os->output_address(relobj, shndx, sym->value());
2887*fae548d3Szrj }
2888*fae548d3Szrj else
2889*fae548d3Szrj {
2890*fae548d3Szrj Value_type secoff =
2891*fae548d3Szrj convert_types<Value_type, uint64_t>(secoff64);
2892*fae548d3Szrj if (sym->type() == elfcpp::STT_TLS)
2893*fae548d3Szrj value = sym->value() + os->tls_offset() + secoff;
2894*fae548d3Szrj else
2895*fae548d3Szrj value = sym->value() + os->address() + secoff;
2896*fae548d3Szrj }
2897*fae548d3Szrj }
2898*fae548d3Szrj }
2899*fae548d3Szrj break;
2900*fae548d3Szrj
2901*fae548d3Szrj case Symbol::IN_OUTPUT_DATA:
2902*fae548d3Szrj {
2903*fae548d3Szrj Output_data* od = sym->output_data();
2904*fae548d3Szrj value = sym->value();
2905*fae548d3Szrj if (sym->type() != elfcpp::STT_TLS)
2906*fae548d3Szrj value += od->address();
2907*fae548d3Szrj else
2908*fae548d3Szrj {
2909*fae548d3Szrj Output_section* os = od->output_section();
2910*fae548d3Szrj gold_assert(os != NULL);
2911*fae548d3Szrj value += os->tls_offset() + (od->address() - os->address());
2912*fae548d3Szrj }
2913*fae548d3Szrj if (sym->offset_is_from_end())
2914*fae548d3Szrj value += od->data_size();
2915*fae548d3Szrj }
2916*fae548d3Szrj break;
2917*fae548d3Szrj
2918*fae548d3Szrj case Symbol::IN_OUTPUT_SEGMENT:
2919*fae548d3Szrj {
2920*fae548d3Szrj Output_segment* os = sym->output_segment();
2921*fae548d3Szrj value = sym->value();
2922*fae548d3Szrj if (sym->type() != elfcpp::STT_TLS)
2923*fae548d3Szrj value += os->vaddr();
2924*fae548d3Szrj switch (sym->offset_base())
2925*fae548d3Szrj {
2926*fae548d3Szrj case Symbol::SEGMENT_START:
2927*fae548d3Szrj break;
2928*fae548d3Szrj case Symbol::SEGMENT_END:
2929*fae548d3Szrj value += os->memsz();
2930*fae548d3Szrj break;
2931*fae548d3Szrj case Symbol::SEGMENT_BSS:
2932*fae548d3Szrj value += os->filesz();
2933*fae548d3Szrj break;
2934*fae548d3Szrj default:
2935*fae548d3Szrj gold_unreachable();
2936*fae548d3Szrj }
2937*fae548d3Szrj }
2938*fae548d3Szrj break;
2939*fae548d3Szrj
2940*fae548d3Szrj case Symbol::IS_CONSTANT:
2941*fae548d3Szrj value = sym->value();
2942*fae548d3Szrj break;
2943*fae548d3Szrj
2944*fae548d3Szrj case Symbol::IS_UNDEFINED:
2945*fae548d3Szrj value = 0;
2946*fae548d3Szrj break;
2947*fae548d3Szrj
2948*fae548d3Szrj default:
2949*fae548d3Szrj gold_unreachable();
2950*fae548d3Szrj }
2951*fae548d3Szrj
2952*fae548d3Szrj *pstatus = CFVS_OK;
2953*fae548d3Szrj return value;
2954*fae548d3Szrj }
2955*fae548d3Szrj
2956*fae548d3Szrj // Finalize the symbol SYM. This returns true if the symbol should be
2957*fae548d3Szrj // added to the symbol table, false otherwise.
2958*fae548d3Szrj
2959*fae548d3Szrj template<int size>
2960*fae548d3Szrj bool
sized_finalize_symbol(Symbol * unsized_sym)2961*fae548d3Szrj Symbol_table::sized_finalize_symbol(Symbol* unsized_sym)
2962*fae548d3Szrj {
2963*fae548d3Szrj typedef typename Sized_symbol<size>::Value_type Value_type;
2964*fae548d3Szrj
2965*fae548d3Szrj Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(unsized_sym);
2966*fae548d3Szrj
2967*fae548d3Szrj // The default version of a symbol may appear twice in the symbol
2968*fae548d3Szrj // table. We only need to finalize it once.
2969*fae548d3Szrj if (sym->has_symtab_index())
2970*fae548d3Szrj return false;
2971*fae548d3Szrj
2972*fae548d3Szrj if (!sym->in_reg())
2973*fae548d3Szrj {
2974*fae548d3Szrj gold_assert(!sym->has_symtab_index());
2975*fae548d3Szrj sym->set_symtab_index(-1U);
2976*fae548d3Szrj gold_assert(sym->dynsym_index() == -1U);
2977*fae548d3Szrj return false;
2978*fae548d3Szrj }
2979*fae548d3Szrj
2980*fae548d3Szrj // If the symbol is only present on plugin files, the plugin decided we
2981*fae548d3Szrj // don't need it.
2982*fae548d3Szrj if (!sym->in_real_elf())
2983*fae548d3Szrj {
2984*fae548d3Szrj gold_assert(!sym->has_symtab_index());
2985*fae548d3Szrj sym->set_symtab_index(-1U);
2986*fae548d3Szrj return false;
2987*fae548d3Szrj }
2988*fae548d3Szrj
2989*fae548d3Szrj // Compute final symbol value.
2990*fae548d3Szrj Compute_final_value_status status;
2991*fae548d3Szrj Value_type value = this->compute_final_value(sym, &status);
2992*fae548d3Szrj
2993*fae548d3Szrj switch (status)
2994*fae548d3Szrj {
2995*fae548d3Szrj case CFVS_OK:
2996*fae548d3Szrj break;
2997*fae548d3Szrj case CFVS_UNSUPPORTED_SYMBOL_SECTION:
2998*fae548d3Szrj {
2999*fae548d3Szrj bool is_ordinary;
3000*fae548d3Szrj unsigned int shndx = sym->shndx(&is_ordinary);
3001*fae548d3Szrj gold_error(_("%s: unsupported symbol section 0x%x"),
3002*fae548d3Szrj sym->demangled_name().c_str(), shndx);
3003*fae548d3Szrj }
3004*fae548d3Szrj break;
3005*fae548d3Szrj case CFVS_NO_OUTPUT_SECTION:
3006*fae548d3Szrj sym->set_symtab_index(-1U);
3007*fae548d3Szrj return false;
3008*fae548d3Szrj default:
3009*fae548d3Szrj gold_unreachable();
3010*fae548d3Szrj }
3011*fae548d3Szrj
3012*fae548d3Szrj sym->set_value(value);
3013*fae548d3Szrj
3014*fae548d3Szrj if (parameters->options().strip_all()
3015*fae548d3Szrj || !parameters->options().should_retain_symbol(sym->name()))
3016*fae548d3Szrj {
3017*fae548d3Szrj sym->set_symtab_index(-1U);
3018*fae548d3Szrj return false;
3019*fae548d3Szrj }
3020*fae548d3Szrj
3021*fae548d3Szrj return true;
3022*fae548d3Szrj }
3023*fae548d3Szrj
3024*fae548d3Szrj // Write out the global symbols.
3025*fae548d3Szrj
3026*fae548d3Szrj void
write_globals(const Stringpool * sympool,const Stringpool * dynpool,Output_symtab_xindex * symtab_xindex,Output_symtab_xindex * dynsym_xindex,Output_file * of) const3027*fae548d3Szrj Symbol_table::write_globals(const Stringpool* sympool,
3028*fae548d3Szrj const Stringpool* dynpool,
3029*fae548d3Szrj Output_symtab_xindex* symtab_xindex,
3030*fae548d3Szrj Output_symtab_xindex* dynsym_xindex,
3031*fae548d3Szrj Output_file* of) const
3032*fae548d3Szrj {
3033*fae548d3Szrj switch (parameters->size_and_endianness())
3034*fae548d3Szrj {
3035*fae548d3Szrj #ifdef HAVE_TARGET_32_LITTLE
3036*fae548d3Szrj case Parameters::TARGET_32_LITTLE:
3037*fae548d3Szrj this->sized_write_globals<32, false>(sympool, dynpool, symtab_xindex,
3038*fae548d3Szrj dynsym_xindex, of);
3039*fae548d3Szrj break;
3040*fae548d3Szrj #endif
3041*fae548d3Szrj #ifdef HAVE_TARGET_32_BIG
3042*fae548d3Szrj case Parameters::TARGET_32_BIG:
3043*fae548d3Szrj this->sized_write_globals<32, true>(sympool, dynpool, symtab_xindex,
3044*fae548d3Szrj dynsym_xindex, of);
3045*fae548d3Szrj break;
3046*fae548d3Szrj #endif
3047*fae548d3Szrj #ifdef HAVE_TARGET_64_LITTLE
3048*fae548d3Szrj case Parameters::TARGET_64_LITTLE:
3049*fae548d3Szrj this->sized_write_globals<64, false>(sympool, dynpool, symtab_xindex,
3050*fae548d3Szrj dynsym_xindex, of);
3051*fae548d3Szrj break;
3052*fae548d3Szrj #endif
3053*fae548d3Szrj #ifdef HAVE_TARGET_64_BIG
3054*fae548d3Szrj case Parameters::TARGET_64_BIG:
3055*fae548d3Szrj this->sized_write_globals<64, true>(sympool, dynpool, symtab_xindex,
3056*fae548d3Szrj dynsym_xindex, of);
3057*fae548d3Szrj break;
3058*fae548d3Szrj #endif
3059*fae548d3Szrj default:
3060*fae548d3Szrj gold_unreachable();
3061*fae548d3Szrj }
3062*fae548d3Szrj }
3063*fae548d3Szrj
3064*fae548d3Szrj // Write out the global symbols.
3065*fae548d3Szrj
3066*fae548d3Szrj template<int size, bool big_endian>
3067*fae548d3Szrj void
sized_write_globals(const Stringpool * sympool,const Stringpool * dynpool,Output_symtab_xindex * symtab_xindex,Output_symtab_xindex * dynsym_xindex,Output_file * of) const3068*fae548d3Szrj Symbol_table::sized_write_globals(const Stringpool* sympool,
3069*fae548d3Szrj const Stringpool* dynpool,
3070*fae548d3Szrj Output_symtab_xindex* symtab_xindex,
3071*fae548d3Szrj Output_symtab_xindex* dynsym_xindex,
3072*fae548d3Szrj Output_file* of) const
3073*fae548d3Szrj {
3074*fae548d3Szrj const Target& target = parameters->target();
3075*fae548d3Szrj
3076*fae548d3Szrj const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
3077*fae548d3Szrj
3078*fae548d3Szrj const unsigned int output_count = this->output_count_;
3079*fae548d3Szrj const section_size_type oview_size = output_count * sym_size;
3080*fae548d3Szrj const unsigned int first_global_index = this->first_global_index_;
3081*fae548d3Szrj unsigned char* psyms;
3082*fae548d3Szrj if (this->offset_ == 0 || output_count == 0)
3083*fae548d3Szrj psyms = NULL;
3084*fae548d3Szrj else
3085*fae548d3Szrj psyms = of->get_output_view(this->offset_, oview_size);
3086*fae548d3Szrj
3087*fae548d3Szrj const unsigned int dynamic_count = this->dynamic_count_;
3088*fae548d3Szrj const section_size_type dynamic_size = dynamic_count * sym_size;
3089*fae548d3Szrj const unsigned int first_dynamic_global_index =
3090*fae548d3Szrj this->first_dynamic_global_index_;
3091*fae548d3Szrj unsigned char* dynamic_view;
3092*fae548d3Szrj if (this->dynamic_offset_ == 0 || dynamic_count == 0)
3093*fae548d3Szrj dynamic_view = NULL;
3094*fae548d3Szrj else
3095*fae548d3Szrj dynamic_view = of->get_output_view(this->dynamic_offset_, dynamic_size);
3096*fae548d3Szrj
3097*fae548d3Szrj for (Symbol_table_type::const_iterator p = this->table_.begin();
3098*fae548d3Szrj p != this->table_.end();
3099*fae548d3Szrj ++p)
3100*fae548d3Szrj {
3101*fae548d3Szrj Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
3102*fae548d3Szrj
3103*fae548d3Szrj // Possibly warn about unresolved symbols in shared libraries.
3104*fae548d3Szrj this->warn_about_undefined_dynobj_symbol(sym);
3105*fae548d3Szrj
3106*fae548d3Szrj unsigned int sym_index = sym->symtab_index();
3107*fae548d3Szrj unsigned int dynsym_index;
3108*fae548d3Szrj if (dynamic_view == NULL)
3109*fae548d3Szrj dynsym_index = -1U;
3110*fae548d3Szrj else
3111*fae548d3Szrj dynsym_index = sym->dynsym_index();
3112*fae548d3Szrj
3113*fae548d3Szrj if (sym_index == -1U && dynsym_index == -1U)
3114*fae548d3Szrj {
3115*fae548d3Szrj // This symbol is not included in the output file.
3116*fae548d3Szrj continue;
3117*fae548d3Szrj }
3118*fae548d3Szrj
3119*fae548d3Szrj unsigned int shndx;
3120*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_Addr sym_value = sym->value();
3121*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_Addr dynsym_value = sym_value;
3122*fae548d3Szrj elfcpp::STB binding = sym->binding();
3123*fae548d3Szrj
3124*fae548d3Szrj // If --weak-unresolved-symbols is set, change binding of unresolved
3125*fae548d3Szrj // global symbols to STB_WEAK.
3126*fae548d3Szrj if (parameters->options().weak_unresolved_symbols()
3127*fae548d3Szrj && binding == elfcpp::STB_GLOBAL
3128*fae548d3Szrj && sym->is_undefined())
3129*fae548d3Szrj binding = elfcpp::STB_WEAK;
3130*fae548d3Szrj
3131*fae548d3Szrj // If --no-gnu-unique is set, change STB_GNU_UNIQUE to STB_GLOBAL.
3132*fae548d3Szrj if (binding == elfcpp::STB_GNU_UNIQUE
3133*fae548d3Szrj && !parameters->options().gnu_unique())
3134*fae548d3Szrj binding = elfcpp::STB_GLOBAL;
3135*fae548d3Szrj
3136*fae548d3Szrj switch (sym->source())
3137*fae548d3Szrj {
3138*fae548d3Szrj case Symbol::FROM_OBJECT:
3139*fae548d3Szrj {
3140*fae548d3Szrj bool is_ordinary;
3141*fae548d3Szrj unsigned int in_shndx = sym->shndx(&is_ordinary);
3142*fae548d3Szrj
3143*fae548d3Szrj if (!is_ordinary
3144*fae548d3Szrj && in_shndx != elfcpp::SHN_ABS
3145*fae548d3Szrj && !Symbol::is_common_shndx(in_shndx))
3146*fae548d3Szrj {
3147*fae548d3Szrj gold_error(_("%s: unsupported symbol section 0x%x"),
3148*fae548d3Szrj sym->demangled_name().c_str(), in_shndx);
3149*fae548d3Szrj shndx = in_shndx;
3150*fae548d3Szrj }
3151*fae548d3Szrj else
3152*fae548d3Szrj {
3153*fae548d3Szrj Object* symobj = sym->object();
3154*fae548d3Szrj if (symobj->is_dynamic())
3155*fae548d3Szrj {
3156*fae548d3Szrj if (sym->needs_dynsym_value())
3157*fae548d3Szrj dynsym_value = target.dynsym_value(sym);
3158*fae548d3Szrj shndx = elfcpp::SHN_UNDEF;
3159*fae548d3Szrj if (sym->is_undef_binding_weak())
3160*fae548d3Szrj binding = elfcpp::STB_WEAK;
3161*fae548d3Szrj else
3162*fae548d3Szrj binding = elfcpp::STB_GLOBAL;
3163*fae548d3Szrj }
3164*fae548d3Szrj else if (symobj->pluginobj() != NULL)
3165*fae548d3Szrj shndx = elfcpp::SHN_UNDEF;
3166*fae548d3Szrj else if (in_shndx == elfcpp::SHN_UNDEF
3167*fae548d3Szrj || (!is_ordinary
3168*fae548d3Szrj && (in_shndx == elfcpp::SHN_ABS
3169*fae548d3Szrj || Symbol::is_common_shndx(in_shndx))))
3170*fae548d3Szrj shndx = in_shndx;
3171*fae548d3Szrj else
3172*fae548d3Szrj {
3173*fae548d3Szrj Relobj* relobj = static_cast<Relobj*>(symobj);
3174*fae548d3Szrj Output_section* os = relobj->output_section(in_shndx);
3175*fae548d3Szrj if (this->is_section_folded(relobj, in_shndx))
3176*fae548d3Szrj {
3177*fae548d3Szrj // This global symbol must be written out even though
3178*fae548d3Szrj // it is folded.
3179*fae548d3Szrj // Get the os of the section it is folded onto.
3180*fae548d3Szrj Section_id folded =
3181*fae548d3Szrj this->icf_->get_folded_section(relobj, in_shndx);
3182*fae548d3Szrj gold_assert(folded.first !=NULL);
3183*fae548d3Szrj Relobj* folded_obj =
3184*fae548d3Szrj reinterpret_cast<Relobj*>(folded.first);
3185*fae548d3Szrj os = folded_obj->output_section(folded.second);
3186*fae548d3Szrj gold_assert(os != NULL);
3187*fae548d3Szrj }
3188*fae548d3Szrj gold_assert(os != NULL);
3189*fae548d3Szrj shndx = os->out_shndx();
3190*fae548d3Szrj
3191*fae548d3Szrj if (shndx >= elfcpp::SHN_LORESERVE)
3192*fae548d3Szrj {
3193*fae548d3Szrj if (sym_index != -1U)
3194*fae548d3Szrj symtab_xindex->add(sym_index, shndx);
3195*fae548d3Szrj if (dynsym_index != -1U)
3196*fae548d3Szrj dynsym_xindex->add(dynsym_index, shndx);
3197*fae548d3Szrj shndx = elfcpp::SHN_XINDEX;
3198*fae548d3Szrj }
3199*fae548d3Szrj
3200*fae548d3Szrj // In object files symbol values are section
3201*fae548d3Szrj // relative.
3202*fae548d3Szrj if (parameters->options().relocatable())
3203*fae548d3Szrj sym_value -= os->address();
3204*fae548d3Szrj }
3205*fae548d3Szrj }
3206*fae548d3Szrj }
3207*fae548d3Szrj break;
3208*fae548d3Szrj
3209*fae548d3Szrj case Symbol::IN_OUTPUT_DATA:
3210*fae548d3Szrj {
3211*fae548d3Szrj Output_data* od = sym->output_data();
3212*fae548d3Szrj
3213*fae548d3Szrj shndx = od->out_shndx();
3214*fae548d3Szrj if (shndx >= elfcpp::SHN_LORESERVE)
3215*fae548d3Szrj {
3216*fae548d3Szrj if (sym_index != -1U)
3217*fae548d3Szrj symtab_xindex->add(sym_index, shndx);
3218*fae548d3Szrj if (dynsym_index != -1U)
3219*fae548d3Szrj dynsym_xindex->add(dynsym_index, shndx);
3220*fae548d3Szrj shndx = elfcpp::SHN_XINDEX;
3221*fae548d3Szrj }
3222*fae548d3Szrj
3223*fae548d3Szrj // In object files symbol values are section
3224*fae548d3Szrj // relative.
3225*fae548d3Szrj if (parameters->options().relocatable())
3226*fae548d3Szrj {
3227*fae548d3Szrj Output_section* os = od->output_section();
3228*fae548d3Szrj gold_assert(os != NULL);
3229*fae548d3Szrj sym_value -= os->address();
3230*fae548d3Szrj }
3231*fae548d3Szrj }
3232*fae548d3Szrj break;
3233*fae548d3Szrj
3234*fae548d3Szrj case Symbol::IN_OUTPUT_SEGMENT:
3235*fae548d3Szrj {
3236*fae548d3Szrj Output_segment* oseg = sym->output_segment();
3237*fae548d3Szrj Output_section* osect = oseg->first_section();
3238*fae548d3Szrj if (osect == NULL)
3239*fae548d3Szrj shndx = elfcpp::SHN_ABS;
3240*fae548d3Szrj else
3241*fae548d3Szrj shndx = osect->out_shndx();
3242*fae548d3Szrj }
3243*fae548d3Szrj break;
3244*fae548d3Szrj
3245*fae548d3Szrj case Symbol::IS_CONSTANT:
3246*fae548d3Szrj shndx = elfcpp::SHN_ABS;
3247*fae548d3Szrj break;
3248*fae548d3Szrj
3249*fae548d3Szrj case Symbol::IS_UNDEFINED:
3250*fae548d3Szrj shndx = elfcpp::SHN_UNDEF;
3251*fae548d3Szrj break;
3252*fae548d3Szrj
3253*fae548d3Szrj default:
3254*fae548d3Szrj gold_unreachable();
3255*fae548d3Szrj }
3256*fae548d3Szrj
3257*fae548d3Szrj if (sym_index != -1U)
3258*fae548d3Szrj {
3259*fae548d3Szrj sym_index -= first_global_index;
3260*fae548d3Szrj gold_assert(sym_index < output_count);
3261*fae548d3Szrj unsigned char* ps = psyms + (sym_index * sym_size);
3262*fae548d3Szrj this->sized_write_symbol<size, big_endian>(sym, sym_value, shndx,
3263*fae548d3Szrj binding, sympool, ps);
3264*fae548d3Szrj }
3265*fae548d3Szrj
3266*fae548d3Szrj if (dynsym_index != -1U)
3267*fae548d3Szrj {
3268*fae548d3Szrj dynsym_index -= first_dynamic_global_index;
3269*fae548d3Szrj gold_assert(dynsym_index < dynamic_count);
3270*fae548d3Szrj unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
3271*fae548d3Szrj this->sized_write_symbol<size, big_endian>(sym, dynsym_value, shndx,
3272*fae548d3Szrj binding, dynpool, pd);
3273*fae548d3Szrj // Allow a target to adjust dynamic symbol value.
3274*fae548d3Szrj parameters->target().adjust_dyn_symbol(sym, pd);
3275*fae548d3Szrj }
3276*fae548d3Szrj }
3277*fae548d3Szrj
3278*fae548d3Szrj // Write the target-specific symbols.
3279*fae548d3Szrj for (std::vector<Symbol*>::const_iterator p = this->target_symbols_.begin();
3280*fae548d3Szrj p != this->target_symbols_.end();
3281*fae548d3Szrj ++p)
3282*fae548d3Szrj {
3283*fae548d3Szrj Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(*p);
3284*fae548d3Szrj
3285*fae548d3Szrj unsigned int sym_index = sym->symtab_index();
3286*fae548d3Szrj unsigned int dynsym_index;
3287*fae548d3Szrj if (dynamic_view == NULL)
3288*fae548d3Szrj dynsym_index = -1U;
3289*fae548d3Szrj else
3290*fae548d3Szrj dynsym_index = sym->dynsym_index();
3291*fae548d3Szrj
3292*fae548d3Szrj unsigned int shndx;
3293*fae548d3Szrj switch (sym->source())
3294*fae548d3Szrj {
3295*fae548d3Szrj case Symbol::IS_CONSTANT:
3296*fae548d3Szrj shndx = elfcpp::SHN_ABS;
3297*fae548d3Szrj break;
3298*fae548d3Szrj case Symbol::IS_UNDEFINED:
3299*fae548d3Szrj shndx = elfcpp::SHN_UNDEF;
3300*fae548d3Szrj break;
3301*fae548d3Szrj default:
3302*fae548d3Szrj gold_unreachable();
3303*fae548d3Szrj }
3304*fae548d3Szrj
3305*fae548d3Szrj if (sym_index != -1U)
3306*fae548d3Szrj {
3307*fae548d3Szrj sym_index -= first_global_index;
3308*fae548d3Szrj gold_assert(sym_index < output_count);
3309*fae548d3Szrj unsigned char* ps = psyms + (sym_index * sym_size);
3310*fae548d3Szrj this->sized_write_symbol<size, big_endian>(sym, sym->value(), shndx,
3311*fae548d3Szrj sym->binding(), sympool,
3312*fae548d3Szrj ps);
3313*fae548d3Szrj }
3314*fae548d3Szrj
3315*fae548d3Szrj if (dynsym_index != -1U)
3316*fae548d3Szrj {
3317*fae548d3Szrj dynsym_index -= first_dynamic_global_index;
3318*fae548d3Szrj gold_assert(dynsym_index < dynamic_count);
3319*fae548d3Szrj unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
3320*fae548d3Szrj this->sized_write_symbol<size, big_endian>(sym, sym->value(), shndx,
3321*fae548d3Szrj sym->binding(), dynpool,
3322*fae548d3Szrj pd);
3323*fae548d3Szrj }
3324*fae548d3Szrj }
3325*fae548d3Szrj
3326*fae548d3Szrj of->write_output_view(this->offset_, oview_size, psyms);
3327*fae548d3Szrj if (dynamic_view != NULL)
3328*fae548d3Szrj of->write_output_view(this->dynamic_offset_, dynamic_size, dynamic_view);
3329*fae548d3Szrj }
3330*fae548d3Szrj
3331*fae548d3Szrj // Write out the symbol SYM, in section SHNDX, to P. POOL is the
3332*fae548d3Szrj // strtab holding the name.
3333*fae548d3Szrj
3334*fae548d3Szrj template<int size, bool big_endian>
3335*fae548d3Szrj void
sized_write_symbol(Sized_symbol<size> * sym,typename elfcpp::Elf_types<size>::Elf_Addr value,unsigned int shndx,elfcpp::STB binding,const Stringpool * pool,unsigned char * p) const3336*fae548d3Szrj Symbol_table::sized_write_symbol(
3337*fae548d3Szrj Sized_symbol<size>* sym,
3338*fae548d3Szrj typename elfcpp::Elf_types<size>::Elf_Addr value,
3339*fae548d3Szrj unsigned int shndx,
3340*fae548d3Szrj elfcpp::STB binding,
3341*fae548d3Szrj const Stringpool* pool,
3342*fae548d3Szrj unsigned char* p) const
3343*fae548d3Szrj {
3344*fae548d3Szrj elfcpp::Sym_write<size, big_endian> osym(p);
3345*fae548d3Szrj if (sym->version() == NULL || !parameters->options().relocatable())
3346*fae548d3Szrj osym.put_st_name(pool->get_offset(sym->name()));
3347*fae548d3Szrj else
3348*fae548d3Szrj osym.put_st_name(pool->get_offset(sym->versioned_name()));
3349*fae548d3Szrj osym.put_st_value(value);
3350*fae548d3Szrj // Use a symbol size of zero for undefined symbols from shared libraries.
3351*fae548d3Szrj if (shndx == elfcpp::SHN_UNDEF && sym->is_from_dynobj())
3352*fae548d3Szrj osym.put_st_size(0);
3353*fae548d3Szrj else
3354*fae548d3Szrj osym.put_st_size(sym->symsize());
3355*fae548d3Szrj elfcpp::STT type = sym->type();
3356*fae548d3Szrj gold_assert(type != elfcpp::STT_GNU_IFUNC || !sym->is_from_dynobj());
3357*fae548d3Szrj // A version script may have overridden the default binding.
3358*fae548d3Szrj if (sym->is_forced_local())
3359*fae548d3Szrj osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL, type));
3360*fae548d3Szrj else
3361*fae548d3Szrj osym.put_st_info(elfcpp::elf_st_info(binding, type));
3362*fae548d3Szrj osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis()));
3363*fae548d3Szrj osym.put_st_shndx(shndx);
3364*fae548d3Szrj }
3365*fae548d3Szrj
3366*fae548d3Szrj // Check for unresolved symbols in shared libraries. This is
3367*fae548d3Szrj // controlled by the --allow-shlib-undefined option.
3368*fae548d3Szrj
3369*fae548d3Szrj // We only warn about libraries for which we have seen all the
3370*fae548d3Szrj // DT_NEEDED entries. We don't try to track down DT_NEEDED entries
3371*fae548d3Szrj // which were not seen in this link. If we didn't see a DT_NEEDED
3372*fae548d3Szrj // entry, we aren't going to be able to reliably report whether the
3373*fae548d3Szrj // symbol is undefined.
3374*fae548d3Szrj
3375*fae548d3Szrj // We also don't warn about libraries found in a system library
3376*fae548d3Szrj // directory (e.g., /lib or /usr/lib); we assume that those libraries
3377*fae548d3Szrj // are OK. This heuristic avoids problems on GNU/Linux, in which -ldl
3378*fae548d3Szrj // can have undefined references satisfied by ld-linux.so.
3379*fae548d3Szrj
3380*fae548d3Szrj inline void
warn_about_undefined_dynobj_symbol(Symbol * sym) const3381*fae548d3Szrj Symbol_table::warn_about_undefined_dynobj_symbol(Symbol* sym) const
3382*fae548d3Szrj {
3383*fae548d3Szrj bool dummy;
3384*fae548d3Szrj if (sym->source() == Symbol::FROM_OBJECT
3385*fae548d3Szrj && sym->object()->is_dynamic()
3386*fae548d3Szrj && sym->shndx(&dummy) == elfcpp::SHN_UNDEF
3387*fae548d3Szrj && sym->binding() != elfcpp::STB_WEAK
3388*fae548d3Szrj && !parameters->options().allow_shlib_undefined()
3389*fae548d3Szrj && !parameters->target().is_defined_by_abi(sym)
3390*fae548d3Szrj && !sym->object()->is_in_system_directory())
3391*fae548d3Szrj {
3392*fae548d3Szrj // A very ugly cast.
3393*fae548d3Szrj Dynobj* dynobj = static_cast<Dynobj*>(sym->object());
3394*fae548d3Szrj if (!dynobj->has_unknown_needed_entries())
3395*fae548d3Szrj gold_undefined_symbol(sym);
3396*fae548d3Szrj }
3397*fae548d3Szrj }
3398*fae548d3Szrj
3399*fae548d3Szrj // Write out a section symbol. Return the update offset.
3400*fae548d3Szrj
3401*fae548d3Szrj void
write_section_symbol(const Output_section * os,Output_symtab_xindex * symtab_xindex,Output_file * of,off_t offset) const3402*fae548d3Szrj Symbol_table::write_section_symbol(const Output_section* os,
3403*fae548d3Szrj Output_symtab_xindex* symtab_xindex,
3404*fae548d3Szrj Output_file* of,
3405*fae548d3Szrj off_t offset) const
3406*fae548d3Szrj {
3407*fae548d3Szrj switch (parameters->size_and_endianness())
3408*fae548d3Szrj {
3409*fae548d3Szrj #ifdef HAVE_TARGET_32_LITTLE
3410*fae548d3Szrj case Parameters::TARGET_32_LITTLE:
3411*fae548d3Szrj this->sized_write_section_symbol<32, false>(os, symtab_xindex, of,
3412*fae548d3Szrj offset);
3413*fae548d3Szrj break;
3414*fae548d3Szrj #endif
3415*fae548d3Szrj #ifdef HAVE_TARGET_32_BIG
3416*fae548d3Szrj case Parameters::TARGET_32_BIG:
3417*fae548d3Szrj this->sized_write_section_symbol<32, true>(os, symtab_xindex, of,
3418*fae548d3Szrj offset);
3419*fae548d3Szrj break;
3420*fae548d3Szrj #endif
3421*fae548d3Szrj #ifdef HAVE_TARGET_64_LITTLE
3422*fae548d3Szrj case Parameters::TARGET_64_LITTLE:
3423*fae548d3Szrj this->sized_write_section_symbol<64, false>(os, symtab_xindex, of,
3424*fae548d3Szrj offset);
3425*fae548d3Szrj break;
3426*fae548d3Szrj #endif
3427*fae548d3Szrj #ifdef HAVE_TARGET_64_BIG
3428*fae548d3Szrj case Parameters::TARGET_64_BIG:
3429*fae548d3Szrj this->sized_write_section_symbol<64, true>(os, symtab_xindex, of,
3430*fae548d3Szrj offset);
3431*fae548d3Szrj break;
3432*fae548d3Szrj #endif
3433*fae548d3Szrj default:
3434*fae548d3Szrj gold_unreachable();
3435*fae548d3Szrj }
3436*fae548d3Szrj }
3437*fae548d3Szrj
3438*fae548d3Szrj // Write out a section symbol, specialized for size and endianness.
3439*fae548d3Szrj
3440*fae548d3Szrj template<int size, bool big_endian>
3441*fae548d3Szrj void
sized_write_section_symbol(const Output_section * os,Output_symtab_xindex * symtab_xindex,Output_file * of,off_t offset) const3442*fae548d3Szrj Symbol_table::sized_write_section_symbol(const Output_section* os,
3443*fae548d3Szrj Output_symtab_xindex* symtab_xindex,
3444*fae548d3Szrj Output_file* of,
3445*fae548d3Szrj off_t offset) const
3446*fae548d3Szrj {
3447*fae548d3Szrj const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
3448*fae548d3Szrj
3449*fae548d3Szrj unsigned char* pov = of->get_output_view(offset, sym_size);
3450*fae548d3Szrj
3451*fae548d3Szrj elfcpp::Sym_write<size, big_endian> osym(pov);
3452*fae548d3Szrj osym.put_st_name(0);
3453*fae548d3Szrj if (parameters->options().relocatable())
3454*fae548d3Szrj osym.put_st_value(0);
3455*fae548d3Szrj else
3456*fae548d3Szrj osym.put_st_value(os->address());
3457*fae548d3Szrj osym.put_st_size(0);
3458*fae548d3Szrj osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL,
3459*fae548d3Szrj elfcpp::STT_SECTION));
3460*fae548d3Szrj osym.put_st_other(elfcpp::elf_st_other(elfcpp::STV_DEFAULT, 0));
3461*fae548d3Szrj
3462*fae548d3Szrj unsigned int shndx = os->out_shndx();
3463*fae548d3Szrj if (shndx >= elfcpp::SHN_LORESERVE)
3464*fae548d3Szrj {
3465*fae548d3Szrj symtab_xindex->add(os->symtab_index(), shndx);
3466*fae548d3Szrj shndx = elfcpp::SHN_XINDEX;
3467*fae548d3Szrj }
3468*fae548d3Szrj osym.put_st_shndx(shndx);
3469*fae548d3Szrj
3470*fae548d3Szrj of->write_output_view(offset, sym_size, pov);
3471*fae548d3Szrj }
3472*fae548d3Szrj
3473*fae548d3Szrj // Print statistical information to stderr. This is used for --stats.
3474*fae548d3Szrj
3475*fae548d3Szrj void
print_stats() const3476*fae548d3Szrj Symbol_table::print_stats() const
3477*fae548d3Szrj {
3478*fae548d3Szrj #if defined(HAVE_TR1_UNORDERED_MAP) || defined(HAVE_EXT_HASH_MAP)
3479*fae548d3Szrj fprintf(stderr, _("%s: symbol table entries: %zu; buckets: %zu\n"),
3480*fae548d3Szrj program_name, this->table_.size(), this->table_.bucket_count());
3481*fae548d3Szrj #else
3482*fae548d3Szrj fprintf(stderr, _("%s: symbol table entries: %zu\n"),
3483*fae548d3Szrj program_name, this->table_.size());
3484*fae548d3Szrj #endif
3485*fae548d3Szrj this->namepool_.print_stats("symbol table stringpool");
3486*fae548d3Szrj }
3487*fae548d3Szrj
3488*fae548d3Szrj // We check for ODR violations by looking for symbols with the same
3489*fae548d3Szrj // name for which the debugging information reports that they were
3490*fae548d3Szrj // defined in disjoint source locations. When comparing the source
3491*fae548d3Szrj // location, we consider instances with the same base filename to be
3492*fae548d3Szrj // the same. This is because different object files/shared libraries
3493*fae548d3Szrj // can include the same header file using different paths, and
3494*fae548d3Szrj // different optimization settings can make the line number appear to
3495*fae548d3Szrj // be a couple lines off, and we don't want to report an ODR violation
3496*fae548d3Szrj // in those cases.
3497*fae548d3Szrj
3498*fae548d3Szrj // This struct is used to compare line information, as returned by
3499*fae548d3Szrj // Dwarf_line_info::one_addr2line. It implements a < comparison
3500*fae548d3Szrj // operator used with std::sort.
3501*fae548d3Szrj
3502*fae548d3Szrj struct Odr_violation_compare
3503*fae548d3Szrj {
3504*fae548d3Szrj bool
operator ()gold::Odr_violation_compare3505*fae548d3Szrj operator()(const std::string& s1, const std::string& s2) const
3506*fae548d3Szrj {
3507*fae548d3Szrj // Inputs should be of the form "dirname/filename:linenum" where
3508*fae548d3Szrj // "dirname/" is optional. We want to compare just the filename:linenum.
3509*fae548d3Szrj
3510*fae548d3Szrj // Find the last '/' in each string.
3511*fae548d3Szrj std::string::size_type s1begin = s1.rfind('/');
3512*fae548d3Szrj std::string::size_type s2begin = s2.rfind('/');
3513*fae548d3Szrj // If there was no '/' in a string, start at the beginning.
3514*fae548d3Szrj if (s1begin == std::string::npos)
3515*fae548d3Szrj s1begin = 0;
3516*fae548d3Szrj if (s2begin == std::string::npos)
3517*fae548d3Szrj s2begin = 0;
3518*fae548d3Szrj return s1.compare(s1begin, std::string::npos,
3519*fae548d3Szrj s2, s2begin, std::string::npos) < 0;
3520*fae548d3Szrj }
3521*fae548d3Szrj };
3522*fae548d3Szrj
3523*fae548d3Szrj // Returns all of the lines attached to LOC, not just the one the
3524*fae548d3Szrj // instruction actually came from.
3525*fae548d3Szrj std::vector<std::string>
linenos_from_loc(const Task * task,const Symbol_location & loc)3526*fae548d3Szrj Symbol_table::linenos_from_loc(const Task* task,
3527*fae548d3Szrj const Symbol_location& loc)
3528*fae548d3Szrj {
3529*fae548d3Szrj // We need to lock the object in order to read it. This
3530*fae548d3Szrj // means that we have to run in a singleton Task. If we
3531*fae548d3Szrj // want to run this in a general Task for better
3532*fae548d3Szrj // performance, we will need one Task for object, plus
3533*fae548d3Szrj // appropriate locking to ensure that we don't conflict with
3534*fae548d3Szrj // other uses of the object. Also note, one_addr2line is not
3535*fae548d3Szrj // currently thread-safe.
3536*fae548d3Szrj Task_lock_obj<Object> tl(task, loc.object);
3537*fae548d3Szrj
3538*fae548d3Szrj std::vector<std::string> result;
3539*fae548d3Szrj Symbol_location code_loc = loc;
3540*fae548d3Szrj parameters->target().function_location(&code_loc);
3541*fae548d3Szrj // 16 is the size of the object-cache that one_addr2line should use.
3542*fae548d3Szrj std::string canonical_result = Dwarf_line_info::one_addr2line(
3543*fae548d3Szrj code_loc.object, code_loc.shndx, code_loc.offset, 16, &result);
3544*fae548d3Szrj if (!canonical_result.empty())
3545*fae548d3Szrj result.push_back(canonical_result);
3546*fae548d3Szrj return result;
3547*fae548d3Szrj }
3548*fae548d3Szrj
3549*fae548d3Szrj // OutputIterator that records if it was ever assigned to. This
3550*fae548d3Szrj // allows it to be used with std::set_intersection() to check for
3551*fae548d3Szrj // intersection rather than computing the intersection.
3552*fae548d3Szrj struct Check_intersection
3553*fae548d3Szrj {
Check_intersectiongold::Check_intersection3554*fae548d3Szrj Check_intersection()
3555*fae548d3Szrj : value_(false)
3556*fae548d3Szrj {}
3557*fae548d3Szrj
had_intersectiongold::Check_intersection3558*fae548d3Szrj bool had_intersection() const
3559*fae548d3Szrj { return this->value_; }
3560*fae548d3Szrj
operator ++gold::Check_intersection3561*fae548d3Szrj Check_intersection& operator++()
3562*fae548d3Szrj { return *this; }
3563*fae548d3Szrj
operator *gold::Check_intersection3564*fae548d3Szrj Check_intersection& operator*()
3565*fae548d3Szrj { return *this; }
3566*fae548d3Szrj
3567*fae548d3Szrj template<typename T>
operator =gold::Check_intersection3568*fae548d3Szrj Check_intersection& operator=(const T&)
3569*fae548d3Szrj {
3570*fae548d3Szrj this->value_ = true;
3571*fae548d3Szrj return *this;
3572*fae548d3Szrj }
3573*fae548d3Szrj
3574*fae548d3Szrj private:
3575*fae548d3Szrj bool value_;
3576*fae548d3Szrj };
3577*fae548d3Szrj
3578*fae548d3Szrj // Check candidate_odr_violations_ to find symbols with the same name
3579*fae548d3Szrj // but apparently different definitions (different source-file/line-no
3580*fae548d3Szrj // for each line assigned to the first instruction).
3581*fae548d3Szrj
3582*fae548d3Szrj void
detect_odr_violations(const Task * task,const char * output_file_name) const3583*fae548d3Szrj Symbol_table::detect_odr_violations(const Task* task,
3584*fae548d3Szrj const char* output_file_name) const
3585*fae548d3Szrj {
3586*fae548d3Szrj for (Odr_map::const_iterator it = candidate_odr_violations_.begin();
3587*fae548d3Szrj it != candidate_odr_violations_.end();
3588*fae548d3Szrj ++it)
3589*fae548d3Szrj {
3590*fae548d3Szrj const char* const symbol_name = it->first;
3591*fae548d3Szrj
3592*fae548d3Szrj std::string first_object_name;
3593*fae548d3Szrj std::vector<std::string> first_object_linenos;
3594*fae548d3Szrj
3595*fae548d3Szrj Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator
3596*fae548d3Szrj locs = it->second.begin();
3597*fae548d3Szrj const Unordered_set<Symbol_location, Symbol_location_hash>::const_iterator
3598*fae548d3Szrj locs_end = it->second.end();
3599*fae548d3Szrj for (; locs != locs_end && first_object_linenos.empty(); ++locs)
3600*fae548d3Szrj {
3601*fae548d3Szrj // Save the line numbers from the first definition to
3602*fae548d3Szrj // compare to the other definitions. Ideally, we'd compare
3603*fae548d3Szrj // every definition to every other, but we don't want to
3604*fae548d3Szrj // take O(N^2) time to do this. This shortcut may cause
3605*fae548d3Szrj // false negatives that appear or disappear depending on the
3606*fae548d3Szrj // link order, but it won't cause false positives.
3607*fae548d3Szrj first_object_name = locs->object->name();
3608*fae548d3Szrj first_object_linenos = this->linenos_from_loc(task, *locs);
3609*fae548d3Szrj }
3610*fae548d3Szrj if (first_object_linenos.empty())
3611*fae548d3Szrj continue;
3612*fae548d3Szrj
3613*fae548d3Szrj // Sort by Odr_violation_compare to make std::set_intersection work.
3614*fae548d3Szrj std::string first_object_canonical_result = first_object_linenos.back();
3615*fae548d3Szrj std::sort(first_object_linenos.begin(), first_object_linenos.end(),
3616*fae548d3Szrj Odr_violation_compare());
3617*fae548d3Szrj
3618*fae548d3Szrj for (; locs != locs_end; ++locs)
3619*fae548d3Szrj {
3620*fae548d3Szrj std::vector<std::string> linenos =
3621*fae548d3Szrj this->linenos_from_loc(task, *locs);
3622*fae548d3Szrj // linenos will be empty if we couldn't parse the debug info.
3623*fae548d3Szrj if (linenos.empty())
3624*fae548d3Szrj continue;
3625*fae548d3Szrj // Sort by Odr_violation_compare to make std::set_intersection work.
3626*fae548d3Szrj gold_assert(!linenos.empty());
3627*fae548d3Szrj std::string second_object_canonical_result = linenos.back();
3628*fae548d3Szrj std::sort(linenos.begin(), linenos.end(), Odr_violation_compare());
3629*fae548d3Szrj
3630*fae548d3Szrj Check_intersection intersection_result =
3631*fae548d3Szrj std::set_intersection(first_object_linenos.begin(),
3632*fae548d3Szrj first_object_linenos.end(),
3633*fae548d3Szrj linenos.begin(),
3634*fae548d3Szrj linenos.end(),
3635*fae548d3Szrj Check_intersection(),
3636*fae548d3Szrj Odr_violation_compare());
3637*fae548d3Szrj if (!intersection_result.had_intersection())
3638*fae548d3Szrj {
3639*fae548d3Szrj gold_warning(_("while linking %s: symbol '%s' defined in "
3640*fae548d3Szrj "multiple places (possible ODR violation):"),
3641*fae548d3Szrj output_file_name, demangle(symbol_name).c_str());
3642*fae548d3Szrj // This only prints one location from each definition,
3643*fae548d3Szrj // which may not be the location we expect to intersect
3644*fae548d3Szrj // with another definition. We could print the whole
3645*fae548d3Szrj // set of locations, but that seems too verbose.
3646*fae548d3Szrj fprintf(stderr, _(" %s from %s\n"),
3647*fae548d3Szrj first_object_canonical_result.c_str(),
3648*fae548d3Szrj first_object_name.c_str());
3649*fae548d3Szrj fprintf(stderr, _(" %s from %s\n"),
3650*fae548d3Szrj second_object_canonical_result.c_str(),
3651*fae548d3Szrj locs->object->name().c_str());
3652*fae548d3Szrj // Only print one broken pair, to avoid needing to
3653*fae548d3Szrj // compare against a list of the disjoint definition
3654*fae548d3Szrj // locations we've found so far. (If we kept comparing
3655*fae548d3Szrj // against just the first one, we'd get a lot of
3656*fae548d3Szrj // redundant complaints about the second definition
3657*fae548d3Szrj // location.)
3658*fae548d3Szrj break;
3659*fae548d3Szrj }
3660*fae548d3Szrj }
3661*fae548d3Szrj }
3662*fae548d3Szrj // We only call one_addr2line() in this function, so we can clear its cache.
3663*fae548d3Szrj Dwarf_line_info::clear_addr2line_cache();
3664*fae548d3Szrj }
3665*fae548d3Szrj
3666*fae548d3Szrj // Warnings functions.
3667*fae548d3Szrj
3668*fae548d3Szrj // Add a new warning.
3669*fae548d3Szrj
3670*fae548d3Szrj void
add_warning(Symbol_table * symtab,const char * name,Object * obj,const std::string & warning)3671*fae548d3Szrj Warnings::add_warning(Symbol_table* symtab, const char* name, Object* obj,
3672*fae548d3Szrj const std::string& warning)
3673*fae548d3Szrj {
3674*fae548d3Szrj name = symtab->canonicalize_name(name);
3675*fae548d3Szrj this->warnings_[name].set(obj, warning);
3676*fae548d3Szrj }
3677*fae548d3Szrj
3678*fae548d3Szrj // Look through the warnings and mark the symbols for which we should
3679*fae548d3Szrj // warn. This is called during Layout::finalize when we know the
3680*fae548d3Szrj // sources for all the symbols.
3681*fae548d3Szrj
3682*fae548d3Szrj void
note_warnings(Symbol_table * symtab)3683*fae548d3Szrj Warnings::note_warnings(Symbol_table* symtab)
3684*fae548d3Szrj {
3685*fae548d3Szrj for (Warning_table::iterator p = this->warnings_.begin();
3686*fae548d3Szrj p != this->warnings_.end();
3687*fae548d3Szrj ++p)
3688*fae548d3Szrj {
3689*fae548d3Szrj Symbol* sym = symtab->lookup(p->first, NULL);
3690*fae548d3Szrj if (sym != NULL
3691*fae548d3Szrj && sym->source() == Symbol::FROM_OBJECT
3692*fae548d3Szrj && sym->object() == p->second.object)
3693*fae548d3Szrj sym->set_has_warning();
3694*fae548d3Szrj }
3695*fae548d3Szrj }
3696*fae548d3Szrj
3697*fae548d3Szrj // Issue a warning. This is called when we see a relocation against a
3698*fae548d3Szrj // symbol for which has a warning.
3699*fae548d3Szrj
3700*fae548d3Szrj template<int size, bool big_endian>
3701*fae548d3Szrj void
issue_warning(const Symbol * sym,const Relocate_info<size,big_endian> * relinfo,size_t relnum,off_t reloffset) const3702*fae548d3Szrj Warnings::issue_warning(const Symbol* sym,
3703*fae548d3Szrj const Relocate_info<size, big_endian>* relinfo,
3704*fae548d3Szrj size_t relnum, off_t reloffset) const
3705*fae548d3Szrj {
3706*fae548d3Szrj gold_assert(sym->has_warning());
3707*fae548d3Szrj
3708*fae548d3Szrj // We don't want to issue a warning for a relocation against the
3709*fae548d3Szrj // symbol in the same object file in which the symbol is defined.
3710*fae548d3Szrj if (sym->object() == relinfo->object)
3711*fae548d3Szrj return;
3712*fae548d3Szrj
3713*fae548d3Szrj Warning_table::const_iterator p = this->warnings_.find(sym->name());
3714*fae548d3Szrj gold_assert(p != this->warnings_.end());
3715*fae548d3Szrj gold_warning_at_location(relinfo, relnum, reloffset,
3716*fae548d3Szrj "%s", p->second.text.c_str());
3717*fae548d3Szrj }
3718*fae548d3Szrj
3719*fae548d3Szrj // Instantiate the templates we need. We could use the configure
3720*fae548d3Szrj // script to restrict this to only the ones needed for implemented
3721*fae548d3Szrj // targets.
3722*fae548d3Szrj
3723*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
3724*fae548d3Szrj template
3725*fae548d3Szrj void
3726*fae548d3Szrj Sized_symbol<32>::allocate_common(Output_data*, Value_type);
3727*fae548d3Szrj #endif
3728*fae548d3Szrj
3729*fae548d3Szrj #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
3730*fae548d3Szrj template
3731*fae548d3Szrj void
3732*fae548d3Szrj Sized_symbol<64>::allocate_common(Output_data*, Value_type);
3733*fae548d3Szrj #endif
3734*fae548d3Szrj
3735*fae548d3Szrj #ifdef HAVE_TARGET_32_LITTLE
3736*fae548d3Szrj template
3737*fae548d3Szrj void
3738*fae548d3Szrj Symbol_table::add_from_relobj<32, false>(
3739*fae548d3Szrj Sized_relobj_file<32, false>* relobj,
3740*fae548d3Szrj const unsigned char* syms,
3741*fae548d3Szrj size_t count,
3742*fae548d3Szrj size_t symndx_offset,
3743*fae548d3Szrj const char* sym_names,
3744*fae548d3Szrj size_t sym_name_size,
3745*fae548d3Szrj Sized_relobj_file<32, false>::Symbols* sympointers,
3746*fae548d3Szrj size_t* defined);
3747*fae548d3Szrj #endif
3748*fae548d3Szrj
3749*fae548d3Szrj #ifdef HAVE_TARGET_32_BIG
3750*fae548d3Szrj template
3751*fae548d3Szrj void
3752*fae548d3Szrj Symbol_table::add_from_relobj<32, true>(
3753*fae548d3Szrj Sized_relobj_file<32, true>* relobj,
3754*fae548d3Szrj const unsigned char* syms,
3755*fae548d3Szrj size_t count,
3756*fae548d3Szrj size_t symndx_offset,
3757*fae548d3Szrj const char* sym_names,
3758*fae548d3Szrj size_t sym_name_size,
3759*fae548d3Szrj Sized_relobj_file<32, true>::Symbols* sympointers,
3760*fae548d3Szrj size_t* defined);
3761*fae548d3Szrj #endif
3762*fae548d3Szrj
3763*fae548d3Szrj #ifdef HAVE_TARGET_64_LITTLE
3764*fae548d3Szrj template
3765*fae548d3Szrj void
3766*fae548d3Szrj Symbol_table::add_from_relobj<64, false>(
3767*fae548d3Szrj Sized_relobj_file<64, false>* relobj,
3768*fae548d3Szrj const unsigned char* syms,
3769*fae548d3Szrj size_t count,
3770*fae548d3Szrj size_t symndx_offset,
3771*fae548d3Szrj const char* sym_names,
3772*fae548d3Szrj size_t sym_name_size,
3773*fae548d3Szrj Sized_relobj_file<64, false>::Symbols* sympointers,
3774*fae548d3Szrj size_t* defined);
3775*fae548d3Szrj #endif
3776*fae548d3Szrj
3777*fae548d3Szrj #ifdef HAVE_TARGET_64_BIG
3778*fae548d3Szrj template
3779*fae548d3Szrj void
3780*fae548d3Szrj Symbol_table::add_from_relobj<64, true>(
3781*fae548d3Szrj Sized_relobj_file<64, true>* relobj,
3782*fae548d3Szrj const unsigned char* syms,
3783*fae548d3Szrj size_t count,
3784*fae548d3Szrj size_t symndx_offset,
3785*fae548d3Szrj const char* sym_names,
3786*fae548d3Szrj size_t sym_name_size,
3787*fae548d3Szrj Sized_relobj_file<64, true>::Symbols* sympointers,
3788*fae548d3Szrj size_t* defined);
3789*fae548d3Szrj #endif
3790*fae548d3Szrj
3791*fae548d3Szrj #ifdef HAVE_TARGET_32_LITTLE
3792*fae548d3Szrj template
3793*fae548d3Szrj Symbol*
3794*fae548d3Szrj Symbol_table::add_from_pluginobj<32, false>(
3795*fae548d3Szrj Sized_pluginobj<32, false>* obj,
3796*fae548d3Szrj const char* name,
3797*fae548d3Szrj const char* ver,
3798*fae548d3Szrj elfcpp::Sym<32, false>* sym);
3799*fae548d3Szrj #endif
3800*fae548d3Szrj
3801*fae548d3Szrj #ifdef HAVE_TARGET_32_BIG
3802*fae548d3Szrj template
3803*fae548d3Szrj Symbol*
3804*fae548d3Szrj Symbol_table::add_from_pluginobj<32, true>(
3805*fae548d3Szrj Sized_pluginobj<32, true>* obj,
3806*fae548d3Szrj const char* name,
3807*fae548d3Szrj const char* ver,
3808*fae548d3Szrj elfcpp::Sym<32, true>* sym);
3809*fae548d3Szrj #endif
3810*fae548d3Szrj
3811*fae548d3Szrj #ifdef HAVE_TARGET_64_LITTLE
3812*fae548d3Szrj template
3813*fae548d3Szrj Symbol*
3814*fae548d3Szrj Symbol_table::add_from_pluginobj<64, false>(
3815*fae548d3Szrj Sized_pluginobj<64, false>* obj,
3816*fae548d3Szrj const char* name,
3817*fae548d3Szrj const char* ver,
3818*fae548d3Szrj elfcpp::Sym<64, false>* sym);
3819*fae548d3Szrj #endif
3820*fae548d3Szrj
3821*fae548d3Szrj #ifdef HAVE_TARGET_64_BIG
3822*fae548d3Szrj template
3823*fae548d3Szrj Symbol*
3824*fae548d3Szrj Symbol_table::add_from_pluginobj<64, true>(
3825*fae548d3Szrj Sized_pluginobj<64, true>* obj,
3826*fae548d3Szrj const char* name,
3827*fae548d3Szrj const char* ver,
3828*fae548d3Szrj elfcpp::Sym<64, true>* sym);
3829*fae548d3Szrj #endif
3830*fae548d3Szrj
3831*fae548d3Szrj #ifdef HAVE_TARGET_32_LITTLE
3832*fae548d3Szrj template
3833*fae548d3Szrj void
3834*fae548d3Szrj Symbol_table::add_from_dynobj<32, false>(
3835*fae548d3Szrj Sized_dynobj<32, false>* dynobj,
3836*fae548d3Szrj const unsigned char* syms,
3837*fae548d3Szrj size_t count,
3838*fae548d3Szrj const char* sym_names,
3839*fae548d3Szrj size_t sym_name_size,
3840*fae548d3Szrj const unsigned char* versym,
3841*fae548d3Szrj size_t versym_size,
3842*fae548d3Szrj const std::vector<const char*>* version_map,
3843*fae548d3Szrj Sized_relobj_file<32, false>::Symbols* sympointers,
3844*fae548d3Szrj size_t* defined);
3845*fae548d3Szrj #endif
3846*fae548d3Szrj
3847*fae548d3Szrj #ifdef HAVE_TARGET_32_BIG
3848*fae548d3Szrj template
3849*fae548d3Szrj void
3850*fae548d3Szrj Symbol_table::add_from_dynobj<32, true>(
3851*fae548d3Szrj Sized_dynobj<32, true>* dynobj,
3852*fae548d3Szrj const unsigned char* syms,
3853*fae548d3Szrj size_t count,
3854*fae548d3Szrj const char* sym_names,
3855*fae548d3Szrj size_t sym_name_size,
3856*fae548d3Szrj const unsigned char* versym,
3857*fae548d3Szrj size_t versym_size,
3858*fae548d3Szrj const std::vector<const char*>* version_map,
3859*fae548d3Szrj Sized_relobj_file<32, true>::Symbols* sympointers,
3860*fae548d3Szrj size_t* defined);
3861*fae548d3Szrj #endif
3862*fae548d3Szrj
3863*fae548d3Szrj #ifdef HAVE_TARGET_64_LITTLE
3864*fae548d3Szrj template
3865*fae548d3Szrj void
3866*fae548d3Szrj Symbol_table::add_from_dynobj<64, false>(
3867*fae548d3Szrj Sized_dynobj<64, false>* dynobj,
3868*fae548d3Szrj const unsigned char* syms,
3869*fae548d3Szrj size_t count,
3870*fae548d3Szrj const char* sym_names,
3871*fae548d3Szrj size_t sym_name_size,
3872*fae548d3Szrj const unsigned char* versym,
3873*fae548d3Szrj size_t versym_size,
3874*fae548d3Szrj const std::vector<const char*>* version_map,
3875*fae548d3Szrj Sized_relobj_file<64, false>::Symbols* sympointers,
3876*fae548d3Szrj size_t* defined);
3877*fae548d3Szrj #endif
3878*fae548d3Szrj
3879*fae548d3Szrj #ifdef HAVE_TARGET_64_BIG
3880*fae548d3Szrj template
3881*fae548d3Szrj void
3882*fae548d3Szrj Symbol_table::add_from_dynobj<64, true>(
3883*fae548d3Szrj Sized_dynobj<64, true>* dynobj,
3884*fae548d3Szrj const unsigned char* syms,
3885*fae548d3Szrj size_t count,
3886*fae548d3Szrj const char* sym_names,
3887*fae548d3Szrj size_t sym_name_size,
3888*fae548d3Szrj const unsigned char* versym,
3889*fae548d3Szrj size_t versym_size,
3890*fae548d3Szrj const std::vector<const char*>* version_map,
3891*fae548d3Szrj Sized_relobj_file<64, true>::Symbols* sympointers,
3892*fae548d3Szrj size_t* defined);
3893*fae548d3Szrj #endif
3894*fae548d3Szrj
3895*fae548d3Szrj #ifdef HAVE_TARGET_32_LITTLE
3896*fae548d3Szrj template
3897*fae548d3Szrj Sized_symbol<32>*
3898*fae548d3Szrj Symbol_table::add_from_incrobj(
3899*fae548d3Szrj Object* obj,
3900*fae548d3Szrj const char* name,
3901*fae548d3Szrj const char* ver,
3902*fae548d3Szrj elfcpp::Sym<32, false>* sym);
3903*fae548d3Szrj #endif
3904*fae548d3Szrj
3905*fae548d3Szrj #ifdef HAVE_TARGET_32_BIG
3906*fae548d3Szrj template
3907*fae548d3Szrj Sized_symbol<32>*
3908*fae548d3Szrj Symbol_table::add_from_incrobj(
3909*fae548d3Szrj Object* obj,
3910*fae548d3Szrj const char* name,
3911*fae548d3Szrj const char* ver,
3912*fae548d3Szrj elfcpp::Sym<32, true>* sym);
3913*fae548d3Szrj #endif
3914*fae548d3Szrj
3915*fae548d3Szrj #ifdef HAVE_TARGET_64_LITTLE
3916*fae548d3Szrj template
3917*fae548d3Szrj Sized_symbol<64>*
3918*fae548d3Szrj Symbol_table::add_from_incrobj(
3919*fae548d3Szrj Object* obj,
3920*fae548d3Szrj const char* name,
3921*fae548d3Szrj const char* ver,
3922*fae548d3Szrj elfcpp::Sym<64, false>* sym);
3923*fae548d3Szrj #endif
3924*fae548d3Szrj
3925*fae548d3Szrj #ifdef HAVE_TARGET_64_BIG
3926*fae548d3Szrj template
3927*fae548d3Szrj Sized_symbol<64>*
3928*fae548d3Szrj Symbol_table::add_from_incrobj(
3929*fae548d3Szrj Object* obj,
3930*fae548d3Szrj const char* name,
3931*fae548d3Szrj const char* ver,
3932*fae548d3Szrj elfcpp::Sym<64, true>* sym);
3933*fae548d3Szrj #endif
3934*fae548d3Szrj
3935*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
3936*fae548d3Szrj template
3937*fae548d3Szrj void
3938*fae548d3Szrj Symbol_table::define_with_copy_reloc<32>(
3939*fae548d3Szrj Sized_symbol<32>* sym,
3940*fae548d3Szrj Output_data* posd,
3941*fae548d3Szrj elfcpp::Elf_types<32>::Elf_Addr value);
3942*fae548d3Szrj #endif
3943*fae548d3Szrj
3944*fae548d3Szrj #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
3945*fae548d3Szrj template
3946*fae548d3Szrj void
3947*fae548d3Szrj Symbol_table::define_with_copy_reloc<64>(
3948*fae548d3Szrj Sized_symbol<64>* sym,
3949*fae548d3Szrj Output_data* posd,
3950*fae548d3Szrj elfcpp::Elf_types<64>::Elf_Addr value);
3951*fae548d3Szrj #endif
3952*fae548d3Szrj
3953*fae548d3Szrj #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
3954*fae548d3Szrj template
3955*fae548d3Szrj void
3956*fae548d3Szrj Sized_symbol<32>::init_output_data(const char* name, const char* version,
3957*fae548d3Szrj Output_data* od, Value_type value,
3958*fae548d3Szrj Size_type symsize, elfcpp::STT type,
3959*fae548d3Szrj elfcpp::STB binding,
3960*fae548d3Szrj elfcpp::STV visibility,
3961*fae548d3Szrj unsigned char nonvis,
3962*fae548d3Szrj bool offset_is_from_end,
3963*fae548d3Szrj bool is_predefined);
3964*fae548d3Szrj
3965*fae548d3Szrj template
3966*fae548d3Szrj void
3967*fae548d3Szrj Sized_symbol<32>::init_constant(const char* name, const char* version,
3968*fae548d3Szrj Value_type value, Size_type symsize,
3969*fae548d3Szrj elfcpp::STT type, elfcpp::STB binding,
3970*fae548d3Szrj elfcpp::STV visibility, unsigned char nonvis,
3971*fae548d3Szrj bool is_predefined);
3972*fae548d3Szrj
3973*fae548d3Szrj template
3974*fae548d3Szrj void
3975*fae548d3Szrj Sized_symbol<32>::init_undefined(const char* name, const char* version,
3976*fae548d3Szrj Value_type value, elfcpp::STT type,
3977*fae548d3Szrj elfcpp::STB binding, elfcpp::STV visibility,
3978*fae548d3Szrj unsigned char nonvis);
3979*fae548d3Szrj #endif
3980*fae548d3Szrj
3981*fae548d3Szrj #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
3982*fae548d3Szrj template
3983*fae548d3Szrj void
3984*fae548d3Szrj Sized_symbol<64>::init_output_data(const char* name, const char* version,
3985*fae548d3Szrj Output_data* od, Value_type value,
3986*fae548d3Szrj Size_type symsize, elfcpp::STT type,
3987*fae548d3Szrj elfcpp::STB binding,
3988*fae548d3Szrj elfcpp::STV visibility,
3989*fae548d3Szrj unsigned char nonvis,
3990*fae548d3Szrj bool offset_is_from_end,
3991*fae548d3Szrj bool is_predefined);
3992*fae548d3Szrj
3993*fae548d3Szrj template
3994*fae548d3Szrj void
3995*fae548d3Szrj Sized_symbol<64>::init_constant(const char* name, const char* version,
3996*fae548d3Szrj Value_type value, Size_type symsize,
3997*fae548d3Szrj elfcpp::STT type, elfcpp::STB binding,
3998*fae548d3Szrj elfcpp::STV visibility, unsigned char nonvis,
3999*fae548d3Szrj bool is_predefined);
4000*fae548d3Szrj
4001*fae548d3Szrj template
4002*fae548d3Szrj void
4003*fae548d3Szrj Sized_symbol<64>::init_undefined(const char* name, const char* version,
4004*fae548d3Szrj Value_type value, elfcpp::STT type,
4005*fae548d3Szrj elfcpp::STB binding, elfcpp::STV visibility,
4006*fae548d3Szrj unsigned char nonvis);
4007*fae548d3Szrj #endif
4008*fae548d3Szrj
4009*fae548d3Szrj #ifdef HAVE_TARGET_32_LITTLE
4010*fae548d3Szrj template
4011*fae548d3Szrj void
4012*fae548d3Szrj Warnings::issue_warning<32, false>(const Symbol* sym,
4013*fae548d3Szrj const Relocate_info<32, false>* relinfo,
4014*fae548d3Szrj size_t relnum, off_t reloffset) const;
4015*fae548d3Szrj #endif
4016*fae548d3Szrj
4017*fae548d3Szrj #ifdef HAVE_TARGET_32_BIG
4018*fae548d3Szrj template
4019*fae548d3Szrj void
4020*fae548d3Szrj Warnings::issue_warning<32, true>(const Symbol* sym,
4021*fae548d3Szrj const Relocate_info<32, true>* relinfo,
4022*fae548d3Szrj size_t relnum, off_t reloffset) const;
4023*fae548d3Szrj #endif
4024*fae548d3Szrj
4025*fae548d3Szrj #ifdef HAVE_TARGET_64_LITTLE
4026*fae548d3Szrj template
4027*fae548d3Szrj void
4028*fae548d3Szrj Warnings::issue_warning<64, false>(const Symbol* sym,
4029*fae548d3Szrj const Relocate_info<64, false>* relinfo,
4030*fae548d3Szrj size_t relnum, off_t reloffset) const;
4031*fae548d3Szrj #endif
4032*fae548d3Szrj
4033*fae548d3Szrj #ifdef HAVE_TARGET_64_BIG
4034*fae548d3Szrj template
4035*fae548d3Szrj void
4036*fae548d3Szrj Warnings::issue_warning<64, true>(const Symbol* sym,
4037*fae548d3Szrj const Relocate_info<64, true>* relinfo,
4038*fae548d3Szrj size_t relnum, off_t reloffset) const;
4039*fae548d3Szrj #endif
4040*fae548d3Szrj
4041*fae548d3Szrj } // End namespace gold.
4042