gold/object.cc

   1 // object.cc -- support for an object file for linking in gold
   2
   3 #include "gold.h"
   4
   5 #include <cerrno>
   6 #include <cstring>
   7 #include <cstdarg>
   8
   9 #include "target-select.h"
  10 #include "layout.h"
  11 #include "output.h"
  12 #include "symtab.h"
  13 #include "object.h"
  14 #include "dynobj.h"
  15
  16 namespace gold
  17 {
  18
  19 // Class Object.
  20
  21 // Set the target based on fields in the ELF file header.
  22
  23 void
  24 Object::set_target(int machine, int size, bool big_endian, int osabi,
  25                    int abiversion)
  26 {
  27   Target* target = select_target(machine, size, big_endian, osabi, abiversion);
  28   if (target == NULL)
  29     {
  30       fprintf(stderr, _("%s: %s: unsupported ELF machine number %d\n"),
  31               program_name, this->name().c_str(), machine);
  32       gold_exit(false);
  33     }
  34   this->target_ = target;
  35 }
  36
  37 // Report an error for the elfcpp::Elf_file interface.
  38
  39 void
  40 Object::error(const char* format, ...)
  41 {
  42   va_list args;
  43
  44   fprintf(stderr, "%s: %s: ", program_name, this->name().c_str());
  45   va_start(args, format);
  46   vfprintf(stderr, format, args);
  47   va_end(args);
  48   putc('\n', stderr);
  49
  50   gold_exit(false);
  51 }
  52
  53 // Return a view of the contents of a section.
  54
  55 const unsigned char*
  56 Object::section_contents(unsigned int shndx, off_t* plen)
  57 {
  58   Location loc(this->do_section_contents(shndx));
  59   *plen = loc.data_size;
  60   return this->get_view(loc.file_offset, loc.data_size);
  61 }
  62
  63 // Read the section data into SD.  This is code common to Sized_relobj
  64 // and Sized_dynobj, so we put it into Object.
  65
  66 template<int size, bool big_endian>
  67 void
  68 Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file,
  69                           Read_symbols_data* sd)
  70 {
  71   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
  72
  73   // Read the section headers.
  74   const off_t shoff = elf_file->shoff();
  75   const unsigned int shnum = this->shnum();
  76   sd->section_headers = this->get_lasting_view(shoff, shnum * shdr_size);
  77
  78   // Read the section names.
  79   const unsigned char* pshdrs = sd->section_headers->data();
  80   const unsigned char* pshdrnames = pshdrs + elf_file->shstrndx() * shdr_size;
  81   typename elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
  82
  83   if (shdrnames.get_sh_type() != elfcpp::SHT_STRTAB)
  84     {
  85       fprintf(stderr,
  86               _("%s: %s: section name section has wrong type: %u\n"),
  87               program_name, this->name().c_str(),
  88               static_cast<unsigned int>(shdrnames.get_sh_type()));
  89       gold_exit(false);
  90     }
  91
  92   sd->section_names_size = shdrnames.get_sh_size();
  93   sd->section_names = this->get_lasting_view(shdrnames.get_sh_offset(),
  94                                              sd->section_names_size);
  95 }
  96
  97 // If NAME is the name of a special .gnu.warning section, arrange for
  98 // the warning to be issued.  SHNDX is the section index.  Return
  99 // whether it is a warning section.
 100
 101 bool
 102 Object::handle_gnu_warning_section(const char* name, unsigned int shndx,
 103                                    Symbol_table* symtab)
 104 {
 105   const char warn_prefix[] = ".gnu.warning.";
 106   const int warn_prefix_len = sizeof warn_prefix - 1;
 107   if (strncmp(name, warn_prefix, warn_prefix_len) == 0)
 108     {
 109       symtab->add_warning(name + warn_prefix_len, this, shndx);
 110       return true;
 111     }
 112   return false;
 113 }
 114
 115 // Class Sized_relobj.
 116
 117 template<int size, bool big_endian>
 118 Sized_relobj<size, big_endian>::Sized_relobj(
 119     const std::string& name,
 120     Input_file* input_file,
 121     off_t offset,
 122     const elfcpp::Ehdr<size, big_endian>& ehdr)
 123   : Relobj(name, input_file, offset),
 124     elf_file_(this, ehdr),
 125     symtab_shndx_(-1U),
 126     local_symbol_count_(0),
 127     output_local_symbol_count_(0),
 128     symbols_(NULL),
 129     local_symbol_offset_(0),
 130     local_values_(),
 131     local_indexes_()
 132 {
 133 }
 134
 135 template<int size, bool big_endian>
 136 Sized_relobj<size, big_endian>::~Sized_relobj()
 137 {
 138 }
 139
 140 // Set up an object file based on the file header.  This sets up the
 141 // target and reads the section information.
 142
 143 template<int size, bool big_endian>
 144 void
 145 Sized_relobj<size, big_endian>::setup(
 146     const elfcpp::Ehdr<size, big_endian>& ehdr)
 147 {
 148   this->set_target(ehdr.get_e_machine(), size, big_endian,
 149                    ehdr.get_e_ident()[elfcpp::EI_OSABI],
 150                    ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
 151
 152   const unsigned int shnum = this->elf_file_.shnum();
 153   this->set_shnum(shnum);
 154 }
 155
 156 // Find the SHT_SYMTAB section, given the section headers.  The ELF
 157 // standard says that maybe in the future there can be more than one
 158 // SHT_SYMTAB section.  Until somebody figures out how that could
 159 // work, we assume there is only one.
 160
 161 template<int size, bool big_endian>
 162 void
 163 Sized_relobj<size, big_endian>::find_symtab(const unsigned char* pshdrs)
 164 {
 165   const unsigned int shnum = this->shnum();
 166   this->symtab_shndx_ = 0;
 167   if (shnum > 0)
 168     {
 169       // Look through the sections in reverse order, since gas tends
 170       // to put the symbol table at the end.
 171       const unsigned char* p = pshdrs + shnum * This::shdr_size;
 172       unsigned int i = shnum;
 173       while (i > 0)
 174         {
 175           --i;
 176           p -= This::shdr_size;
 177           typename This::Shdr shdr(p);
 178           if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
 179             {
 180               this->symtab_shndx_ = i;
 181               break;
 182             }
 183         }
 184     }
 185 }
 186
 187 // Read the sections and symbols from an object file.
 188
 189 template<int size, bool big_endian>
 190 void
 191 Sized_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
 192 {
 193   this->read_section_data(&this->elf_file_, sd);
 194
 195   const unsigned char* const pshdrs = sd->section_headers->data();
 196
 197   this->find_symtab(pshdrs);
 198
 199   if (this->symtab_shndx_ == 0)
 200     {
 201       // No symbol table.  Weird but legal.
 202       sd->symbols = NULL;
 203       sd->symbols_size = 0;
 204       sd->symbol_names = NULL;
 205       sd->symbol_names_size = 0;
 206       return;
 207     }
 208
 209   // Get the symbol table section header.
 210   typename This::Shdr symtabshdr(pshdrs
 211                                  + this->symtab_shndx_ * This::shdr_size);
 212   gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
 213
 214   // We only need the external symbols.
 215   const int sym_size = This::sym_size;
 216   const unsigned int loccount = symtabshdr.get_sh_info();
 217   this->local_symbol_count_ = loccount;
 218   off_t locsize = loccount * sym_size;
 219   off_t extoff = symtabshdr.get_sh_offset() + locsize;
 220   off_t extsize = symtabshdr.get_sh_size() - locsize;
 221
 222   // Read the symbol table.
 223   File_view* fvsymtab = this->get_lasting_view(extoff, extsize);
 224
 225   // Read the section header for the symbol names.
 226   unsigned int strtab_shndx = symtabshdr.get_sh_link();
 227   if (strtab_shndx >= this->shnum())
 228     {
 229       fprintf(stderr, _("%s: %s: invalid symbol table name index: %u\n"),
 230               program_name, this->name().c_str(), strtab_shndx);
 231       gold_exit(false);
 232     }
 233   typename This::Shdr strtabshdr(pshdrs + strtab_shndx * This::shdr_size);
 234   if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
 235     {
 236       fprintf(stderr,
 237               _("%s: %s: symbol table name section has wrong type: %u\n"),
 238               program_name, this->name().c_str(),
 239               static_cast<unsigned int>(strtabshdr.get_sh_type()));
 240       gold_exit(false);
 241     }
 242
 243   // Read the symbol names.
 244   File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
 245                                                strtabshdr.get_sh_size());
 246
 247   sd->symbols = fvsymtab;
 248   sd->symbols_size = extsize;
 249   sd->symbol_names = fvstrtab;
 250   sd->symbol_names_size = strtabshdr.get_sh_size();
 251 }
 252
 253 // Return whether to include a section group in the link.  LAYOUT is
 254 // used to keep track of which section groups we have already seen.
 255 // INDEX is the index of the section group and SHDR is the section
 256 // header.  If we do not want to include this group, we set bits in
 257 // OMIT for each section which should be discarded.
 258
 259 template<int size, bool big_endian>
 260 bool
 261 Sized_relobj<size, big_endian>::include_section_group(
 262     Layout* layout,
 263     unsigned int index,
 264     const elfcpp::Shdr<size, big_endian>& shdr,
 265     std::vector<bool>* omit)
 266 {
 267   // Read the section contents.
 268   const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
 269                                              shdr.get_sh_size());
 270   const elfcpp::Elf_Word* pword =
 271     reinterpret_cast<const elfcpp::Elf_Word*>(pcon);
 272
 273   // The first word contains flags.  We only care about COMDAT section
 274   // groups.  Other section groups are always included in the link
 275   // just like ordinary sections.
 276   elfcpp::Elf_Word flags = elfcpp::Swap<32, big_endian>::readval(pword);
 277   if ((flags & elfcpp::GRP_COMDAT) == 0)
 278     return true;
 279
 280   // Look up the group signature, which is the name of a symbol.  This
 281   // is a lot of effort to go to to read a string.  Why didn't they
 282   // just use the name of the SHT_GROUP section as the group
 283   // signature?
 284
 285   // Get the appropriate symbol table header (this will normally be
 286   // the single SHT_SYMTAB section, but in principle it need not be).
 287   const unsigned int link = shdr.get_sh_link();
 288   typename This::Shdr symshdr(this, this->elf_file_.section_header(link));
 289
 290   // Read the symbol table entry.
 291   if (shdr.get_sh_info() >= symshdr.get_sh_size() / This::sym_size)
 292     {
 293       fprintf(stderr, _("%s: %s: section group %u info %u out of range\n"),
 294               program_name, this->name().c_str(), index, shdr.get_sh_info());
 295       gold_exit(false);
 296     }
 297   off_t symoff = symshdr.get_sh_offset() + shdr.get_sh_info() * This::sym_size;
 298   const unsigned char* psym = this->get_view(symoff, This::sym_size);
 299   elfcpp::Sym<size, big_endian> sym(psym);
 300
 301   // Read the symbol table names.
 302   off_t symnamelen;
 303   const unsigned char* psymnamesu;
 304   psymnamesu = this->section_contents(symshdr.get_sh_link(), &symnamelen);
 305   const char* psymnames = reinterpret_cast<const char*>(psymnamesu);
 306
 307   // Get the section group signature.
 308   if (sym.get_st_name() >= symnamelen)
 309     {
 310       fprintf(stderr, _("%s: %s: symbol %u name offset %u out of range\n"),
 311               program_name, this->name().c_str(), shdr.get_sh_info(),
 312               sym.get_st_name());
 313       gold_exit(false);
 314     }
 315
 316   const char* signature = psymnames + sym.get_st_name();
 317
 318   // It seems that some versions of gas will create a section group
 319   // associated with a section symbol, and then fail to give a name to
 320   // the section symbol.  In such a case, use the name of the section.
 321   // FIXME.
 322   std::string secname;
 323   if (signature[0] == '\0' && sym.get_st_type() == elfcpp::STT_SECTION)
 324     {
 325       secname = this->section_name(sym.get_st_shndx());
 326       signature = secname.c_str();
 327     }
 328
 329   // Record this section group, and see whether we've already seen one
 330   // with the same signature.
 331   if (layout->add_comdat(signature, true))
 332     return true;
 333
 334   // This is a duplicate.  We want to discard the sections in this
 335   // group.
 336   size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
 337   for (size_t i = 1; i < count; ++i)
 338     {
 339       elfcpp::Elf_Word secnum =
 340         elfcpp::Swap<32, big_endian>::readval(pword + i);
 341       if (secnum >= this->shnum())
 342         {
 343           fprintf(stderr,
 344                   _("%s: %s: section %u in section group %u out of range"),
 345                   program_name, this->name().c_str(), secnum,
 346                   index);
 347           gold_exit(false);
 348         }
 349       (*omit)[secnum] = true;
 350     }
 351
 352   return false;
 353 }
 354
 355 // Whether to include a linkonce section in the link.  NAME is the
 356 // name of the section and SHDR is the section header.
 357
 358 // Linkonce sections are a GNU extension implemented in the original
 359 // GNU linker before section groups were defined.  The semantics are
 360 // that we only include one linkonce section with a given name.  The
 361 // name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
 362 // where T is the type of section and SYMNAME is the name of a symbol.
 363 // In an attempt to make linkonce sections interact well with section
 364 // groups, we try to identify SYMNAME and use it like a section group
 365 // signature.  We want to block section groups with that signature,
 366 // but not other linkonce sections with that signature.  We also use
 367 // the full name of the linkonce section as a normal section group
 368 // signature.
 369
 370 template<int size, bool big_endian>
 371 bool
 372 Sized_relobj<size, big_endian>::include_linkonce_section(
 373     Layout* layout,
 374     const char* name,
 375     const elfcpp::Shdr<size, big_endian>&)
 376 {
 377   const char* symname = strrchr(name, '.') + 1;
 378   bool include1 = layout->add_comdat(symname, false);
 379   bool include2 = layout->add_comdat(name, true);
 380   return include1 && include2;
 381 }
 382
 383 // Lay out the input sections.  We walk through the sections and check
 384 // whether they should be included in the link.  If they should, we
 385 // pass them to the Layout object, which will return an output section
 386 // and an offset.
 387
 388 template<int size, bool big_endian>
 389 void
 390 Sized_relobj<size, big_endian>::do_layout(const General_options& options,
 391                                           Symbol_table* symtab,
 392                                           Layout* layout,
 393                                           Read_symbols_data* sd)
 394 {
 395   const unsigned int shnum = this->shnum();
 396   if (shnum == 0)
 397     return;
 398
 399   // Get the section headers.
 400   const unsigned char* pshdrs = sd->section_headers->data();
 401
 402   // Get the section names.
 403   const unsigned char* pnamesu = sd->section_names->data();
 404   const char* pnames = reinterpret_cast<const char*>(pnamesu);
 405
 406   std::vector<Map_to_output>& map_sections(this->map_to_output());
 407   map_sections.resize(shnum);
 408
 409   // Keep track of which sections to omit.
 410   std::vector<bool> omit(shnum, false);
 411
 412   // Skip the first, dummy, section.
 413   pshdrs += This::shdr_size;
 414   for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
 415     {
 416       typename This::Shdr shdr(pshdrs);
 417
 418       if (shdr.get_sh_name() >= sd->section_names_size)
 419         {
 420           fprintf(stderr,
 421                   _("%s: %s: bad section name offset for section %u: %lu\n"),
 422                   program_name, this->name().c_str(), i,
 423                   static_cast<unsigned long>(shdr.get_sh_name()));
 424           gold_exit(false);
 425         }
 426
 427       const char* name = pnames + shdr.get_sh_name();
 428
 429       if (this->handle_gnu_warning_section(name, i, symtab))
 430         {
 431           if (!options.is_relocatable())
 432             omit[i] = true;
 433         }
 434
 435       bool discard = omit[i];
 436       if (!discard)
 437         {
 438           if (shdr.get_sh_type() == elfcpp::SHT_GROUP)
 439             {
 440               if (!this->include_section_group(layout, i, shdr, &omit))
 441                 discard = true;
 442             }
 443           else if (Layout::is_linkonce(name))
 444             {
 445               if (!this->include_linkonce_section(layout, name, shdr))
 446                 discard = true;
 447             }
 448         }
 449
 450       if (discard)
 451         {
 452           // Do not include this section in the link.
 453           map_sections[i].output_section = NULL;
 454           continue;
 455         }
 456
 457       off_t offset;
 458       Output_section* os = layout->layout(this, i, name, shdr, &offset);
 459
 460       map_sections[i].output_section = os;
 461       map_sections[i].offset = offset;
 462     }
 463
 464   delete sd->section_headers;
 465   sd->section_headers = NULL;
 466   delete sd->section_names;
 467   sd->section_names = NULL;
 468 }
 469
 470 // Add the symbols to the symbol table.
 471
 472 template<int size, bool big_endian>
 473 void
 474 Sized_relobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
 475                                                Read_symbols_data* sd)
 476 {
 477   if (sd->symbols == NULL)
 478     {
 479       gold_assert(sd->symbol_names == NULL);
 480       return;
 481     }
 482
 483   const int sym_size = This::sym_size;
 484   size_t symcount = sd->symbols_size / sym_size;
 485   if (symcount * sym_size != sd->symbols_size)
 486     {
 487       fprintf(stderr,
 488               _("%s: %s: size of symbols is not multiple of symbol size\n"),
 489               program_name, this->name().c_str());
 490       gold_exit(false);
 491     }
 492
 493   this->symbols_ = new Symbol*[symcount];
 494
 495   const char* sym_names =
 496     reinterpret_cast<const char*>(sd->symbol_names->data());
 497   symtab->add_from_relobj(this, sd->symbols->data(), symcount, sym_names,
 498                           sd->symbol_names_size, this->symbols_);
 499
 500   delete sd->symbols;
 501   sd->symbols = NULL;
 502   delete sd->symbol_names;
 503   sd->symbol_names = NULL;
 504 }
 505
 506 // Finalize the local symbols.  Here we record the file offset at
 507 // which they should be output, we add their names to *POOL, and we
 508 // add their values to THIS->LOCAL_VALUES_ and their indexes in the
 509 // output symbol table to THIS->LOCAL_INDEXES_.  Return the symbol
 510 // index.  This function is always called from the main thread.  The
 511 // actual output of the local symbols will occur in a separate task.
 512
 513 template<int size, bool big_endian>
 514 unsigned int
 515 Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index,
 516                                                           off_t off,
 517                                                           Stringpool* pool)
 518 {
 519   gold_assert(this->symtab_shndx_ != -1U);
 520   if (this->symtab_shndx_ == 0)
 521     {
 522       // This object has no symbols.  Weird but legal.
 523       return index;
 524     }
 525
 526   gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
 527
 528   this->local_symbol_offset_ = off;
 529
 530   // Read the symbol table section header.
 531   const unsigned int symtab_shndx = this->symtab_shndx_;
 532   typename This::Shdr symtabshdr(this,
 533                                  this->elf_file_.section_header(symtab_shndx));
 534   gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
 535
 536   // Read the local symbols.
 537   const int sym_size = This::sym_size;
 538   const unsigned int loccount = this->local_symbol_count_;
 539   gold_assert(loccount == symtabshdr.get_sh_info());
 540   off_t locsize = loccount * sym_size;
 541   const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
 542                                               locsize);
 543
 544   this->local_values_.resize(loccount);
 545   this->local_indexes_.resize(loccount);
 546
 547   // Read the symbol names.
 548   const unsigned int strtab_shndx = symtabshdr.get_sh_link();
 549   off_t strtab_size;
 550   const unsigned char* pnamesu = this->section_contents(strtab_shndx,
 551                                                         &strtab_size);
 552   const char* pnames = reinterpret_cast<const char*>(pnamesu);
 553
 554   // Loop over the local symbols.
 555
 556   const std::vector<Map_to_output>& mo(this->map_to_output());
 557   unsigned int shnum = this->shnum();
 558   unsigned int count = 0;
 559   // Skip the first, dummy, symbol.
 560   psyms += sym_size;
 561   for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
 562     {
 563       elfcpp::Sym<size, big_endian> sym(psyms);
 564
 565       unsigned int shndx = sym.get_st_shndx();
 566
 567       if (shndx >= elfcpp::SHN_LORESERVE)
 568         {
 569           if (shndx == elfcpp::SHN_ABS)
 570             this->local_values_[i] = sym.get_st_value();
 571           else
 572             {
 573               // FIXME: Handle SHN_XINDEX.
 574               fprintf(stderr,
 575                       _("%s: %s: unknown section index %u "
 576                         "for local symbol %u\n"),
 577                       program_name, this->name().c_str(), shndx, i);
 578               gold_exit(false);
 579             }
 580         }
 581       else
 582         {
 583           if (shndx >= shnum)
 584             {
 585               fprintf(stderr,
 586                       _("%s: %s: local symbol %u section index %u "
 587                         "out of range\n"),
 588                       program_name, this->name().c_str(), i, shndx);
 589               gold_exit(false);
 590             }
 591
 592           if (mo[shndx].output_section == NULL)
 593             {
 594               this->local_values_[i] = 0;
 595               this->local_indexes_[i] = -1U;
 596               continue;
 597             }
 598
 599           this->local_values_[i] = (mo[shndx].output_section->address()
 600                                     + mo[shndx].offset
 601                                     + sym.get_st_value());
 602         }
 603
 604       // Decide whether this symbol should go into the output file.
 605
 606       if (sym.get_st_type() == elfcpp::STT_SECTION)
 607         {
 608           this->local_indexes_[i] = -1U;
 609           continue;
 610         }
 611
 612       if (sym.get_st_name() >= strtab_size)
 613         {
 614           fprintf(stderr,
 615                   _("%s: %s: local symbol %u section name "
 616                     "out of range: %u >= %u\n"),
 617                   program_name, this->name().c_str(),
 618                   i, sym.get_st_name(),
 619                   static_cast<unsigned int>(strtab_size));
 620           gold_exit(false);
 621         }
 622
 623       const char* name = pnames + sym.get_st_name();
 624       pool->add(name, NULL);
 625       this->local_indexes_[i] = index;
 626       ++index;
 627       off += sym_size;
 628       ++count;
 629     }
 630
 631   this->output_local_symbol_count_ = count;
 632
 633   return index;
 634 }
 635
 636 // Write out the local symbols.
 637
 638 template<int size, bool big_endian>
 639 void
 640 Sized_relobj<size, big_endian>::write_local_symbols(Output_file* of,
 641                                                     const Stringpool* sympool)
 642 {
 643   gold_assert(this->symtab_shndx_ != -1U);
 644   if (this->symtab_shndx_ == 0)
 645     {
 646       // This object has no symbols.  Weird but legal.
 647       return;
 648     }
 649
 650   // Read the symbol table section header.
 651   const unsigned int symtab_shndx = this->symtab_shndx_;
 652   typename This::Shdr symtabshdr(this,
 653                                  this->elf_file_.section_header(symtab_shndx));
 654   gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
 655   const unsigned int loccount = this->local_symbol_count_;
 656   gold_assert(loccount == symtabshdr.get_sh_info());
 657
 658   // Read the local symbols.
 659   const int sym_size = This::sym_size;
 660   off_t locsize = loccount * sym_size;
 661   const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
 662                                               locsize);
 663
 664   // Read the symbol names.
 665   const unsigned int strtab_shndx = symtabshdr.get_sh_link();
 666   off_t strtab_size;
 667   const unsigned char* pnamesu = this->section_contents(strtab_shndx,
 668                                                         &strtab_size);
 669   const char* pnames = reinterpret_cast<const char*>(pnamesu);
 670
 671   // Get a view into the output file.
 672   off_t output_size = this->output_local_symbol_count_ * sym_size;
 673   unsigned char* oview = of->get_output_view(this->local_symbol_offset_,
 674                                              output_size);
 675
 676   const std::vector<Map_to_output>& mo(this->map_to_output());
 677
 678   gold_assert(this->local_values_.size() == loccount);
 679   gold_assert(this->local_indexes_.size() == loccount);
 680
 681   unsigned char* ov = oview;
 682   psyms += sym_size;
 683   for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
 684     {
 685       elfcpp::Sym<size, big_endian> isym(psyms);
 686
 687       if (this->local_indexes_[i] == -1U)
 688         continue;
 689       gold_assert(this->local_indexes_[i] != 0);
 690
 691       unsigned int st_shndx = isym.get_st_shndx();
 692       if (st_shndx < elfcpp::SHN_LORESERVE)
 693         {
 694           gold_assert(st_shndx < mo.size());
 695           if (mo[st_shndx].output_section == NULL)
 696             continue;
 697           st_shndx = mo[st_shndx].output_section->out_shndx();
 698         }
 699
 700       elfcpp::Sym_write<size, big_endian> osym(ov);
 701
 702       gold_assert(isym.get_st_name() < strtab_size);
 703       const char* name = pnames + isym.get_st_name();
 704       osym.put_st_name(sympool->get_offset(name));
 705       osym.put_st_value(this->local_values_[i]);
 706       osym.put_st_size(isym.get_st_size());
 707       osym.put_st_info(isym.get_st_info());
 708       osym.put_st_other(isym.get_st_other());
 709       osym.put_st_shndx(st_shndx);
 710
 711       ov += sym_size;
 712     }
 713
 714   gold_assert(ov - oview == output_size);
 715
 716   of->write_output_view(this->local_symbol_offset_, output_size, oview);
 717 }
 718
 719 // Input_objects methods.
 720
 721 // Add a regular relocatable object to the list.  Return false if this
 722 // object should be ignored.
 723
 724 bool
 725 Input_objects::add_object(Object* obj)
 726 {
 727   if (!obj->is_dynamic())
 728     this->relobj_list_.push_back(static_cast<Relobj*>(obj));
 729   else
 730     {
 731       // See if this is a duplicate SONAME.
 732       Dynobj* dynobj = static_cast<Dynobj*>(obj);
 733
 734       std::pair<Unordered_set<std::string>::iterator, bool> ins =
 735         this->sonames_.insert(dynobj->soname());
 736       if (!ins.second)
 737         {
 738           // We have already seen a dynamic object with this soname.
 739           return false;
 740         }
 741
 742       this->dynobj_list_.push_back(dynobj);
 743     }
 744
 745   Target* target = obj->target();
 746   if (this->target_ == NULL)
 747     this->target_ = target;
 748   else if (this->target_ != target)
 749     {
 750       fprintf(stderr, "%s: %s: incompatible target\n",
 751               program_name, obj->name().c_str());
 752       gold_exit(false);
 753     }
 754
 755   return true;
 756 }
 757
 758 // Relocate_info methods.
 759
 760 // Return a string describing the location of a relocation.  This is
 761 // only used in error messages.
 762
 763 template<int size, bool big_endian>
 764 std::string
 765 Relocate_info<size, big_endian>::location(size_t relnum, off_t) const
 766 {
 767   std::string ret(this->object->name());
 768   ret += ": reloc ";
 769   char buf[100];
 770   snprintf(buf, sizeof buf, "%zu", relnum);
 771   ret += buf;
 772   ret += " in reloc section ";
 773   snprintf(buf, sizeof buf, "%u", this->reloc_shndx);
 774   ret += buf;
 775   ret += " (" + this->object->section_name(this->reloc_shndx);
 776   ret += ") for section ";
 777   snprintf(buf, sizeof buf, "%u", this->data_shndx);
 778   ret += buf;
 779   ret += " (" + this->object->section_name(this->data_shndx) + ")";
 780   return ret;
 781 }
 782
 783 } // End namespace gold.
 784
 785 namespace
 786 {
 787
 788 using namespace gold;
 789
 790 // Read an ELF file with the header and return the appropriate
 791 // instance of Object.
 792
 793 template<int size, bool big_endian>
 794 Object*
 795 make_elf_sized_object(const std::string& name, Input_file* input_file,
 796                       off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
 797 {
 798   int et = ehdr.get_e_type();
 799   if (et == elfcpp::ET_REL)
 800     {
 801       Sized_relobj<size, big_endian>* obj =
 802         new Sized_relobj<size, big_endian>(name, input_file, offset, ehdr);
 803       obj->setup(ehdr);
 804       return obj;
 805     }
 806   else if (et == elfcpp::ET_DYN)
 807     {
 808       Sized_dynobj<size, big_endian>* obj =
 809         new Sized_dynobj<size, big_endian>(name, input_file, offset, ehdr);
 810       obj->setup(ehdr);
 811       return obj;
 812     }
 813   else
 814     {
 815       fprintf(stderr, _("%s: %s: unsupported ELF file type %d\n"),
 816               program_name, name.c_str(), et);
 817       gold_exit(false);
 818     }
 819 }
 820
 821 } // End anonymous namespace.
 822
 823 namespace gold
 824 {
 825
 826 // Read an ELF file and return the appropriate instance of Object.
 827
 828 Object*
 829 make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
 830                 const unsigned char* p, off_t bytes)
 831 {
 832   if (bytes < elfcpp::EI_NIDENT)
 833     {
 834       fprintf(stderr, _("%s: %s: ELF file too short\n"),
 835               program_name, name.c_str());
 836       gold_exit(false);
 837     }
 838
 839   int v = p[elfcpp::EI_VERSION];
 840   if (v != elfcpp::EV_CURRENT)
 841     {
 842       if (v == elfcpp::EV_NONE)
 843         fprintf(stderr, _("%s: %s: invalid ELF version 0\n"),
 844                 program_name, name.c_str());
 845       else
 846         fprintf(stderr, _("%s: %s: unsupported ELF version %d\n"),
 847                 program_name, name.c_str(), v);
 848       gold_exit(false);
 849     }
 850
 851   int c = p[elfcpp::EI_CLASS];
 852   if (c == elfcpp::ELFCLASSNONE)
 853     {
 854       fprintf(stderr, _("%s: %s: invalid ELF class 0\n"),
 855               program_name, name.c_str());
 856       gold_exit(false);
 857     }
 858   else if (c != elfcpp::ELFCLASS32
 859            && c != elfcpp::ELFCLASS64)
 860     {
 861       fprintf(stderr, _("%s: %s: unsupported ELF class %d\n"),
 862               program_name, name.c_str(), c);
 863       gold_exit(false);
 864     }
 865
 866   int d = p[elfcpp::EI_DATA];
 867   if (d == elfcpp::ELFDATANONE)
 868     {
 869       fprintf(stderr, _("%s: %s: invalid ELF data encoding\n"),
 870               program_name, name.c_str());
 871       gold_exit(false);
 872     }
 873   else if (d != elfcpp::ELFDATA2LSB
 874            && d != elfcpp::ELFDATA2MSB)
 875     {
 876       fprintf(stderr, _("%s: %s: unsupported ELF data encoding %d\n"),
 877               program_name, name.c_str(), d);
 878       gold_exit(false);
 879     }
 880
 881   bool big_endian = d == elfcpp::ELFDATA2MSB;
 882
 883   if (c == elfcpp::ELFCLASS32)
 884     {
 885       if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
 886         {
 887           fprintf(stderr, _("%s: %s: ELF file too short\n"),
 888                   program_name, name.c_str());
 889           gold_exit(false);
 890         }
 891       if (big_endian)
 892         {
 893           elfcpp::Ehdr<32, true> ehdr(p);
 894           return make_elf_sized_object<32, true>(name, input_file,
 895                                                  offset, ehdr);
 896         }
 897       else
 898         {
 899           elfcpp::Ehdr<32, false> ehdr(p);
 900           return make_elf_sized_object<32, false>(name, input_file,
 901                                                   offset, ehdr);
 902         }
 903     }
 904   else
 905     {
 906       if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
 907         {
 908           fprintf(stderr, _("%s: %s: ELF file too short\n"),
 909                   program_name, name.c_str());
 910           gold_exit(false);
 911         }
 912       if (big_endian)
 913         {
 914           elfcpp::Ehdr<64, true> ehdr(p);
 915           return make_elf_sized_object<64, true>(name, input_file,
 916                                                  offset, ehdr);
 917         }
 918       else
 919         {
 920           elfcpp::Ehdr<64, false> ehdr(p);
 921           return make_elf_sized_object<64, false>(name, input_file,
 922                                                   offset, ehdr);
 923         }
 924     }
 925 }
 926
 927 // Instantiate the templates we need.  We could use the configure
 928 // script to restrict this to only the ones for implemented targets.
 929
 930 template
 931 class Sized_relobj<32, false>;
 932
 933 template
 934 class Sized_relobj<32, true>;
 935
 936 template
 937 class Sized_relobj<64, false>;
 938
 939 template
 940 class Sized_relobj<64, true>;
 941
 942 template
 943 struct Relocate_info<32, false>;
 944
 945 template
 946 struct Relocate_info<32, true>;
 947
 948 template
 949 struct Relocate_info<64, false>;
 950
 951 template
 952 struct Relocate_info<64, true>;
 953
 954 } // End namespace gold.