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