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.  We can't give an error
 194       // here, because we have not yet discarded linkonce and comdat
 195       // sections.  FIXME.
 196       return;
 197
 198     case WEAK_DEF * 16 + DEF:
 199       // We've seen a weak definition, and now we see a strong
 200       // definition.  In the original SVR4 linker, this was treated as
 201       // a multiple definition error.  In the Solaris linker and the
 202       // GNU linker, a weak definition followed by a regular
 203       // definition causes the weak definition to be overridden.  We
 204       // are currently compatible with the GNU linker.  In the future
 205       // we should add a target specific option to change this.
 206       // FIXME.
 207       to->override(sym, object);
 208       return;
 209
 210     case DYN_DEF * 16 + DEF:
 211     case DYN_WEAK_DEF * 16 + DEF:
 212       // We've seen a definition in a dynamic object, and now we see a
 213       // definition in a regular object.  The definition in the
 214       // regular object overrides the definition in the dynamic
 215       // object.
 216       to->override(sym, object);
 217       return;
 218
 219     case UNDEF * 16 + DEF:
 220     case WEAK_UNDEF * 16 + DEF:
 221     case DYN_UNDEF * 16 + DEF:
 222     case DYN_WEAK_UNDEF * 16 + DEF:
 223       // We've seen an undefined reference, and now we see a
 224       // definition.  We use the definition.
 225       to->override(sym, object);
 226       return;
 227
 228     case COMMON * 16 + DEF:
 229     case WEAK_COMMON * 16 + DEF:
 230     case DYN_COMMON * 16 + DEF:
 231     case DYN_WEAK_COMMON * 16 + DEF:
 232       // We've seen a common symbol and now we see a definition.  The
 233       // definition overrides.  FIXME: We should optionally issue a
 234       // warning.
 235       to->override(sym, object);
 236       return;
 237
 238     case DEF * 16 + WEAK_DEF:
 239     case WEAK_DEF * 16 + WEAK_DEF:
 240       // We've seen a definition and now we see a weak definition.  We
 241       // ignore the new weak definition.
 242       return;
 243
 244     case DYN_DEF * 16 + WEAK_DEF:
 245     case DYN_WEAK_DEF * 16 + WEAK_DEF:
 246       // We've seen a dynamic definition and now we see a regular weak
 247       // definition.  The regular weak definition overrides.
 248       to->override(sym, object);
 249       return;
 250
 251     case UNDEF * 16 + WEAK_DEF:
 252     case WEAK_UNDEF * 16 + WEAK_DEF:
 253     case DYN_UNDEF * 16 + WEAK_DEF:
 254     case DYN_WEAK_UNDEF * 16 + WEAK_DEF:
 255       // A weak definition of a currently undefined symbol.
 256       to->override(sym, object);
 257       return;
 258
 259     case COMMON * 16 + WEAK_DEF:
 260     case WEAK_COMMON * 16 + WEAK_DEF:
 261       // A weak definition does not override a common definition.
 262       return;
 263
 264     case DYN_COMMON * 16 + WEAK_DEF:
 265     case DYN_WEAK_COMMON * 16 + WEAK_DEF:
 266       // A weak definition does override a definition in a dynamic
 267       // object.  FIXME: We should optionally issue a warning.
 268       to->override(sym, object);
 269       return;
 270
 271     case DEF * 16 + DYN_DEF:
 272     case WEAK_DEF * 16 + DYN_DEF:
 273     case DYN_DEF * 16 + DYN_DEF:
 274     case DYN_WEAK_DEF * 16 + DYN_DEF:
 275       // Ignore a dynamic definition if we already have a definition.
 276       return;
 277
 278     case UNDEF * 16 + DYN_DEF:
 279     case WEAK_UNDEF * 16 + DYN_DEF:
 280     case DYN_UNDEF * 16 + DYN_DEF:
 281     case DYN_WEAK_UNDEF * 16 + DYN_DEF:
 282       // Use a dynamic definition if we have a reference.
 283       to->override(sym, object);
 284       return;
 285
 286     case COMMON * 16 + DYN_DEF:
 287     case WEAK_COMMON * 16 + DYN_DEF:
 288     case DYN_COMMON * 16 + DYN_DEF:
 289     case DYN_WEAK_COMMON * 16 + DYN_DEF:
 290       // Ignore a dynamic definition if we already have a common
 291       // definition.
 292       return;
 293
 294     case DEF * 16 + DYN_WEAK_DEF:
 295     case WEAK_DEF * 16 + DYN_WEAK_DEF:
 296     case DYN_DEF * 16 + DYN_WEAK_DEF:
 297     case DYN_WEAK_DEF * 16 + DYN_WEAK_DEF:
 298       // Ignore a weak dynamic definition if we already have a
 299       // definition.
 300       return;
 301
 302     case UNDEF * 16 + DYN_WEAK_DEF:
 303     case WEAK_UNDEF * 16 + DYN_WEAK_DEF:
 304     case DYN_UNDEF * 16 + DYN_WEAK_DEF:
 305     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_DEF:
 306       // Use a weak dynamic definition if we have a reference.
 307       to->override(sym, object);
 308       return;
 309
 310     case COMMON * 16 + DYN_WEAK_DEF:
 311     case WEAK_COMMON * 16 + DYN_WEAK_DEF:
 312     case DYN_COMMON * 16 + DYN_WEAK_DEF:
 313     case DYN_WEAK_COMMON * 16 + DYN_WEAK_DEF:
 314       // Ignore a weak dynamic definition if we already have a common
 315       // definition.
 316       return;
 317
 318     case DEF * 16 + UNDEF:
 319     case WEAK_DEF * 16 + UNDEF:
 320     case DYN_DEF * 16 + UNDEF:
 321     case DYN_WEAK_DEF * 16 + UNDEF:
 322     case UNDEF * 16 + UNDEF:
 323     case WEAK_UNDEF * 16 + UNDEF:
 324     case DYN_UNDEF * 16 + UNDEF:
 325     case DYN_WEAK_UNDEF * 16 + UNDEF:
 326     case COMMON * 16 + UNDEF:
 327     case WEAK_COMMON * 16 + UNDEF:
 328     case DYN_COMMON * 16 + UNDEF:
 329     case DYN_WEAK_COMMON * 16 + UNDEF:
 330       // A new undefined reference tells us nothing.
 331       return;
 332
 333     case DEF * 16 + WEAK_UNDEF:
 334     case WEAK_DEF * 16 + WEAK_UNDEF:
 335     case DYN_DEF * 16 + WEAK_UNDEF:
 336     case DYN_WEAK_DEF * 16 + WEAK_UNDEF:
 337     case UNDEF * 16 + WEAK_UNDEF:
 338     case WEAK_UNDEF * 16 + WEAK_UNDEF:
 339     case DYN_UNDEF * 16 + WEAK_UNDEF:
 340     case DYN_WEAK_UNDEF * 16 + WEAK_UNDEF:
 341     case COMMON * 16 + WEAK_UNDEF:
 342     case WEAK_COMMON * 16 + WEAK_UNDEF:
 343     case DYN_COMMON * 16 + WEAK_UNDEF:
 344     case DYN_WEAK_COMMON * 16 + WEAK_UNDEF:
 345       // A new weak undefined reference tells us nothing.
 346       return;
 347
 348     case DEF * 16 + DYN_UNDEF:
 349     case WEAK_DEF * 16 + DYN_UNDEF:
 350     case DYN_DEF * 16 + DYN_UNDEF:
 351     case DYN_WEAK_DEF * 16 + DYN_UNDEF:
 352     case UNDEF * 16 + DYN_UNDEF:
 353     case WEAK_UNDEF * 16 + DYN_UNDEF:
 354     case DYN_UNDEF * 16 + DYN_UNDEF:
 355     case DYN_WEAK_UNDEF * 16 + DYN_UNDEF:
 356     case COMMON * 16 + DYN_UNDEF:
 357     case WEAK_COMMON * 16 + DYN_UNDEF:
 358     case DYN_COMMON * 16 + DYN_UNDEF:
 359     case DYN_WEAK_COMMON * 16 + DYN_UNDEF:
 360       // A new dynamic undefined reference tells us nothing.
 361       return;
 362
 363     case DEF * 16 + DYN_WEAK_UNDEF:
 364     case WEAK_DEF * 16 + DYN_WEAK_UNDEF:
 365     case DYN_DEF * 16 + DYN_WEAK_UNDEF:
 366     case DYN_WEAK_DEF * 16 + DYN_WEAK_UNDEF:
 367     case UNDEF * 16 + DYN_WEAK_UNDEF:
 368     case WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
 369     case DYN_UNDEF * 16 + DYN_WEAK_UNDEF:
 370     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_UNDEF:
 371     case COMMON * 16 + DYN_WEAK_UNDEF:
 372     case WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
 373     case DYN_COMMON * 16 + DYN_WEAK_UNDEF:
 374     case DYN_WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
 375       // A new weak dynamic undefined reference tells us nothing.
 376       return;
 377
 378     case DEF * 16 + COMMON:
 379       // A common symbol does not override a definition.
 380       return;
 381
 382     case WEAK_DEF * 16 + COMMON:
 383     case DYN_DEF * 16 + COMMON:
 384     case DYN_WEAK_DEF * 16 + COMMON:
 385       // A common symbol does override a weak definition or a dynamic
 386       // definition.
 387       to->override(sym, object);
 388       return;
 389
 390     case UNDEF * 16 + COMMON:
 391     case WEAK_UNDEF * 16 + COMMON:
 392     case DYN_UNDEF * 16 + COMMON:
 393     case DYN_WEAK_UNDEF * 16 + COMMON:
 394       // A common symbol is a definition for a reference.
 395       to->override(sym, object);
 396       return;
 397
 398     case COMMON * 16 + COMMON:
 399     case WEAK_COMMON * 16 + COMMON:
 400     case DYN_COMMON * 16 + COMMON:
 401     case DYN_WEAK_COMMON * 16 + COMMON:
 402
 403     case DEF * 16 + WEAK_COMMON:
 404     case WEAK_DEF * 16 + WEAK_COMMON:
 405     case DYN_DEF * 16 + WEAK_COMMON:
 406     case DYN_WEAK_DEF * 16 + WEAK_COMMON:
 407     case UNDEF * 16 + WEAK_COMMON:
 408     case WEAK_UNDEF * 16 + WEAK_COMMON:
 409     case DYN_UNDEF * 16 + WEAK_COMMON:
 410     case DYN_WEAK_UNDEF * 16 + WEAK_COMMON:
 411     case COMMON * 16 + WEAK_COMMON:
 412     case WEAK_COMMON * 16 + WEAK_COMMON:
 413     case DYN_COMMON * 16 + WEAK_COMMON:
 414     case DYN_WEAK_COMMON * 16 + WEAK_COMMON:
 415
 416     case DEF * 16 + DYN_COMMON:
 417     case WEAK_DEF * 16 + DYN_COMMON:
 418     case DYN_DEF * 16 + DYN_COMMON:
 419     case DYN_WEAK_DEF * 16 + DYN_COMMON:
 420     case UNDEF * 16 + DYN_COMMON:
 421     case WEAK_UNDEF * 16 + DYN_COMMON:
 422     case DYN_UNDEF * 16 + DYN_COMMON:
 423     case DYN_WEAK_UNDEF * 16 + DYN_COMMON:
 424     case COMMON * 16 + DYN_COMMON:
 425     case WEAK_COMMON * 16 + DYN_COMMON:
 426     case DYN_COMMON * 16 + DYN_COMMON:
 427     case DYN_WEAK_COMMON * 16 + DYN_COMMON:
 428
 429     case DEF * 16 + DYN_WEAK_COMMON:
 430     case WEAK_DEF * 16 + DYN_WEAK_COMMON:
 431     case DYN_DEF * 16 + DYN_WEAK_COMMON:
 432     case DYN_WEAK_DEF * 16 + DYN_WEAK_COMMON:
 433     case UNDEF * 16 + DYN_WEAK_COMMON:
 434     case WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
 435     case DYN_UNDEF * 16 + DYN_WEAK_COMMON:
 436     case DYN_WEAK_UNDEF * 16 + DYN_WEAK_COMMON:
 437     case COMMON * 16 + DYN_WEAK_COMMON:
 438     case WEAK_COMMON * 16 + DYN_WEAK_COMMON:
 439     case DYN_COMMON * 16 + DYN_WEAK_COMMON:
 440     case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON:
 441       abort();
 442       break;
 443
 444     default:
 445       abort();
 446     }
 447 }
 448
 449 // Instantiate the templates we need.  We could use the configure
 450 // script to restrict this to only the ones needed for implemented
 451 // targets.
 452
 453 template
 454 void
 455 Symbol_table::resolve<32, true>(
 456     Sized_symbol<32>* to,
 457     const elfcpp::Sym<32, true>& sym,
 458     Object* object);
 459
 460 template
 461 void
 462 Symbol_table::resolve<32, false>(
 463     Sized_symbol<32>* to,
 464     const elfcpp::Sym<32, false>& sym,
 465     Object* object);
 466
 467 template
 468 void
 469 Symbol_table::resolve<64, true>(
 470     Sized_symbol<64>* to,
 471     const elfcpp::Sym<64, true>& sym,
 472     Object* object);
 473
 474 template
 475 void
 476 Symbol_table::resolve<64, false>(
 477     Sized_symbol<64>* to,
 478     const elfcpp::Sym<64, false>& sym,
 479     Object* object);
 480
 481 } // End namespace gold.