OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [resolve.cc] - Blame information for rev 98

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 27 khays
// resolve.cc -- symbol resolution for gold
2
 
3
// Copyright 2006, 2007, 2008, 2009, 2010 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
#include "plugin.h"
30
 
31
namespace gold
32
{
33
 
34
// Symbol methods used in this file.
35
 
36
// This symbol is being overridden by another symbol whose version is
37
// VERSION.  Update the VERSION_ field accordingly.
38
 
39
inline void
40
Symbol::override_version(const char* version)
41
{
42
  if (version == NULL)
43
    {
44
      // This is the case where this symbol is NAME/VERSION, and the
45
      // version was not marked as hidden.  That makes it the default
46
      // version, so we create NAME/NULL.  Later we see another symbol
47
      // NAME/NULL, and that symbol is overriding this one.  In this
48
      // case, since NAME/VERSION is the default, we make NAME/NULL
49
      // override NAME/VERSION as well.  They are already the same
50
      // Symbol structure.  Setting the VERSION_ field to NULL ensures
51
      // that it will be output with the correct, empty, version.
52
      this->version_ = version;
53
    }
54
  else
55
    {
56
      // This is the case where this symbol is NAME/VERSION_ONE, and
57
      // now we see NAME/VERSION_TWO, and NAME/VERSION_TWO is
58
      // overriding NAME.  If VERSION_ONE and VERSION_TWO are
59
      // different, then this can only happen when VERSION_ONE is NULL
60
      // and VERSION_TWO is not hidden.
61
      gold_assert(this->version_ == version || this->version_ == NULL);
62
      this->version_ = version;
63
    }
64
}
65
 
66
// This symbol is being overidden by another symbol whose visibility
67
// is VISIBILITY.  Updated the VISIBILITY_ field accordingly.
68
 
69
inline void
70
Symbol::override_visibility(elfcpp::STV visibility)
71
{
72
  // The rule for combining visibility is that we always choose the
73
  // most constrained visibility.  In order of increasing constraint,
74
  // visibility goes PROTECTED, HIDDEN, INTERNAL.  This is the reverse
75
  // of the numeric values, so the effect is that we always want the
76
  // smallest non-zero value.
77
  if (visibility != elfcpp::STV_DEFAULT)
78
    {
79
      if (this->visibility_ == elfcpp::STV_DEFAULT)
80
        this->visibility_ = visibility;
81
      else if (this->visibility_ > visibility)
82
        this->visibility_ = visibility;
83
    }
84
}
85
 
86
// Override the fields in Symbol.
87
 
88
template<int size, bool big_endian>
89
void
90
Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym,
91
                      unsigned int st_shndx, bool is_ordinary,
92
                      Object* object, const char* version)
93
{
94
  gold_assert(this->source_ == FROM_OBJECT);
95
  this->u_.from_object.object = object;
96
  this->override_version(version);
97
  this->u_.from_object.shndx = st_shndx;
98
  this->is_ordinary_shndx_ = is_ordinary;
99
  this->type_ = sym.get_st_type();
100
  this->binding_ = sym.get_st_bind();
101
  this->override_visibility(sym.get_st_visibility());
102
  this->nonvis_ = sym.get_st_nonvis();
103
  if (object->is_dynamic())
104
    this->in_dyn_ = true;
105
  else
106
    this->in_reg_ = true;
107
}
108
 
109
// Override the fields in Sized_symbol.
110
 
111
template<int size>
112
template<bool big_endian>
113
void
114
Sized_symbol<size>::override(const elfcpp::Sym<size, big_endian>& sym,
115
                             unsigned st_shndx, bool is_ordinary,
116
                             Object* object, const char* version)
117
{
118
  this->override_base(sym, st_shndx, is_ordinary, object, version);
119
  this->value_ = sym.get_st_value();
120
  this->symsize_ = sym.get_st_size();
121
}
122
 
123
// Override TOSYM with symbol FROMSYM, defined in OBJECT, with version
124
// VERSION.  This handles all aliases of TOSYM.
125
 
126
template<int size, bool big_endian>
127
void
128
Symbol_table::override(Sized_symbol<size>* tosym,
129
                       const elfcpp::Sym<size, big_endian>& fromsym,
130
                       unsigned int st_shndx, bool is_ordinary,
131
                       Object* object, const char* version)
132
{
133
  tosym->override(fromsym, st_shndx, is_ordinary, object, version);
134
  if (tosym->has_alias())
135
    {
136
      Symbol* sym = this->weak_aliases_[tosym];
137
      gold_assert(sym != NULL);
138
      Sized_symbol<size>* ssym = this->get_sized_symbol<size>(sym);
139
      do
140
        {
141
          ssym->override(fromsym, st_shndx, is_ordinary, object, version);
142
          sym = this->weak_aliases_[ssym];
143
          gold_assert(sym != NULL);
144
          ssym = this->get_sized_symbol<size>(sym);
145
        }
146
      while (ssym != tosym);
147
    }
148
}
149
 
150
// The resolve functions build a little code for each symbol.
151
// Bit 0: 0 for global, 1 for weak.
152
// Bit 1: 0 for regular object, 1 for shared object
153
// Bits 2-3: 0 for normal, 1 for undefined, 2 for common
154
// This gives us values from 0 to 11.
155
 
