Hash tables, dynamic section, i386 PLT, gold_assert.
[external/binutils.git] / gold / resolve.cc
1 // resolve.cc -- symbol resolution for gold
2
3 #include "gold.h"
4
5 #include "elfcpp.h"
6 #include "target.h"
7 #include "object.h"
8 #include "symtab.h"
9
10 namespace gold
11 {
12
13 // Symbol methods used in this file.
14
15 // Override the fields in Symbol.
16
17 template<int size, bool big_endian>
18 void
19 Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym,
20                       Object* object)
21 {
22   gold_assert(this->source_ == FROM_OBJECT);
23   this->u_.from_object.object = object;
24   // FIXME: Handle SHN_XINDEX.
25   this->u_.from_object.shnum = sym.get_st_shndx();
26   this->type_ = sym.get_st_type();
27   this->binding_ = sym.get_st_bind();
28   this->visibility_ = sym.get_st_visibility();
29   this->nonvis_ = sym.get_st_nonvis();
30 }
31
32 // Override the fields in Sized_symbol.
33
34 template<int size>
35 template<bool big_endian>
36 void
37 Sized_symbol<size>::override(const elfcpp::Sym<size, big_endian>& sym,
38                              Object* object)
39 {
40   this->override_base(sym, object);
41   this->value_ = sym.get_st_value();
42   this->symsize_ = sym.get_st_size();
43 }
44
45 // Resolve a symbol.  This is called the second and subsequent times
46 // we see a symbol.  TO is the pre-existing symbol.  SYM is the new
47 // symbol, seen in OBJECT.
48
49 template<int size, bool big_endian>
50 void
51 Symbol_table::resolve(Sized_symbol<size>* to,
52                       const elfcpp::Sym<size, big_endian>& sym,
53                       Object* object)
54 {
55   if (object->target()->has_resolve())
56     {
57       Sized_target<size, big_endian>* sized_target;
58       sized_target = object->sized_target
59                      SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
60                          SELECT_SIZE_ENDIAN_ONLY(size, big_endian));
61       sized_target->resolve(to, sym, object);
62       return;
63     }
64
65   // Build a little code for each symbol.
66   // Bit 0: 0 for global, 1 for weak.
67   // Bit 1: 0 for regular object, 1 for shared object
68   // Bits 2-3: 0 for normal, 1 for undefined, 2 for common
69   // This gives us values from 0 to 11:
70
71   enum
72   {
73     DEF = 0,
74     WEAK_DEF = 1,
75     DYN_DEF = 2,
76     DYN_WEAK_DEF = 3,
77     UNDEF = 4,
78     WEAK_UNDEF = 5,
79     DYN_UNDEF = 6,
80     DYN_WEAK_UNDEF = 7,
81     COMMON = 8,
82     WEAK_COMMON = 9,
83     DYN_COMMON = 10,
84     DYN_WEAK_COMMON = 11
85   };
86
87   int tobits;
88   switch (to->binding())
89     {
90     case elfcpp::STB_GLOBAL:
91       tobits = 0;
92       break;
93
94     case elfcpp::STB_WEAK:
95       tobits = 1;
96       break;
97
98     case elfcpp::STB_LOCAL:
99       // We should only see externally visible symbols in the symbol
100       // table.
101       gold_unreachable();
102
103     default:
104       // Any target which wants to handle STB_LOOS, etc., needs to
105       // define a resolve method.
106       gold_unreachable();
107     }
108
109   if (to->source() == Symbol::FROM_OBJECT
110       && to->object()->is_dynamic())
111     tobits |= (1 << 1);
112
113   switch (to->shnum())
114     {
115     case elfcpp::SHN_UNDEF:
116       tobits |= (1 << 2);
117       break;
118
119     case elfcpp::SHN_COMMON:
120       tobits |= (2 << 2);
121       break;
122
123     default:
124       if (to->type() == elfcpp::STT_COMMON)
125         tobits |= (2 << 2);
126       break;
127     }
128
129   int frombits;
130   switch (sym.get_st_bind())
131     {
132     case elfcpp::STB_GLOBAL:
133       frombits = 0;
134       break;
135
136     case elfcpp::STB_WEAK:
137       frombits = 1;
138       break;
139
140     case elfcpp::STB_LOCAL:
141       fprintf(stderr,
142               _("%s: %s: invalid STB_LOCAL symbol %s in external symbols\n"),
143               program_name, object->name().c_str(), to->name());
144       gold_exit(false);
145
146     default:
147       fprintf(stderr,
148               _("%s: %s: unsupported symbol binding %d for symbol %s\n"),
149               program_name, object->name().c_str(),
150               static_cast<int>(sym.get_st_bind()), to->name());
151       gold_exit(false);
152     }
153
154   if (object->is_dynamic())
155     {
156       frombits |= (1 << 1);
157
158       // Record that we've seen this symbol in a dynamic object.
159       to->set_in_dyn();
160     }
161
162   switch (sym.get_st_shndx())
163     {
164     case elfcpp::SHN_UNDEF:
165       frombits |= (1 << 2);
166       break;
167
168     case elfcpp::SHN_COMMON:
169       frombits |= (2 << 2);
170       break;
171
172     default:
173       if (sym.get_st_type() == elfcpp::STT_COMMON)
174         frombits |= (2 << 2);
175       break;
176     }
177
178   if ((tobits & (1 << 1)) != (frombits & (1 << 1)))
179     {
180       // This symbol is seen in both a dynamic object and a regular
181       // object.  That means that we need the symbol to go into the
182       // dynamic symbol table, so that the dynamic linker can use the
183       // regular symbol to override or define the dynamic symbol.
184       to->set_needs_dynsym_entry();
185     }
186
187   // FIXME: Warn if either but not both of TO and SYM are STT_TLS.
188
189   // We use a giant switch table for symbol resolution.  This code is
190   // unwieldy, but: 1) it is efficient; 2) we definitely handle all
191   // cases; 3) it is easy to change the handling of a particular case.
192   // The alternative would be a series of conditionals, but it is easy
193   // to get the ordering wrong.  This could also be done as a table,
194   // but that is no easier to understand than this large switch
195   // statement.
196
197   switch (tobits * 16 + frombits)
198     {
199     case DEF * 16 + DEF:
200       // Two definitions of the same symbol.
201       fprintf(stderr, "%s: %s: multiple definition of %s\n",
202               program_name, object->name().c_str(), to->name());
203       // FIXME: Report locations.  Record that we have seen an error.
204       return;
205
206     case WEAK_DEF * 16 + DEF:
207       // We've seen a weak definition, and now we see a strong
208       // definition.  In the original SVR4 linker, this was treated as
209       // a multiple definition error.  In the Solaris linker and the
210       // GNU linker, a weak definition followed by a regular
211       // definition causes the weak definition to be overridden.  We
212       // are currently compatible with the GNU linker.  In the future
213       // we should add a target specific option to change this.
214       // FIXME.
215       to->override(sym, object);
216       return;
217
218     case DYN_DEF * 16 + DEF:
219     case DYN_WEAK_DEF * 16 + DEF:
220       // We've seen a definition in a dynamic object, and now we see a
221       // definition in a regular object.  The definition in the
222       // regular object overrides the definition in the dynamic
223       // object.
224       to->override(sym, object);
225       return;
226
227     case UNDEF * 16 + DEF:
228     case WEAK_UNDEF * 16 + DEF:
229     case DYN_UNDEF * 16 + DEF:
230     case DYN_WEAK_UNDEF * 16 + DEF:
231       // We've seen an undefined reference, and now we see a
232       // definition.  We use the definition.
233       to->override(sym, object);
234       return;
235
236     case COMMON * 16 + DEF:
237     case WEAK_COMMON * 16 + DEF:
238     case DYN_COMMON * 16 + DEF:
239     case DYN_WEAK_COMMON * 16 + DEF:
240       // We've seen a common symbol and now we see a definition.  The
241       // definition overrides.  FIXME: We should optionally issue a
242       // warning.
243       to->override(sym, object);
244       return;
245
246     case DEF * 16 + WEAK_DEF:
247     case WEAK_DEF * 16 + WEAK_DEF:
248       // We've seen a definition and now we see a weak definition.  We
249       // ignore the new weak definition.
250       return;
251
252     case DYN_DEF * 16 + WEAK_DEF:
253     case DYN_WEAK_DEF * 16 + WEAK_DEF:
254       // We've seen a dynamic definition and now we see a regular weak
255       // definition.  The regular weak definition overrides.
256       to->override(sym, object);
257       return;
258
259     case UNDEF * 16 + WEAK_DEF:
260     case WEAK_UNDEF * 16 + WEAK_DEF:
261     case DYN_UNDEF * 16 + WEAK_DEF:
262     case DYN_WEAK_UNDEF * 16 + WEAK_DEF:
263       // A weak definition of a currently undefined symbol.
264       to->override(sym, object);
265       return;
266
267     case COMMON * 16 + WEAK_DEF:
268     case WEAK_COMMON * 16 + WEAK_DEF:
269       // A weak definition does not override a common definition.
270       return;
271
272     case DYN_COMMON * 16 + WEAK_DEF:
273     case DYN_WEAK_COMMON * 16 + WEAK_DEF:
274       // A weak definition does override a definition in a dynamic
275       // object.  FIXME: We should optionally issue a warning.
276       to->override(sym, object);
277       return;
278
279     case DEF * 16 + DYN_DEF:
280     case WEAK_DEF * 16 + DYN_DEF:
281     case DYN_DEF * 16 + DYN_DEF:
282     case DYN_WEAK_DEF * 16 + DYN_DEF:
283       // Ignore a dynamic definition if we already have a definition.
284       return;
285
286     case UNDEF * 16 + DYN_DEF:
287     case WEAK_UNDEF * 16 + DYN_DEF:
288     case DYN_UNDEF * 16 + DYN_DEF:
289     case DYN_WEAK_UNDEF * 16 + DYN_DEF:
290       // Use a dynamic definition if we have a reference.
291       to->override(sym, object);
292       return;
293
294     case COMMON * 16 + DYN_DEF:
295     case WEAK_COMMON * 16 + DYN_DEF:
296     case DYN_COMMON * 16 + DYN_DEF:
297     case DYN_WEAK_COMMON * 16 + DYN_DEF:
298       // Ignore a dynamic definition if we already have a common
299       // definition.
300       return;
301
302     case DEF * 16 + DYN_WEAK_DEF:
303     case WEAK_DEF * 16 + DYN_WEAK_DEF:
304     case DYN_DEF * 16 + DYN_WEAK_DEF:
305     case DYN_WEAK_DEF * 16 + DYN_WEAK_DEF:
306       // Ignore a weak dynamic definition if we already have a
307       // definition.
308       return;
309
310     case UNDEF * 16 + DYN_WEAK_DEF:
311     case WEAK_UNDEF * 16 + DYN_WEAK_DEF:
312     case DYN_UNDEF * 16 + DYN_WEAK_DEF:
313     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_DEF:
314       // Use a weak dynamic definition if we have a reference.
315       to->override(sym, object);
316       return;
317
318     case COMMON * 16 + DYN_WEAK_DEF:
319     case WEAK_COMMON * 16 + DYN_WEAK_DEF:
320     case DYN_COMMON * 16 + DYN_WEAK_DEF:
321     case DYN_WEAK_COMMON * 16 + DYN_WEAK_DEF:
322       // Ignore a weak dynamic definition if we already have a common
323       // definition.
324       return;
325
326     case DEF * 16 + UNDEF:
327     case WEAK_DEF * 16 + UNDEF:
328     case DYN_DEF * 16 + UNDEF:
329     case DYN_WEAK_DEF * 16 + UNDEF:
330     case UNDEF * 16 + UNDEF:
331       // A new undefined reference tells us nothing.
332       return;
333
334     case WEAK_UNDEF * 16 + UNDEF:
335     case DYN_UNDEF * 16 + UNDEF:
336     case DYN_WEAK_UNDEF * 16 + UNDEF:
337       // A strong undef overrides a dynamic or weak undef.
338       to->override(sym, object);
339       return;
340
341     case COMMON * 16 + UNDEF:
342     case WEAK_COMMON * 16 + UNDEF:
343     case DYN_COMMON * 16 + UNDEF:
344     case DYN_WEAK_COMMON * 16 + UNDEF:
345       // A new undefined reference tells us nothing.
346       return;
347
348     case DEF * 16 + WEAK_UNDEF:
349     case WEAK_DEF * 16 + WEAK_UNDEF:
350     case DYN_DEF * 16 + WEAK_UNDEF:
351     case DYN_WEAK_DEF * 16 + WEAK_UNDEF:
352     case UNDEF * 16 + WEAK_UNDEF:
353     case WEAK_UNDEF * 16 + WEAK_UNDEF:
354     case DYN_UNDEF * 16 + WEAK_UNDEF:
355     case DYN_WEAK_UNDEF * 16 + WEAK_UNDEF:
356     case COMMON * 16 + WEAK_UNDEF:
357     case WEAK_COMMON * 16 + WEAK_UNDEF:
358     case DYN_COMMON * 16 + WEAK_UNDEF:
359     case DYN_WEAK_COMMON * 16 + WEAK_UNDEF:
360       // A new weak undefined reference tells us nothing.
361       return;
362
363     case DEF * 16 + DYN_UNDEF:
364     case WEAK_DEF * 16 + DYN_UNDEF:
365     case DYN_DEF * 16 + DYN_UNDEF:
366     case DYN_WEAK_DEF * 16 + DYN_UNDEF:
367     case UNDEF * 16 + DYN_UNDEF:
368     case WEAK_UNDEF * 16 + DYN_UNDEF:
369     case DYN_UNDEF * 16 + DYN_UNDEF:
370     case DYN_WEAK_UNDEF * 16 + DYN_UNDEF:
371     case COMMON * 16 + DYN_UNDEF:
372     case WEAK_COMMON * 16 + DYN_UNDEF:
373     case DYN_COMMON * 16 + DYN_UNDEF:
374     case DYN_WEAK_COMMON * 16 + DYN_UNDEF:
375       // A new dynamic undefined reference tells us nothing.
376       return;
377
378     case DEF * 16 + DYN_WEAK_UNDEF:
379     case WEAK_DEF * 16 + DYN_WEAK_UNDEF:
380     case DYN_DEF * 16 + DYN_WEAK_UNDEF:
381     case DYN_WEAK_DEF * 16 + DYN_WEAK_UNDEF:
382     case UNDEF * 16 + DYN_WEAK_UNDEF:
383     case WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
384     case DYN_UNDEF * 16 + DYN_WEAK_UNDEF:
385     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
386     case COMMON * 16 + DYN_WEAK_UNDEF:
387     case WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
388     case DYN_COMMON * 16 + DYN_WEAK_UNDEF:
389     case DYN_WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
390       // A new weak dynamic undefined reference tells us nothing.
391       return;
392
393     case DEF * 16 + COMMON:
394       // A common symbol does not override a definition.
395       return;
396
397     case WEAK_DEF * 16 + COMMON:
398     case DYN_DEF * 16 + COMMON:
399     case DYN_WEAK_DEF * 16 + COMMON:
400       // A common symbol does override a weak definition or a dynamic
401       // definition.
402       to->override(sym, object);
403       return;
404
405     case UNDEF * 16 + COMMON:
406     case WEAK_UNDEF * 16 + COMMON:
407     case DYN_UNDEF * 16 + COMMON:
408     case DYN_WEAK_UNDEF * 16 + COMMON:
409       // A common symbol is a definition for a reference.
410       to->override(sym, object);
411       return;
412
413     case COMMON * 16 + COMMON:
414       // Set the size to the maximum.
415       if (sym.get_st_size() > to->symsize())
416         to->set_symsize(sym.get_st_size());
417       return;
418
419     case WEAK_COMMON * 16 + COMMON:
420       // I'm not sure just what a weak common symbol means, but
421       // presumably it can be overridden by a regular common symbol.
422       to->override(sym, object);
423       return;
424
425     case DYN_COMMON * 16 + COMMON:
426     case DYN_WEAK_COMMON * 16 + COMMON:
427       {
428         // Use the real common symbol, but adjust the size if necessary.
429         typename Sized_symbol<size>::Size_type symsize = to->symsize();
430         to->override(sym, object);
431         if (to->symsize() < symsize)
432           to->set_symsize(symsize);
433       }
434       return;
435
436     case DEF * 16 + WEAK_COMMON:
437     case WEAK_DEF * 16 + WEAK_COMMON:
438     case DYN_DEF * 16 + WEAK_COMMON:
439     case DYN_WEAK_DEF * 16 + WEAK_COMMON:
440       // Whatever a weak common symbol is, it won't override a
441       // definition.
442       return;
443
444     case UNDEF * 16 + WEAK_COMMON:
445     case WEAK_UNDEF * 16 + WEAK_COMMON:
446     case DYN_UNDEF * 16 + WEAK_COMMON:
447     case DYN_WEAK_UNDEF * 16 + WEAK_COMMON:
448       // A weak common symbol is better than an undefined symbol.
449       to->override(sym, object);
450       return;
451
452     case COMMON * 16 + WEAK_COMMON:
453     case WEAK_COMMON * 16 + WEAK_COMMON:
454     case DYN_COMMON * 16 + WEAK_COMMON:
455     case DYN_WEAK_COMMON * 16 + WEAK_COMMON:
456       // Ignore a weak common symbol in the presence of a real common
457       // symbol.
458       return;
459
460     case DEF * 16 + DYN_COMMON:
461     case WEAK_DEF * 16 + DYN_COMMON:
462     case DYN_DEF * 16 + DYN_COMMON:
463     case DYN_WEAK_DEF * 16 + DYN_COMMON:
464       // Ignore a dynamic common symbol in the presence of a
465       // definition.
466       return;
467
468     case UNDEF * 16 + DYN_COMMON:
469     case WEAK_UNDEF * 16 + DYN_COMMON:
470     case DYN_UNDEF * 16 + DYN_COMMON:
471     case DYN_WEAK_UNDEF * 16 + DYN_COMMON:
472       // A dynamic common symbol is a definition of sorts.
473       to->override(sym, object);
474       return;
475
476     case COMMON * 16 + DYN_COMMON:
477     case WEAK_COMMON * 16 + DYN_COMMON:
478     case DYN_COMMON * 16 + DYN_COMMON:
479     case DYN_WEAK_COMMON * 16 + DYN_COMMON:
480       // Set the size to the maximum.
481       if (sym.get_st_size() > to->symsize())
482         to->set_symsize(sym.get_st_size());
483       return;
484
485     case DEF * 16 + DYN_WEAK_COMMON:
486     case WEAK_DEF * 16 + DYN_WEAK_COMMON:
487     case DYN_DEF * 16 + DYN_WEAK_COMMON:
488     case DYN_WEAK_DEF * 16 + DYN_WEAK_COMMON:
489       // A common symbol is ignored in the face of a definition.
490       return;
491
492     case UNDEF * 16 + DYN_WEAK_COMMON:
493     case WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
494     case DYN_UNDEF * 16 + DYN_WEAK_COMMON:
495     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
496       // I guess a weak common symbol is better than a definition.
497       to->override(sym, object);
498       return;
499
500     case COMMON * 16 + DYN_WEAK_COMMON:
501     case WEAK_COMMON * 16 + DYN_WEAK_COMMON:
502     case DYN_COMMON * 16 + DYN_WEAK_COMMON:
503     case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON:
504       // Set the size to the maximum.
505       if (sym.get_st_size() > to->symsize())
506         to->set_symsize(sym.get_st_size());
507       return;
508
509     default:
510       gold_unreachable();
511     }
512 }
513
514 // Instantiate the templates we need.  We could use the configure
515 // script to restrict this to only the ones needed for implemented
516 // targets.
517
518 template
519 void
520 Symbol_table::resolve<32, true>(
521     Sized_symbol<32>* to,
522     const elfcpp::Sym<32, true>& sym,
523     Object* object);
524
525 template
526 void
527 Symbol_table::resolve<32, false>(
528     Sized_symbol<32>* to,
529     const elfcpp::Sym<32, false>& sym,
530     Object* object);
531
532 template
533 void
534 Symbol_table::resolve<64, true>(
535     Sized_symbol<64>* to,
536     const elfcpp::Sym<64, true>& sym,
537     Object* object);
538
539 template
540 void
541 Symbol_table::resolve<64, false>(
542     Sized_symbol<64>* to,
543     const elfcpp::Sym<64, false>& sym,
544     Object* object);
545
546 } // End namespace gold.