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