156
static const int global_or_weak_shift = 0;
157
static const unsigned int global_flag = 0 << global_or_weak_shift;
158
static const unsigned int weak_flag = 1 << global_or_weak_shift;
159
 
160
static const int regular_or_dynamic_shift = 1;
161
static const unsigned int regular_flag = 0 << regular_or_dynamic_shift;
162
static const unsigned int dynamic_flag = 1 << regular_or_dynamic_shift;
163
 
164
static const int def_undef_or_common_shift = 2;
165
static const unsigned int def_flag = 0 << def_undef_or_common_shift;
166
static const unsigned int undef_flag = 1 << def_undef_or_common_shift;
167
static const unsigned int common_flag = 2 << def_undef_or_common_shift;
168
 
169
// This convenience function combines all the flags based on facts
170
// about the symbol.
171
 
172
static unsigned int
173
symbol_to_bits(elfcpp::STB binding, bool is_dynamic,
174
               unsigned int shndx, bool is_ordinary, elfcpp::STT type)
175
{
176
  unsigned int bits;
177
 
178
  switch (binding)
179
    {
180
    case elfcpp::STB_GLOBAL:
181
    case elfcpp::STB_GNU_UNIQUE:
182
      bits = global_flag;
183
      break;
184
 
185
    case elfcpp::STB_WEAK:
186
      bits = weak_flag;
187
      break;
188
 
189
    case elfcpp::STB_LOCAL:
190
      // We should only see externally visible symbols in the symbol
191
      // table.
192
      gold_error(_("invalid STB_LOCAL symbol in external symbols"));
193
      bits = global_flag;
194
 
195
    default:
196
      // Any target which wants to handle STB_LOOS, etc., needs to
197
      // define a resolve method.
198
      gold_error(_("unsupported symbol binding %d"), static_cast<int>(binding));
199
      bits = global_flag;
200
    }
201
 
202
  if (is_dynamic)
203
    bits |= dynamic_flag;
204
  else
205
    bits |= regular_flag;
206
 
207
  switch (shndx)
208
    {
209
    case elfcpp::SHN_UNDEF:
210
      bits |= undef_flag;
211
      break;
212
 
213
    case elfcpp::SHN_COMMON:
214
      if (!is_ordinary)
215
        bits |= common_flag;
216
      break;
217
 
218
    default:
219
      if (type == elfcpp::STT_COMMON)
220
        bits |= common_flag;
221
      else if (!is_ordinary && Symbol::is_common_shndx(shndx))
222
        bits |= common_flag;
223
      else
224
        bits |= def_flag;
225
      break;
226
    }
227
 
228
  return bits;
229
}
230
 
231
// Resolve a symbol.  This is called the second and subsequent times
232
// we see a symbol.  TO is the pre-existing symbol.  ST_SHNDX is the
233
// section index for SYM, possibly adjusted for many sections.
234
// IS_ORDINARY is whether ST_SHNDX is a normal section index rather
235
// than a special code.  ORIG_ST_SHNDX is the original section index,
236
// before any munging because of discarded sections, except that all
237
// non-ordinary section indexes are mapped to SHN_UNDEF.  VERSION is
238
// the version of SYM.
239
 
240
template<int size, bool big_endian>
241
void
242
Symbol_table::resolve(Sized_symbol<size>* to,
243
                      const elfcpp::Sym<size, big_endian>& sym,
244
                      unsigned int st_shndx, bool is_ordinary,
245
                      unsigned int orig_st_shndx,
246
                      Object* object, const char* version)
