54529d1e93ada598bf1859ab839fcf2553611bcd
[external/binutils.git] / gold / resolve.cc
1 // resolve.cc -- symbol resolution for gold
2
3 // Copyright 2006, 2007 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
5
6 // This file is part of gold.
7
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
12
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 // GNU General Public License for more details.
17
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
22
23 #include "gold.h"
24
25 #include "elfcpp.h"
26 #include "target.h"
27 #include "object.h"
28 #include "symtab.h"
29
30 namespace gold
31 {
32
33 // Symbol methods used in this file.
34
35 // Override the fields in Symbol.
36
37 template<int size, bool big_endian>
38 void
39 Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym,
40                       Object* object, const char* version)
41 {
42   gold_assert(this->source_ == FROM_OBJECT);
43   this->u_.from_object.object = object;
44   if (version != NULL && this->version() != version)
45     {
46       gold_assert(this->version() == NULL);
47       this->version_ = version;
48     }
49   // FIXME: Handle SHN_XINDEX.
50   this->u_.from_object.shndx = sym.get_st_shndx();
51   this->type_ = sym.get_st_type();
52   this->binding_ = sym.get_st_bind();
53   this->visibility_ = sym.get_st_visibility();
54   this->nonvis_ = sym.get_st_nonvis();
55   if (object->is_dynamic())
56     this->in_dyn_ = true;
57   else
58     this->in_reg_ = true;
59 }
60
61 // Override the fields in Sized_symbol.
62
63 template<int size>
64 template<bool big_endian>
65 void
66 Sized_symbol<size>::override(const elfcpp::Sym<size, big_endian>& sym,
67                              Object* object, const char* version)
68 {
69   this->override_base(sym, object, version);
70   this->value_ = sym.get_st_value();
71   this->symsize_ = sym.get_st_size();
72 }
73
74 // The resolve functions build a little code for each symbol.
75 // Bit 0: 0 for global, 1 for weak.
76 // Bit 1: 0 for regular object, 1 for shared object
77 // Bits 2-3: 0 for normal, 1 for undefined, 2 for common
78 // This gives us values from 0 to 11.
79
80 static const int global_or_weak_shift = 0;
81 static const unsigned int global_flag = 0 << global_or_weak_shift;
82 static const unsigned int weak_flag = 1 << global_or_weak_shift;
83
84 static const int regular_or_dynamic_shift = 1;
85 static const unsigned int regular_flag = 0 << regular_or_dynamic_shift;
86 static const unsigned int dynamic_flag = 1 << regular_or_dynamic_shift;
87
88 static const int def_undef_or_common_shift = 2;
89 static const unsigned int def_flag = 0 << def_undef_or_common_shift;
90 static const unsigned int undef_flag = 1 << def_undef_or_common_shift;
91 static const unsigned int common_flag = 2 << def_undef_or_common_shift;
92
93 // Resolve a symbol.  This is called the second and subsequent times
94 // we see a symbol.  TO is the pre-existing symbol.  SYM is the new
95 // symbol, seen in OBJECT.  VERSION of the version of SYM.
96
97 template<int size, bool big_endian>
98 void
99 Symbol_table::resolve(Sized_symbol<size>* to,
100                       const elfcpp::Sym<size, big_endian>& sym,
101                       Object* object, const char* version)
102 {
103   if (object->target()->has_resolve())
104     {
105       Sized_target<size, big_endian>* sized_target;
106       sized_target = object->sized_target
107                      SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
108                          SELECT_SIZE_ENDIAN_ONLY(size, big_endian));
109       sized_target->resolve(to, sym, object, version);
110       return;
111     }
112
113   if (!object->is_dynamic())
114     {
115       // Record that we've seen this symbol in a regular object.
116       to->set_in_reg();
117     }
118   else
119     {
120       // Record that we've seen this symbol in a dynamic object.
121       to->set_in_dyn();
122     }
123
124   unsigned int frombits;
125   switch (sym.get_st_bind())
126     {
127     case elfcpp::STB_GLOBAL:
128       frombits = global_flag;
129       break;
130
131     case elfcpp::STB_WEAK:
132       frombits = weak_flag;
133       break;
134
135     case elfcpp::STB_LOCAL:
136       gold_error(_("%s: invalid STB_LOCAL symbol %s in external symbols"),
137                  object->name().c_str(), to->name());
138       frombits = global_flag;
139       break;
140
141     default:
142       gold_error(_("%s: unsupported symbol binding %d for symbol %s"),
143                  object->name().c_str(),
144                  static_cast<int>(sym.get_st_bind()), to->name());
145       frombits = global_flag;
146       break;
147     }
148
149   if (!object->is_dynamic())
150     frombits |= regular_flag;
151   else
152     frombits |= dynamic_flag;
153
154   switch (sym.get_st_shndx())
155     {
156     case elfcpp::SHN_UNDEF:
157       frombits |= undef_flag;
158       break;
159
160     case elfcpp::SHN_COMMON:
161       frombits |= common_flag;
162       break;
163
164     default:
165       if (sym.get_st_type() == elfcpp::STT_COMMON)
166         frombits |= common_flag;
167       else
168         frombits |= def_flag;
169       break;
170     }
171
172   bool adjust_common_sizes;
173   if (Symbol_table::should_override(to, frombits, &adjust_common_sizes))
174     {
175       typename Sized_symbol<size>::Size_type tosize = to->symsize();
176
177       to->override(sym, object, version);
178
179       if (adjust_common_sizes && tosize > to->symsize())
180         to->set_symsize(tosize);
181     }
182   else
183     {
184       if (adjust_common_sizes && sym.get_st_size() > to->symsize())
185         to->set_symsize(sym.get_st_size());
186     }
187 }
188
189 // Handle the core of symbol resolution.  This is called with the
190 // existing symbol, TO, and a bitflag describing the new symbol.  This
191 // returns true if we should override the existing symbol with the new
192 // one, and returns false otherwise.  It sets *ADJUST_COMMON_SIZES to
193 // true if we should set the symbol size to the maximum of the TO and
194 // FROM sizes.  It handles error conditions.
195
196 bool
197 Symbol_table::should_override(const Symbol* to, unsigned int frombits,
198                               bool* adjust_common_sizes)
199 {
200   *adjust_common_sizes = false;
201
202   unsigned int tobits;
203   switch (to->binding())
204     {
205     case elfcpp::STB_GLOBAL:
206       tobits = global_flag;
207       break;
208
209     case elfcpp::STB_WEAK:
210       tobits = weak_flag;
211       break;
212
213     case elfcpp::STB_LOCAL:
214       // We should only see externally visible symbols in the symbol
215       // table.
216       gold_unreachable();
217
218     default:
219       // Any target which wants to handle STB_LOOS, etc., needs to
220       // define a resolve method.
221       gold_unreachable();
222     }
223
224   if (to->source() == Symbol::FROM_OBJECT
225       && to->object()->is_dynamic())
226     tobits |= dynamic_flag;
227   else
228     tobits |= regular_flag;
229
230   switch (to->shndx())
231     {
232     case elfcpp::SHN_UNDEF:
233       tobits |= undef_flag;
234       break;
235
236     case elfcpp::SHN_COMMON:
237       tobits |= common_flag;
238       break;
239
240     default:
241       if (to->type() == elfcpp::STT_COMMON)
242         tobits |= common_flag;
243       else
244         tobits |= def_flag;
245       break;
246     }
247
248   // FIXME: Warn if either but not both of TO and SYM are STT_TLS.
249
250   // We use a giant switch table for symbol resolution.  This code is
251   // unwieldy, but: 1) it is efficient; 2) we definitely handle all
252   // cases; 3) it is easy to change the handling of a particular case.
253   // The alternative would be a series of conditionals, but it is easy
254   // to get the ordering wrong.  This could also be done as a table,
255   // but that is no easier to understand than this large switch
256   // statement.
257
258   // These are the values generated by the bit codes.
259   enum
260   {
261     DEF =              global_flag | regular_flag | def_flag,
262     WEAK_DEF =         weak_flag   | regular_flag | def_flag,
263     DYN_DEF =          global_flag | dynamic_flag | def_flag,
264     DYN_WEAK_DEF =     weak_flag   | dynamic_flag | def_flag,
265     UNDEF =            global_flag | regular_flag | undef_flag,
266     WEAK_UNDEF =       weak_flag   | regular_flag | undef_flag,
267     DYN_UNDEF =        global_flag | dynamic_flag | undef_flag,
268     DYN_WEAK_UNDEF =   weak_flag   | dynamic_flag | undef_flag,
269     COMMON =           global_flag | regular_flag | common_flag,
270     WEAK_COMMON =      weak_flag   | regular_flag | common_flag,
271     DYN_COMMON =       global_flag | dynamic_flag | common_flag,
272     DYN_WEAK_COMMON =  weak_flag   | dynamic_flag | common_flag
273   };
274
275   switch (tobits * 16 + frombits)
276     {
277     case DEF * 16 + DEF:
278       // Two definitions of the same symbol.
279       // FIXME: Report locations.
280       gold_error(_("multiple definition of %s"), to->name());
281       return false;
282
283     case WEAK_DEF * 16 + DEF:
284       // We've seen a weak definition, and now we see a strong
285       // definition.  In the original SVR4 linker, this was treated as
286       // a multiple definition error.  In the Solaris linker and the
287       // GNU linker, a weak definition followed by a regular
288       // definition causes the weak definition to be overridden.  We
289       // are currently compatible with the GNU linker.  In the future
290       // we should add a target specific option to change this.
291       // FIXME.
292       return true;
293
294     case DYN_DEF * 16 + DEF:
295     case DYN_WEAK_DEF * 16 + DEF:
296       // We've seen a definition in a dynamic object, and now we see a
297       // definition in a regular object.  The definition in the
298       // regular object overrides the definition in the dynamic
299       // object.
300       return true;
301
302     case UNDEF * 16 + DEF:
303     case WEAK_UNDEF * 16 + DEF:
304     case DYN_UNDEF * 16 + DEF:
305     case DYN_WEAK_UNDEF * 16 + DEF:
306       // We've seen an undefined reference, and now we see a
307       // definition.  We use the definition.
308       return true;
309
310     case COMMON * 16 + DEF:
311     case WEAK_COMMON * 16 + DEF:
312     case DYN_COMMON * 16 + DEF:
313     case DYN_WEAK_COMMON * 16 + DEF:
314       // We've seen a common symbol and now we see a definition.  The
315       // definition overrides.  FIXME: We should optionally issue, version a
316       // warning.
317       return true;
318
319     case DEF * 16 + WEAK_DEF:
320     case WEAK_DEF * 16 + WEAK_DEF:
321       // We've seen a definition and now we see a weak definition.  We
322       // ignore the new weak definition.
323       return false;
324
325     case DYN_DEF * 16 + WEAK_DEF:
326     case DYN_WEAK_DEF * 16 + WEAK_DEF:
327       // We've seen a dynamic definition and now we see a regular weak
328       // definition.  The regular weak definition overrides.
329       return true;
330
331     case UNDEF * 16 + WEAK_DEF:
332     case WEAK_UNDEF * 16 + WEAK_DEF:
333     case DYN_UNDEF * 16 + WEAK_DEF:
334     case DYN_WEAK_UNDEF * 16 + WEAK_DEF:
335       // A weak definition of a currently undefined symbol.
336       return true;
337
338     case COMMON * 16 + WEAK_DEF:
339     case WEAK_COMMON * 16 + WEAK_DEF:
340       // A weak definition does not override a common definition.
341       return false;
342
343     case DYN_COMMON * 16 + WEAK_DEF:
344     case DYN_WEAK_COMMON * 16 + WEAK_DEF:
345       // A weak definition does override a definition in a dynamic
346       // object.  FIXME: We should optionally issue a warning.
347       return true;
348
349     case DEF * 16 + DYN_DEF:
350     case WEAK_DEF * 16 + DYN_DEF:
351     case DYN_DEF * 16 + DYN_DEF:
352     case DYN_WEAK_DEF * 16 + DYN_DEF:
353       // Ignore a dynamic definition if we already have a definition.
354       return false;
355
356     case UNDEF * 16 + DYN_DEF:
357     case WEAK_UNDEF * 16 + DYN_DEF:
358     case DYN_UNDEF * 16 + DYN_DEF:
359     case DYN_WEAK_UNDEF * 16 + DYN_DEF:
360       // Use a dynamic definition if we have a reference.
361       return true;
362
363     case COMMON * 16 + DYN_DEF:
364     case WEAK_COMMON * 16 + DYN_DEF:
365     case DYN_COMMON * 16 + DYN_DEF:
366     case DYN_WEAK_COMMON * 16 + DYN_DEF:
367       // Ignore a dynamic definition if we already have a common
368       // definition.
369       return false;
370
371     case DEF * 16 + DYN_WEAK_DEF:
372     case WEAK_DEF * 16 + DYN_WEAK_DEF:
373     case DYN_DEF * 16 + DYN_WEAK_DEF:
374     case DYN_WEAK_DEF * 16 + DYN_WEAK_DEF:
375       // Ignore a weak dynamic definition if we already have a
376       // definition.
377       return false;
378
379     case UNDEF * 16 + DYN_WEAK_DEF:
380     case WEAK_UNDEF * 16 + DYN_WEAK_DEF:
381     case DYN_UNDEF * 16 + DYN_WEAK_DEF:
382     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_DEF:
383       // Use a weak dynamic definition if we have a reference.
384       return true;
385
386     case COMMON * 16 + DYN_WEAK_DEF:
387     case WEAK_COMMON * 16 + DYN_WEAK_DEF:
388     case DYN_COMMON * 16 + DYN_WEAK_DEF:
389     case DYN_WEAK_COMMON * 16 + DYN_WEAK_DEF:
390       // Ignore a weak dynamic definition if we already have a common
391       // definition.
392       return false;
393
394     case DEF * 16 + UNDEF:
395     case WEAK_DEF * 16 + UNDEF:
396     case DYN_DEF * 16 + UNDEF:
397     case DYN_WEAK_DEF * 16 + UNDEF:
398     case UNDEF * 16 + UNDEF:
399       // A new undefined reference tells us nothing.
400       return false;
401
402     case WEAK_UNDEF * 16 + UNDEF:
403     case DYN_UNDEF * 16 + UNDEF:
404     case DYN_WEAK_UNDEF * 16 + UNDEF:
405       // A strong undef overrides a dynamic or weak undef.
406       return true;
407
408     case COMMON * 16 + UNDEF:
409     case WEAK_COMMON * 16 + UNDEF:
410     case DYN_COMMON * 16 + UNDEF:
411     case DYN_WEAK_COMMON * 16 + UNDEF:
412       // A new undefined reference tells us nothing.
413       return false;
414
415     case DEF * 16 + WEAK_UNDEF:
416     case WEAK_DEF * 16 + WEAK_UNDEF:
417     case DYN_DEF * 16 + WEAK_UNDEF:
418     case DYN_WEAK_DEF * 16 + WEAK_UNDEF:
419     case UNDEF * 16 + WEAK_UNDEF:
420     case WEAK_UNDEF * 16 + WEAK_UNDEF:
421     case DYN_UNDEF * 16 + WEAK_UNDEF:
422     case DYN_WEAK_UNDEF * 16 + WEAK_UNDEF:
423     case COMMON * 16 + WEAK_UNDEF:
424     case WEAK_COMMON * 16 + WEAK_UNDEF:
425     case DYN_COMMON * 16 + WEAK_UNDEF:
426     case DYN_WEAK_COMMON * 16 + WEAK_UNDEF:
427       // A new weak undefined reference tells us nothing.
428       return false;
429
430     case DEF * 16 + DYN_UNDEF:
431     case WEAK_DEF * 16 + DYN_UNDEF:
432     case DYN_DEF * 16 + DYN_UNDEF:
433     case DYN_WEAK_DEF * 16 + DYN_UNDEF:
434     case UNDEF * 16 + DYN_UNDEF:
435     case WEAK_UNDEF * 16 + DYN_UNDEF:
436     case DYN_UNDEF * 16 + DYN_UNDEF:
437     case DYN_WEAK_UNDEF * 16 + DYN_UNDEF:
438     case COMMON * 16 + DYN_UNDEF:
439     case WEAK_COMMON * 16 + DYN_UNDEF:
440     case DYN_COMMON * 16 + DYN_UNDEF:
441     case DYN_WEAK_COMMON * 16 + DYN_UNDEF:
442       // A new dynamic undefined reference tells us nothing.
443       return false;
444
445     case DEF * 16 + DYN_WEAK_UNDEF:
446     case WEAK_DEF * 16 + DYN_WEAK_UNDEF:
447     case DYN_DEF * 16 + DYN_WEAK_UNDEF:
448     case DYN_WEAK_DEF * 16 + DYN_WEAK_UNDEF:
449     case UNDEF * 16 + DYN_WEAK_UNDEF:
450     case WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
451     case DYN_UNDEF * 16 + DYN_WEAK_UNDEF:
452     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
453     case COMMON * 16 + DYN_WEAK_UNDEF:
454     case WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
455     case DYN_COMMON * 16 + DYN_WEAK_UNDEF:
456     case DYN_WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
457       // A new weak dynamic undefined reference tells us nothing.
458       return false;
459
460     case DEF * 16 + COMMON:
461       // A common symbol does not override a definition.
462       return false;
463
464     case WEAK_DEF * 16 + COMMON:
465     case DYN_DEF * 16 + COMMON:
466     case DYN_WEAK_DEF * 16 + COMMON:
467       // A common symbol does override a weak definition or a dynamic
468       // definition.
469       return true;
470
471     case UNDEF * 16 + COMMON:
472     case WEAK_UNDEF * 16 + COMMON:
473     case DYN_UNDEF * 16 + COMMON:
474     case DYN_WEAK_UNDEF * 16 + COMMON:
475       // A common symbol is a definition for a reference.
476       return true;
477
478     case COMMON * 16 + COMMON:
479       // Set the size to the maximum.
480       *adjust_common_sizes = true;
481       return false;
482
483     case WEAK_COMMON * 16 + COMMON:
484       // I'm not sure just what a weak common symbol means, but
485       // presumably it can be overridden by a regular common symbol.
486       return true;
487
488     case DYN_COMMON * 16 + COMMON:
489     case DYN_WEAK_COMMON * 16 + COMMON:
490       // Use the real common symbol, but adjust the size if necessary.
491       *adjust_common_sizes = true;
492       return true;
493
494     case DEF * 16 + WEAK_COMMON:
495     case WEAK_DEF * 16 + WEAK_COMMON:
496     case DYN_DEF * 16 + WEAK_COMMON:
497     case DYN_WEAK_DEF * 16 + WEAK_COMMON:
498       // Whatever a weak common symbol is, it won't override a
499       // definition.
500       return false;
501
502     case UNDEF * 16 + WEAK_COMMON:
503     case WEAK_UNDEF * 16 + WEAK_COMMON:
504     case DYN_UNDEF * 16 + WEAK_COMMON:
505     case DYN_WEAK_UNDEF * 16 + WEAK_COMMON:
506       // A weak common symbol is better than an undefined symbol.
507       return true;
508
509     case COMMON * 16 + WEAK_COMMON:
510     case WEAK_COMMON * 16 + WEAK_COMMON:
511     case DYN_COMMON * 16 + WEAK_COMMON:
512     case DYN_WEAK_COMMON * 16 + WEAK_COMMON:
513       // Ignore a weak common symbol in the presence of a real common
514       // symbol.
515       return false;
516
517     case DEF * 16 + DYN_COMMON:
518     case WEAK_DEF * 16 + DYN_COMMON:
519     case DYN_DEF * 16 + DYN_COMMON:
520     case DYN_WEAK_DEF * 16 + DYN_COMMON:
521       // Ignore a dynamic common symbol in the presence of a
522       // definition.
523       return false;
524
525     case UNDEF * 16 + DYN_COMMON:
526     case WEAK_UNDEF * 16 + DYN_COMMON:
527     case DYN_UNDEF * 16 + DYN_COMMON:
528     case DYN_WEAK_UNDEF * 16 + DYN_COMMON:
529       // A dynamic common symbol is a definition of sorts.
530       return true;
531
532     case COMMON * 16 + DYN_COMMON:
533     case WEAK_COMMON * 16 + DYN_COMMON:
534     case DYN_COMMON * 16 + DYN_COMMON:
535     case DYN_WEAK_COMMON * 16 + DYN_COMMON:
536       // Set the size to the maximum.
537       *adjust_common_sizes = true;
538       return false;
539
540     case DEF * 16 + DYN_WEAK_COMMON:
541     case WEAK_DEF * 16 + DYN_WEAK_COMMON:
542     case DYN_DEF * 16 + DYN_WEAK_COMMON:
543     case DYN_WEAK_DEF * 16 + DYN_WEAK_COMMON:
544       // A common symbol is ignored in the face of a definition.
545       return false;
546
547     case UNDEF * 16 + DYN_WEAK_COMMON:
548     case WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
549     case DYN_UNDEF * 16 + DYN_WEAK_COMMON:
550     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
551       // I guess a weak common symbol is better than a definition.
552       return true;
553
554     case COMMON * 16 + DYN_WEAK_COMMON:
555     case WEAK_COMMON * 16 + DYN_WEAK_COMMON:
556     case DYN_COMMON * 16 + DYN_WEAK_COMMON:
557     case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON:
558       // Set the size to the maximum.
559       *adjust_common_sizes = true;
560       return false;
561
562     default:
563       gold_unreachable();
564     }
565 }
566
567 // A special case of should_override which is only called for a strong
568 // defined symbol from a regular object file.  This is used when
569 // defining special symbols.
570
571 bool
572 Symbol_table::should_override_with_special(const Symbol* to)
573 {
574   bool adjust_common_sizes;
575   unsigned int frombits = global_flag | regular_flag | def_flag;
576   bool ret = Symbol_table::should_override(to, frombits, &adjust_common_sizes);
577   gold_assert(!adjust_common_sizes);
578   return ret;
579 }
580
581 // Override symbol base with a special symbol.
582
583 void
584 Symbol::override_base_with_special(const Symbol* from)
585 {
586   this->source_ = from->source_;
587   switch (from->source_)
588     {
589     case FROM_OBJECT:
590       this->u_.from_object = from->u_.from_object;
591       break;
592     case IN_OUTPUT_DATA:
593       this->u_.in_output_data = from->u_.in_output_data;
594       break;
595     case IN_OUTPUT_SEGMENT:
596       this->u_.in_output_segment = from->u_.in_output_segment;
597       break;
598     case CONSTANT:
599       break;
600     default:
601       gold_unreachable();
602       break;
603     }
604
605   if (from->version_ != NULL && this->version_ != from->version_)
606     {
607       gold_assert(this->version_ == NULL);
608       this->version_ = from->version_;
609     }
610
611   this->type_ = from->type_;
612   this->binding_ = from->binding_;
613   this->visibility_ = from->visibility_;
614   this->nonvis_ = from->nonvis_;
615
616   // Special symbols are always considered to be regular symbols.
617   this->in_reg_ = true;
618 }
619
620 // Override a symbol with a special symbol.
621
622 template<int size>
623 void
624 Sized_symbol<size>::override_with_special(const Sized_symbol<size>* from)
625 {
626   this->override_base_with_special(from);
627   this->value_ = from->value_;
628   this->symsize_ = from->symsize_;
629 }
630
631 // Instantiate the templates we need.  We could use the configure
632 // script to restrict this to only the ones needed for implemented
633 // targets.
634
635 #ifdef HAVE_TARGET_32_LITTLE
636 template
637 void
638 Symbol_table::resolve<32, false>(
639     Sized_symbol<32>* to,
640     const elfcpp::Sym<32, false>& sym,
641     Object* object,
642     const char* version);
643 #endif
644
645 #ifdef HAVE_TARGET_32_BIG
646 template
647 void
648 Symbol_table::resolve<32, true>(
649     Sized_symbol<32>* to,
650     const elfcpp::Sym<32, true>& sym,
651     Object* object,
652     const char* version);
653 #endif
654
655 #ifdef HAVE_TARGET_64_LITTLE
656 template
657 void
658 Symbol_table::resolve<64, false>(
659     Sized_symbol<64>* to,
660     const elfcpp::Sym<64, false>& sym,
661     Object* object,
662     const char* version);
663 #endif
664
665 #ifdef HAVE_TARGET_64_BIG
666 template
667 void
668 Symbol_table::resolve<64, true>(
669     Sized_symbol<64>* to,
670     const elfcpp::Sym<64, true>& sym,
671     Object* object,
672     const char* version);
673 #endif
674
675 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
676 template
677 void
678 Sized_symbol<32>::override_with_special(const Sized_symbol<32>*);
679 #endif
680
681 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
682 template
683 void
684 Sized_symbol<64>::override_with_special(const Sized_symbol<64>*);
685 #endif
686
687 } // End namespace gold.