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