247
{
248
  if (parameters->target().has_resolve())
249
    {
250
      Sized_target<size, big_endian>* sized_target;
251
      sized_target = parameters->sized_target<size, big_endian>();
252
      sized_target->resolve(to, sym, object, version);
253
      return;
254
    }
255
 
256
  if (!object->is_dynamic())
257
    {
258
      // Record that we've seen this symbol in a regular object.
259
      to->set_in_reg();
260
    }
261
  else if (st_shndx == elfcpp::SHN_UNDEF
262
           && (to->visibility() == elfcpp::STV_HIDDEN
263
               || to->visibility() == elfcpp::STV_INTERNAL))
264
    {
265
      // A dynamic object cannot reference a hidden or internal symbol
266
      // defined in another object.
267
      gold_warning(_("%s symbol '%s' in %s is referenced by DSO %s"),
268
                   (to->visibility() == elfcpp::STV_HIDDEN
269
                    ? "hidden"
270
                    : "internal"),
271
                   to->demangled_name().c_str(),
272
                   to->object()->name().c_str(),
273
                   object->name().c_str());
274
      return;
275
    }
276
  else
277
    {
278
      // Record that we've seen this symbol in a dynamic object.
279
      to->set_in_dyn();
280
    }
281
 
282
  // Record if we've seen this symbol in a real ELF object (i.e., the
283
  // symbol is referenced from outside the world known to the plugin).
284
  if (object->pluginobj() == NULL)
285
    to->set_in_real_elf();
286
 
287
  // If we're processing replacement files, allow new symbols to override
288
  // the placeholders from the plugin objects.
289
  if (to->source() == Symbol::FROM_OBJECT)
290
    {
291
      Pluginobj* obj = to->object()->pluginobj();
292
      if (obj != NULL
293
          && parameters->options().plugins()->in_replacement_phase())
294
        {
295
          this->override(to, sym, st_shndx, is_ordinary, object, version);
296
          return;
297
        }
298
    }
299
 
300
  // A new weak undefined reference, merging with an old weak
301
  // reference, could be a One Definition Rule (ODR) violation --
302
  // especially if the types or sizes of the references differ.  We'll
303
  // store such pairs and look them up later to make sure they
304
  // actually refer to the same lines of code.  We also check
305
  // combinations of weak and strong, which might occur if one case is
306
  // inline and the other is not.  (Note: not all ODR violations can
307
  // be found this way, and not everything this finds is an ODR
308
  // violation.  But it's helpful to warn about.)
309
  bool to_is_ordinary;
310
  if (parameters->options().detect_odr_violations()
311
      && (sym.get_st_bind() == elfcpp::STB_WEAK
312
          || to->binding() == elfcpp::STB_WEAK)
313
      && orig_st_shndx != elfcpp::SHN_UNDEF
314
      && to->shndx(&to_is_ordinary) != elfcpp::SHN_UNDEF
315
      && to_is_ordinary
316
      && sym.get_st_size() != 0    // Ignore weird 0-sized symbols.
317
      && to->symsize() != 0
318
      && (sym.get_st_type() != to->type()
319
          || sym.get_st_size() != to->symsize())
320
      // C does not have a concept of ODR, so we only need to do this
321
      // on C++ symbols.  These have (mangled) names starting with _Z.
322
      && to->name()[0] == '_' && to->name()[1] == 'Z')
323
    {
324
      Symbol_location fromloc
325
          = { object, orig_st_shndx, sym.get_st_value() };
326
      Symbol_location toloc = { to->object(), to->shndx(&to_is_ordinary),
327
                                to->value() };
328
      this->candidate_odr_violations_[to->name()].insert(fromloc);
329
      this->candidate_odr_violations_[to->name()].insert(toloc);
330
    }
331
 
332
  unsigned int frombits = symbol_to_bits(sym.get_st_bind(),
333
                                         object->is_dynamic(),
334
                                         st_shndx, is_ordinary,
335
                                         sym.get_st_type());
336
 
337
  bool adjust_common_sizes;
338
  bool adjust_dyndef;
339
  typename Sized_symbol<size>::Size_type tosize = to->symsize();
340
  if (Symbol_table::should_override(to, frombits, OBJECT, object,
341
                                    &adjust_common_sizes,
342
                                    &adjust_dyndef))
343
    {
344
      elfcpp::STB tobinding = to->binding();
345
      this->override(to, sym, st_shndx, is_ordinary, object, version);
346
      if (adjust_common_sizes && tosize > to->symsize())
347
        to->set_symsize(tosize);
348
      if (adjust_dyndef)
349
        {
350
          // We are overriding an UNDEF or WEAK UNDEF with a DYN DEF.
351
          // Remember which kind of UNDEF it was for future reference.
352
          to->set_undef_binding(tobinding);
353
        }
354
    }
355
  else
356
    {
357
      if (adjust_common_sizes && sym.get_st_size() > tosize)
358
        to->set_symsize(sym.get_st_size());
359
      if (adjust_dyndef)
360
        {
361
          // We are keeping a DYN DEF after seeing an UNDEF or WEAK UNDEF.
362
          // Remember which kind of UNDEF it was.
363
          to->set_undef_binding(sym.get_st_bind());
364
        }
365
      // The ELF ABI says that even for a reference to a symbol we
366
      // merge the visibility.
367
      to->override_visibility(sym.get_st_visibility());
368
    }
369
 
370
  if (adjust_common_sizes && parameters->options().warn_common())
371
    {
372
      if (tosize > sym.get_st_size())
373
        Symbol_table::report_resolve_problem(false,
374
                                             _("common of '%s' overriding "
375
                                               "smaller common"),
376
                                             to, OBJECT, object);
377
      else if (tosize < sym.get_st_size())
378
        Symbol_table::report_resolve_problem(false,
379
                                             _("common of '%s' overidden by "
380
                                               "larger common"),
381
                                             to, OBJECT, object);
382
      else
383
        Symbol_table::report_resolve_problem(false,
384
                                             _("multiple common of '%s'"),
385
                                             to, OBJECT, object);
386
    }
387
}
388
 
389
// Handle the core of symbol resolution.  This is called with the
390
// existing symbol, TO, and a bitflag describing the new symbol.  This
391
// returns true if we should override the existing symbol with the new
392
// one, and returns false otherwise.  It sets *ADJUST_COMMON_SIZES to
393
// true if we should set the symbol size to the maximum of the TO and
394
// FROM sizes.  It handles error conditions.
395
 
396
bool
397
Symbol_table::should_override(const Symbol* to, unsigned int frombits,
398
                              Defined defined, Object* object,
399
                              bool* adjust_common_sizes,
400
                              bool* adjust_dyndef)
401
{
402
  *adjust_common_sizes = false;
403
  *adjust_dyndef = false;
404
 
405
  unsigned int tobits;
406
  if (to->source() == Symbol::IS_UNDEFINED)
407
    tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_UNDEF, true,
408
                            to->type());
409
  else if (to->source() != Symbol::FROM_OBJECT)
410
    tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_ABS, false,
411
                            to->type());
412
  else
413
    {
414
      bool is_ordinary;
415
      unsigned int shndx = to->shndx(&is_ordinary);
416
      tobits = symbol_to_bits(to->binding(),
417
                              to->object()->is_dynamic(),
418
                              shndx,
419
                              is_ordinary,
420
                              to->type());
421
    }
422
 
423
  // FIXME: Warn if either but not both of TO and SYM are STT_TLS.
424
 
425
  // We use a giant switch table for symbol resolution.  This code is
426
  // unwieldy, but: 1) it is efficient; 2) we definitely handle all
427
  // cases; 3) it is easy to change the handling of a particular case.
428
  // The alternative would be a series of conditionals, but it is easy
429
  // to get the ordering wrong.  This could also be done as a table,
430
  // but that is no easier to understand than this large switch
431
  // statement.
432
 
433
  // These are the values generated by the bit codes.
434
  enum
435
  {
436
    DEF =              global_flag | regular_flag | def_flag,
437
    WEAK_DEF =         weak_flag   | regular_flag | def_flag,
438
    DYN_DEF =          global_flag | dynamic_flag | def_flag,
439
    DYN_WEAK_DEF =     weak_flag   | dynamic_flag | def_flag,
440
    UNDEF =            global_flag | regular_flag | undef_flag,
441
    WEAK_UNDEF =       weak_flag   | regular_flag | undef_flag,
442
    DYN_UNDEF =        global_flag | dynamic_flag | undef_flag,
443
    DYN_WEAK_UNDEF =   weak_flag   | dynamic_flag | undef_flag,
444
    COMMON =           global_flag | regular_flag | common_flag,
445
    WEAK_COMMON =      weak_flag   | regular_flag | common_flag,
446
    DYN_COMMON =       global_flag | dynamic_flag | common_flag,
447
    DYN_WEAK_COMMON =  weak_flag   | dynamic_flag | common_flag
448
  };
449
 
450
  switch (tobits * 16 + frombits)
451
    {
452
    case DEF * 16 + DEF:
453
      // Two definitions of the same symbol.
454
 
455
      // If either symbol is defined by an object included using
456
      // --just-symbols, then don't warn.  This is for compatibility
457
      // with the GNU linker.  FIXME: This is a hack.
458
      if ((to->source() == Symbol::FROM_OBJECT && to->object()->just_symbols())
459
          || (object != NULL && object->just_symbols()))
460
        return false;
461
 
462
      if (!parameters->options().muldefs())
463
        Symbol_table::report_resolve_problem(true,
464
                                             _("multiple definition of '%s'"),
465
                                             to, defined, object);
466
      return false;
467
 
468
    case WEAK_DEF * 16 + DEF:
469
      // We've seen a weak definition, and now we see a strong
470
      // definition.  In the original SVR4 linker, this was treated as
471
      // a multiple definition error.  In the Solaris linker and the
472
      // GNU linker, a weak definition followed by a regular
473
      // definition causes the weak definition to be overridden.  We
474
      // are currently compatible with the GNU linker.  In the future
475
      // we should add a target specific option to change this.
476
      // FIXME.
477
      return true;
478
 
479
    case DYN_DEF * 16 + DEF:
480
    case DYN_WEAK_DEF * 16 + DEF:
481
      // We've seen a definition in a dynamic object, and now we see a
482
      // definition in a regular object.  The definition in the
483
      // regular object overrides the definition in the dynamic
484
      // object.
485
      return true;
486
 
487
    case UNDEF * 16 + DEF:
488
    case WEAK_UNDEF * 16 + DEF:
489
    case DYN_UNDEF * 16 + DEF:
490
    case DYN_WEAK_UNDEF * 16 + DEF:
491
      // We've seen an undefined reference, and now we see a
492
      // definition.  We use the definition.
493
      return true;
494
 
495
    case COMMON * 16 + DEF:
496
    case WEAK_COMMON * 16 + DEF:
497
    case DYN_COMMON * 16 + DEF:
498
    case DYN_WEAK_COMMON * 16 + DEF:
499
      // We've seen a common symbol and now we see a definition.  The
500
      // definition overrides.
501
      if (parameters->options().warn_common())
502
        Symbol_table::report_resolve_problem(false,
503
                                             _("definition of '%s' overriding "
504
                                               "common"),
505
                                             to, defined, object);
506
      return true;
507
 
508
    case DEF * 16 + WEAK_DEF:
509
    case WEAK_DEF * 16 + WEAK_DEF:
510
      // We've seen a definition and now we see a weak definition.  We
511
      // ignore the new weak definition.
512
      return false;
513
 
514
    case DYN_DEF * 16 + WEAK_DEF:
515
    case DYN_WEAK_DEF * 16 + WEAK_DEF:
516
      // We've seen a dynamic definition and now we see a regular weak
517
      // definition.  The regular weak definition overrides.
518
      return true;
519
 
520
    case UNDEF * 16 + WEAK_DEF:
521
    case WEAK_UNDEF * 16 + WEAK_DEF:
522
    case DYN_UNDEF * 16 + WEAK_DEF:
523
    case DYN_WEAK_UNDEF * 16 + WEAK_DEF:
524
      // A weak definition of a currently undefined symbol.
525
      return true;
526
 
527
    case COMMON * 16 + WEAK_DEF:
528
    case WEAK_COMMON * 16 + WEAK_DEF:
529
      // A weak definition does not override a common definition.
530
      return false;
531
 
532
    case DYN_COMMON * 16 + WEAK_DEF:
533
    case DYN_WEAK_COMMON * 16 + WEAK_DEF:
534
      // A weak definition does override a definition in a dynamic
535
      // object.
536
      if (parameters->options().warn_common())
537
        Symbol_table::report_resolve_problem(false,
538
                                             _("definition of '%s' overriding "
539
                                               "dynamic common definition"),
540
                                             to, defined, object);
541
      return true;
542
 
543
    case DEF * 16 + DYN_DEF:
544
    case WEAK_DEF * 16 + DYN_DEF:
545
    case DYN_DEF * 16 + DYN_DEF:
546
    case DYN_WEAK_DEF * 16 + DYN_DEF:
547
      // Ignore a dynamic definition if we already have a definition.
548
      return false;
549
 
550
    case UNDEF * 16 + DYN_DEF:
551
    case DYN_UNDEF * 16 + DYN_DEF:
552
    case DYN_WEAK_UNDEF * 16 + DYN_DEF:
553
      // Use a dynamic definition if we have a reference.
554
      return true;
555
 
556
    case WEAK_UNDEF * 16 + DYN_DEF:
557
      // When overriding a weak undef by a dynamic definition,
558
      // we need to remember that the original undef was weak.
559
      *adjust_dyndef = true;
560
      return true;
561
 
562
    case COMMON * 16 + DYN_DEF:
563
    case WEAK_COMMON * 16 + DYN_DEF:
564
    case DYN_COMMON * 16 + DYN_DEF:
565
    case DYN_WEAK_COMMON * 16 + DYN_DEF:
566
      // Ignore a dynamic definition if we already have a common
567
      // definition.
568
      return false;
569
 
570
    case DEF * 16 + DYN_WEAK_DEF:
571
    case WEAK_DEF * 16 + DYN_WEAK_DEF:
572
    case DYN_DEF * 16 + DYN_WEAK_DEF:
573
    case DYN_WEAK_DEF * 16 + DYN_WEAK_DEF:
574
      // Ignore a weak dynamic definition if we already have a
575
      // definition.
576
      return false;
577
 
578
    case UNDEF * 16 + DYN_WEAK_DEF:
579
      // When overriding an undef by a dynamic weak definition,
580
      // we need to remember that the original undef was not weak.
581
      *adjust_dyndef = true;
582
      return true;
583
 
584
    case DYN_UNDEF * 16 + DYN_WEAK_DEF:
585
    case DYN_WEAK_UNDEF * 16 + DYN_WEAK_DEF:
586
      // Use a weak dynamic definition if we have a reference.
587
      return true;
588
 
589
    case WEAK_UNDEF * 16 + DYN_WEAK_DEF:
590
      // When overriding a weak undef by a dynamic definition,
591
      // we need to remember that the original undef was weak.
592
      *adjust_dyndef = true;
593
      return true;
594
 
595
    case COMMON * 16 + DYN_WEAK_DEF:
596
    case WEAK_COMMON * 16 + DYN_WEAK_DEF:
597
    case DYN_COMMON * 16 + DYN_WEAK_DEF:
598
    case DYN_WEAK_COMMON * 16 + DYN_WEAK_DEF:
599
      // Ignore a weak dynamic definition if we already have a common
600
      // definition.
601
      return false;
602
 
603
    case DEF * 16 + UNDEF:
604
    case WEAK_DEF * 16 + UNDEF:
605
    case UNDEF * 16 + UNDEF:
606
      // A new undefined reference tells us nothing.
607
      return false;
608
 
609
    case DYN_DEF * 16 + UNDEF:
610
    case DYN_WEAK_DEF * 16 + UNDEF:
611
      // For a dynamic def, we need to remember which kind of undef we see.
612
      *adjust_dyndef = true;
613
      return false;
614
 
615
    case WEAK_UNDEF * 16 + UNDEF:
616
    case DYN_UNDEF * 16 + UNDEF:
617
    case DYN_WEAK_UNDEF * 16 + UNDEF:
618
      // A strong undef overrides a dynamic or weak undef.
619
      return true;
620
 
621
    case COMMON * 16 + UNDEF:
622
    case WEAK_COMMON * 16 + UNDEF:
623
    case DYN_COMMON * 16 + UNDEF:
624
    case DYN_WEAK_COMMON * 16 + UNDEF:
625
      // A new undefined reference tells us nothing.
626
      return false;
627
 
628
    case DEF * 16 + WEAK_UNDEF:
629
    case WEAK_DEF * 16 + WEAK_UNDEF:
630
    case UNDEF * 16 + WEAK_UNDEF:
631
    case WEAK_UNDEF * 16 + WEAK_UNDEF:
632
    case DYN_UNDEF * 16 + WEAK_UNDEF:
633
    case COMMON * 16 + WEAK_UNDEF:
634
    case WEAK_COMMON * 16 + WEAK_UNDEF:
635
    case DYN_COMMON * 16 + WEAK_UNDEF:
636
    case DYN_WEAK_COMMON * 16 + WEAK_UNDEF:
637
      // A new weak undefined reference tells us nothing unless the
638
      // exisiting symbol is a dynamic weak reference.
639
      return false;
640
 
641
    case DYN_WEAK_UNDEF * 16 + WEAK_UNDEF:
642
      // A new weak reference overrides an existing dynamic weak reference.
643
      // This is necessary because a dynamic weak reference remembers
644
      // the old binding, which may not be weak.  If we keeps the existing
645
      // dynamic weak reference, the weakness may be dropped in the output.
646
      return true;
647
 
648
    case DYN_DEF * 16 + WEAK_UNDEF:
649
    case DYN_WEAK_DEF * 16 + WEAK_UNDEF:
650
      // For a dynamic def, we need to remember which kind of undef we see.
651
      *adjust_dyndef = true;
652
      return false;
653
 
654
    case DEF * 16 + DYN_UNDEF:
655
    case WEAK_DEF * 16 + DYN_UNDEF:
656
    case DYN_DEF * 16 + DYN_UNDEF:
657
    case DYN_WEAK_DEF * 16 + DYN_UNDEF:
658
    case UNDEF * 16 + DYN_UNDEF:
659
    case WEAK_UNDEF * 16 + DYN_UNDEF:
660
    case DYN_UNDEF * 16 + DYN_UNDEF:
661
    case DYN_WEAK_UNDEF * 16 + DYN_UNDEF:
662
    case COMMON * 16 + DYN_UNDEF:
663
    case WEAK_COMMON * 16 + DYN_UNDEF:
664
    case DYN_COMMON * 16 + DYN_UNDEF:
665
    case DYN_WEAK_COMMON * 16 + DYN_UNDEF:
666
      // A new dynamic undefined reference tells us nothing.
667
      return false;
668
 
669
    case DEF * 16 + DYN_WEAK_UNDEF:
670
    case WEAK_DEF * 16 + DYN_WEAK_UNDEF:
671
    case DYN_DEF * 16 + DYN_WEAK_UNDEF:
672
    case DYN_WEAK_DEF * 16 + DYN_WEAK_UNDEF:
673
    case UNDEF * 16 + DYN_WEAK_UNDEF:
674
    case WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
675
    case DYN_UNDEF * 16 + DYN_WEAK_UNDEF:
676
    case DYN_WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
677
    case COMMON * 16 + DYN_WEAK_UNDEF:
678
    case WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
679
    case DYN_COMMON * 16 + DYN_WEAK_UNDEF:
680
    case DYN_WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
681
      // A new weak dynamic undefined reference tells us nothing.
682
      return false;
683
 
684
    case DEF * 16 + COMMON:
685
      // A common symbol does not override a definition.
686
      if (parameters->options().warn_common())
687
        Symbol_table::report_resolve_problem(false,
688
                                             _("common '%s' overridden by "
689
                                               "previous definition"),
690
                                             to, defined, object);
691
      return false;
692
 
693
    case WEAK_DEF * 16 + COMMON:
694
    case DYN_DEF * 16 + COMMON:
695
    case DYN_WEAK_DEF * 16 + COMMON:
696
      // A common symbol does override a weak definition or a dynamic
697
      // definition.
698
      return true;
699
 
700
    case UNDEF * 16 + COMMON:
701
    case WEAK_UNDEF * 16 + COMMON:
702
    case DYN_UNDEF * 16 + COMMON:
703
    case DYN_WEAK_UNDEF * 16 + COMMON:
704
      // A common symbol is a definition for a reference.
705
      return true;
706
 
707
    case COMMON * 16 + COMMON:
708
      // Set the size to the maximum.
709
      *adjust_common_sizes = true;
710
      return false;
711
 
712
    case WEAK_COMMON * 16 + COMMON:
713
      // I'm not sure just what a weak common symbol means, but
714
      // presumably it can be overridden by a regular common symbol.
715
      return true;
716
 
717
    case DYN_COMMON * 16 + COMMON:
718
    case DYN_WEAK_COMMON * 16 + COMMON:
719
      // Use the real common symbol, but adjust the size if necessary.
720
      *adjust_common_sizes = true;
721
      return true;
722
 
723
    case DEF * 16 + WEAK_COMMON:
724
    case WEAK_DEF * 16 + WEAK_COMMON:
725
    case DYN_DEF * 16 + WEAK_COMMON:
726
    case DYN_WEAK_DEF * 16 + WEAK_COMMON:
727
      // Whatever a weak common symbol is, it won't override a
728
      // definition.
729
      return false;
730
 
731
    case UNDEF * 16 + WEAK_COMMON:
732
    case WEAK_UNDEF * 16 + WEAK_COMMON:
733
    case DYN_UNDEF * 16 + WEAK_COMMON:
734
    case DYN_WEAK_UNDEF * 16 + WEAK_COMMON:
735
      // A weak common symbol is better than an undefined symbol.
736
      return true;
737
 
738
    case COMMON * 16 + WEAK_COMMON:
739
    case WEAK_COMMON * 16 + WEAK_COMMON:
740
    case DYN_COMMON * 16 + WEAK_COMMON:
741
    case DYN_WEAK_COMMON * 16 + WEAK_COMMON:
742
      // Ignore a weak common symbol in the presence of a real common
743
      // symbol.
744
      return false;
745
 
746
    case DEF * 16 + DYN_COMMON:
747
    case WEAK_DEF * 16 + DYN_COMMON:
748
    case DYN_DEF * 16 + DYN_COMMON:
749
    case DYN_WEAK_DEF * 16 + DYN_COMMON:
750
      // Ignore a dynamic common symbol in the presence of a
751
      // definition.
752
      return false;
753
 
754
    case UNDEF * 16 + DYN_COMMON:
755
    case WEAK_UNDEF * 16 + DYN_COMMON:
756
    case DYN_UNDEF * 16 + DYN_COMMON:
757
    case DYN_WEAK_UNDEF * 16 + DYN_COMMON:
758
      // A dynamic common symbol is a definition of sorts.
759
      return true;
760
 
761
    case COMMON * 16 + DYN_COMMON:
762
    case WEAK_COMMON * 16 + DYN_COMMON:
763
    case DYN_COMMON * 16 + DYN_COMMON:
764
    case DYN_WEAK_COMMON * 16 + DYN_COMMON:
765
      // Set the size to the maximum.
766
      *adjust_common_sizes = true;
767
      return false;
768
 
769
    case DEF * 16 + DYN_WEAK_COMMON:
770
    case WEAK_DEF * 16 + DYN_WEAK_COMMON:
771
    case DYN_DEF * 16 + DYN_WEAK_COMMON:
772
    case DYN_WEAK_DEF * 16 + DYN_WEAK_COMMON:
773
      // A common symbol is ignored in the face of a definition.
774
      return false;
775
 
776
    case UNDEF * 16 + DYN_WEAK_COMMON:
777
    case WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
778
    case DYN_UNDEF * 16 + DYN_WEAK_COMMON:
779
    case DYN_WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
780
      // I guess a weak common symbol is better than a definition.
781
      return true;
782
 
783
    case COMMON * 16 + DYN_WEAK_COMMON:
784
    case WEAK_COMMON * 16 + DYN_WEAK_COMMON:
785
    case DYN_COMMON * 16 + DYN_WEAK_COMMON:
786
    case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON:
787
      // Set the size to the maximum.
788
      *adjust_common_sizes = true;
789
      return false;
790
 
791
    default:
792
      gold_unreachable();
793
    }
794
}
795
 
796
// Issue an error or warning due to symbol resolution.  IS_ERROR
797
// indicates an error rather than a warning.  MSG is the error
798
// message; it is expected to have a %s for the symbol name.  TO is
799
// the existing symbol.  DEFINED/OBJECT is where the new symbol was
800
// found.
801
 
802
// FIXME: We should have better location information here.  When the
803
// symbol is defined, we should be able to pull the location from the
804
// debug info if there is any.
805
 
806
void
807
Symbol_table::report_resolve_problem(bool is_error, const char* msg,
808
                                     const Symbol* to, Defined defined,
809
                                     Object* object)
810
{
811
  std::string demangled(to->demangled_name());
812
  size_t len = strlen(msg) + demangled.length() + 10;
813
  char* buf = new char[len];
814
  snprintf(buf, len, msg, demangled.c_str());
815
 
816
  const char* objname;
817
  switch (defined)
818
    {
819
    case OBJECT:
820
      objname = object->name().c_str();
821
      break;
822
    case COPY:
823
      objname = _("COPY reloc");
824
      break;
825
    case DEFSYM:
826
    case UNDEFINED:
827
      objname = _("command line");
828
      break;
829
    case SCRIPT:
830
      objname = _("linker script");
831
      break;
832
    case PREDEFINED:
833
      objname = _("linker defined");
834
      break;
835
    default:
836
      gold_unreachable();
837
    }
838
 
839
  if (is_error)
840
    gold_error("%s: %s", objname, buf);
841
  else
842
    gold_warning("%s: %s", objname, buf);
843
 
844
  delete[] buf;
845
 
846
  if (to->source() == Symbol::FROM_OBJECT)
847
    objname = to->object()->name().c_str();
848
  else
849
    objname = _("command line");
850
  gold_info("%s: %s: previous definition here", program_name, objname);
851
}
852
 
853
// A special case of should_override which is only called for a strong
854
// defined symbol from a regular object file.  This is used when
855
// defining special symbols.
856
 
857
bool
858
Symbol_table::should_override_with_special(const Symbol* to, Defined defined)
859
{
860
  bool adjust_common_sizes;
861
  bool adjust_dyn_def;
862
  unsigned int frombits = global_flag | regular_flag | def_flag;
863
  bool ret = Symbol_table::should_override(to, frombits, defined, NULL,
864
                                           &adjust_common_sizes,
865
                                           &adjust_dyn_def);
866
  gold_assert(!adjust_common_sizes && !adjust_dyn_def);
867
  return ret;
868
}
869
 
870
// Override symbol base with a special symbol.
871
 
872
void
873
Symbol::override_base_with_special(const Symbol* from)
874
{
875
  gold_assert(this->name_ == from->name_ || this->has_alias());
876
 
877
  this->source_ = from->source_;
878
  switch (from->source_)
879
    {
880
    case FROM_OBJECT:
881
      this->u_.from_object = from->u_.from_object;
882
      break;
883
    case IN_OUTPUT_DATA:
884
      this->u_.in_output_data = from->u_.in_output_data;
885
      break;
886
    case IN_OUTPUT_SEGMENT:
887
      this->u_.in_output_segment = from->u_.in_output_segment;
888
      break;
889
    case IS_CONSTANT:
890
    case IS_UNDEFINED:
891
      break;
892
    default:
893
      gold_unreachable();
894
      break;
895
    }
896
 
897
  this->override_version(from->version_);
898
  this->type_ = from->type_;
899
  this->binding_ = from->binding_;
900
  this->override_visibility(from->visibility_);
901
  this->nonvis_ = from->nonvis_;
902
 
903
  // Special symbols are always considered to be regular symbols.
904
  this->in_reg_ = true;
905
 
906
  if (from->needs_dynsym_entry_)
907
    this->needs_dynsym_entry_ = true;
908
  if (from->needs_dynsym_value_)
909
    this->needs_dynsym_value_ = true;
910
 
911
  // We shouldn't see these flags.  If we do, we need to handle them
912
  // somehow.
913
  gold_assert(!from->is_forwarder_);
914
  gold_assert(!from->has_plt_offset());
915
  gold_assert(!from->has_warning_);
916
  gold_assert(!from->is_copied_from_dynobj_);
917
  gold_assert(!from->is_forced_local_);
918
}
919
 
920
// Override a symbol with a special symbol.
921
 
922
template<int size>
923
void
924
Sized_symbol<size>::override_with_special(const Sized_symbol<size>* from)
925
{
926
  this->override_base_with_special(from);
927
  this->value_ = from->value_;
928
  this->symsize_ = from->symsize_;
929
}
930
 
931
// Override TOSYM with the special symbol FROMSYM.  This handles all
932
// aliases of TOSYM.
933
 
934
template<int size>
935
void
936
Symbol_table::override_with_special(Sized_symbol<size>* tosym,
937
                                    const Sized_symbol<size>* fromsym)
938
{
939
  tosym->override_with_special(fromsym);
940
  if (tosym->has_alias())
941
    {
942
      Symbol* sym = this->weak_aliases_[tosym];
943
      gold_assert(sym != NULL);
944
      Sized_symbol<size>* ssym = this->get_sized_symbol<size>(sym);
945
      do
946
        {
947
          ssym->override_with_special(fromsym);
948
          sym = this->weak_aliases_[ssym];
949
          gold_assert(sym != NULL);
950
          ssym = this->get_sized_symbol<size>(sym);
951
        }
952
      while (ssym != tosym);
953
    }
954
  if (tosym->binding() == elfcpp::STB_LOCAL
955
      || ((tosym->visibility() == elfcpp::STV_HIDDEN
956
           || tosym->visibility() == elfcpp::STV_INTERNAL)
957
          && (tosym->binding() == elfcpp::STB_GLOBAL
958
              || tosym->binding() == elfcpp::STB_GNU_UNIQUE
959
              || tosym->binding() == elfcpp::STB_WEAK)
960
          && !parameters->options().relocatable()))
961
    this->force_local(tosym);
962
}
963
 
964
// Instantiate the templates we need.  We could use the configure
965
// script to restrict this to only the ones needed for implemented
966
// targets.
967
 
968
// We have to instantiate both big and little endian versions because
969
// these are used by other templates that depends on size only.
970
 
971
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
972
template
973
void
974
Symbol_table::resolve<32, false>(
975
    Sized_symbol<32>* to,
976
    const elfcpp::Sym<32, false>& sym,
977
    unsigned int st_shndx,
978
    bool is_ordinary,
979
    unsigned int orig_st_shndx,
980
    Object* object,
981
    const char* version);
982
 
983
template
984
void
985
Symbol_table::resolve<32, true>(
986
    Sized_symbol<32>* to,
987
    const elfcpp::Sym<32, true>& sym,
988
    unsigned int st_shndx,
989
    bool is_ordinary,
990
    unsigned int orig_st_shndx,
991
    Object* object,
992
    const char* version);
993
#endif
994
 
995
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
996
template
997
void
998
Symbol_table::resolve<64, false>(
999
    Sized_symbol<64>* to,
1000
    const elfcpp::Sym<64, false>& sym,
1001
    unsigned int st_shndx,
1002
    bool is_ordinary,
1003
    unsigned int orig_st_shndx,
1004
    Object* object,
1005
    const char* version);
1006
 
1007
template
1008
void
1009
Symbol_table::resolve<64, true>(
1010
    Sized_symbol<64>* to,
1011
    const elfcpp::Sym<64, true>& sym,
1012
    unsigned int st_shndx,
1013
    bool is_ordinary,
1014
    unsigned int orig_st_shndx,
1015
    Object* object,
1016
    const char* version);
1017
#endif
1018
 
1019
#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1020
template
1021
void
1022
Symbol_table::override_with_special<32>(Sized_symbol<32>*,
1023
                                        const Sized_symbol<32>*);
1024
#endif
1025
 
1026
#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1027
template
1028
void
1029
Symbol_table::override_with_special<64>(Sized_symbol<64>*,
1030
                                        const Sized_symbol<64>*);
1031
#endif
1032
 
1033
} // End namespace gold.

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.