gold/object.h

   1 // object.h -- support for an object file for linking in gold  -*- C++ -*-
   2
   3 #ifndef GOLD_OBJECT_H
   4 #define GOLD_OBJECT_H
   5
   6 #include <string>
   7 #include <vector>
   8
   9 #include "elfcpp.h"
  10 #include "elfcpp_file.h"
  11 #include "fileread.h"
  12 #include "target.h"
  13
  14 namespace gold
  15 {
  16
  17 class General_options;
  18 class Stringpool;
  19 class Layout;
  20 class Output_section;
  21 class Output_file;
  22 class Dynobj;
  23
  24 // Data to pass from read_symbols() to add_symbols().
  25
  26 struct Read_symbols_data
  27 {
  28   // Section headers.
  29   File_view* section_headers;
  30   // Section names.
  31   File_view* section_names;
  32   // Size of section name data in bytes.
  33   off_t section_names_size;
  34   // Symbol data.
  35   File_view* symbols;
  36   // Size of symbol data in bytes.
  37   off_t symbols_size;
  38   // Symbol names.
  39   File_view* symbol_names;
  40   // Size of symbol name data in bytes.
  41   off_t symbol_names_size;
  42
  43   // Version information.  This is only used on dynamic objects.
  44   // Version symbol data (from SHT_GNU_versym section).
  45   File_view* versym;
  46   off_t versym_size;
  47   // Version definition data (from SHT_GNU_verdef section).
  48   File_view* verdef;
  49   off_t verdef_size;
  50   unsigned int verdef_info;
  51   // Needed version data  (from SHT_GNU_verneed section).
  52   File_view* verneed;
  53   off_t verneed_size;
  54   unsigned int verneed_info;
  55 };
  56
  57 // Data about a single relocation section.  This is read in
  58 // read_relocs and processed in scan_relocs.
  59
  60 struct Section_relocs
  61 {
  62   // Index of reloc section.
  63   unsigned int reloc_shndx;
  64   // Index of section that relocs apply to.
  65   unsigned int data_shndx;
  66   // Contents of reloc section.
  67   File_view* contents;
  68   // Reloc section type.
  69   unsigned int sh_type;
  70   // Number of reloc entries.
  71   size_t reloc_count;
  72 };
  73
  74 // Relocations in an object file.  This is read in read_relocs and
  75 // processed in scan_relocs.
  76
  77 struct Read_relocs_data
  78 {
  79   typedef std::vector<Section_relocs> Relocs_list;
  80   // The relocations.
  81   Relocs_list relocs;
  82   // The local symbols.
  83   File_view* local_symbols;
  84 };
  85
  86 // Object is an abstract base class which represents either a 32-bit
  87 // or a 64-bit input object.  This can be a regular object file
  88 // (ET_REL) or a shared object (ET_DYN).
  89
  90 class Object
  91 {
  92  public:
  93   // NAME is the name of the object as we would report it to the user
  94   // (e.g., libfoo.a(bar.o) if this is in an archive.  INPUT_FILE is
  95   // used to read the file.  OFFSET is the offset within the input
  96   // file--0 for a .o or .so file, something else for a .a file.
  97   Object(const std::string& name, Input_file* input_file, bool is_dynamic,
  98          off_t offset = 0)
  99     : name_(name), input_file_(input_file), offset_(offset), shnum_(-1U),
 100       is_dynamic_(is_dynamic), target_(NULL)
 101   { }
 102
 103   virtual ~Object()
 104   { }
 105
 106   // Return the name of the object as we would report it to the tuser.
 107   const std::string&
 108   name() const
 109   { return this->name_; }
 110
 111   // Return whether this is a dynamic object.
 112   bool
 113   is_dynamic() const
 114   { return this->is_dynamic_; }
 115
 116   // Return the target structure associated with this object.
 117   Target*
 118   target() const
 119   { return this->target_; }
 120
 121   // Lock the underlying file.
 122   void
 123   lock()
 124   { this->input_file_->file().lock(); }
 125
 126   // Unlock the underlying file.
 127   void
 128   unlock()
 129   { this->input_file_->file().unlock(); }
 130
 131   // Return whether the underlying file is locked.
 132   bool
 133   is_locked() const
 134   { return this->input_file_->file().is_locked(); }
 135
 136   // Return the sized target structure associated with this object.
 137   // This is like the target method but it returns a pointer of
 138   // appropriate checked type.
 139   template<int size, bool big_endian>
 140   Sized_target<size, big_endian>*
 141   sized_target(ACCEPT_SIZE_ENDIAN_ONLY);
 142
 143   // Read the symbol information.
 144   void
 145   read_symbols(Read_symbols_data* sd)
 146   { return this->do_read_symbols(sd); }
 147
 148   // Pass sections which should be included in the link to the Layout
 149   // object, and record where the sections go in the output file.
 150   void
 151   layout(const General_options& options, Symbol_table* symtab,
 152          Layout* layout, Read_symbols_data* sd)
 153   { this->do_layout(options, symtab, layout, sd); }
 154
 155   // Add symbol information to the global symbol table.
 156   void
 157   add_symbols(Symbol_table* symtab, Read_symbols_data* sd)
 158   { this->do_add_symbols(symtab, sd); }
 159
 160   // Return a view of the contents of a section.  Set *PLEN to the
 161   // size.
 162   const unsigned char*
 163   section_contents(unsigned int shndx, off_t* plen);
 164
 165   // Return the name of a section given a section index.  This is only
 166   // used for error messages.
 167   std::string
 168   section_name(unsigned int shndx)
 169   { return this->do_section_name(shndx); }
 170
 171   // Return the section flags given a section index.
 172   uint64_t
 173   section_flags(unsigned int shndx)
 174   { return this->do_section_flags(shndx); }
 175
 176   // Functions and types for the elfcpp::Elf_file interface.  This
 177   // permit us to use Object as the File template parameter for
 178   // elfcpp::Elf_file.
 179
 180   // The View class is returned by view.  It must support a single
 181   // method, data().  This is trivial, because get_view does what we
 182   // need.
 183   class View
 184   {
 185    public:
 186     View(const unsigned char* p)
 187       : p_(p)
 188     { }
 189
 190     const unsigned char*
 191     data() const
 192     { return this->p_; }
 193
 194    private:
 195     const unsigned char* p_;
 196   };
 197
 198   // Return a View.
 199   View
 200   view(off_t file_offset, off_t data_size)
 201   { return View(this->get_view(file_offset, data_size)); }
 202
 203   // Report an error.
 204   void
 205   error(const char* format, ...) ATTRIBUTE_PRINTF_2;
 206
 207   // A location in the file.
 208   struct Location
 209   {
 210     off_t file_offset;
 211     off_t data_size;
 212
 213     Location(off_t fo, off_t ds)
 214       : file_offset(fo), data_size(ds)
 215     { }
 216   };
 217
 218   // Get a View given a Location.
 219   View view(Location loc)
 220   { return View(this->get_view(loc.file_offset, loc.data_size)); }
 221
 222  protected:
 223   // Read the symbols--implemented by child class.
 224   virtual void
 225   do_read_symbols(Read_symbols_data*) = 0;
 226
 227   // Lay out sections--implemented by child class.
 228   virtual void
 229   do_layout(const General_options&, Symbol_table*, Layout*,
 230             Read_symbols_data*) = 0;
 231
 232   // Add symbol information to the global symbol table--implemented by
 233   // child class.
 234   virtual void
 235   do_add_symbols(Symbol_table*, Read_symbols_data*) = 0;
 236
 237   // Return the location of the contents of a section.  Implemented by
 238   // child class.
 239   virtual Location
 240   do_section_contents(unsigned int shndx) = 0;
 241
 242   // Get the name of a section--implemented by child class.
 243   virtual std::string
 244   do_section_name(unsigned int shndx) = 0;
 245
 246   // Get section flags--implemented by child class.
 247   virtual uint64_t
 248   do_section_flags(unsigned int shndx) = 0;
 249
 250   // Get the file.
 251   Input_file*
 252   input_file() const
 253   { return this->input_file_; }
 254
 255   // Get the offset into the file.
 256   off_t
 257   offset() const
 258   { return this->offset_; }
 259
 260   // Get a view into the underlying file.
 261   const unsigned char*
 262   get_view(off_t start, off_t size)
 263   { return this->input_file_->file().get_view(start + this->offset_, size); }
 264
 265   // Get a lasting view into the underlying file.
 266   File_view*
 267   get_lasting_view(off_t start, off_t size)
 268   {
 269     return this->input_file_->file().get_lasting_view(start + this->offset_,
 270                                                       size);
 271   }
 272
 273   // Read data from the underlying file.
 274   void
 275   read(off_t start, off_t size, void* p)
 276   { this->input_file_->file().read(start + this->offset_, size, p); }
 277
 278   // Set the target.
 279   void
 280   set_target(int machine, int size, bool big_endian, int osabi,
 281              int abiversion);
 282
 283   // Get the number of sections.
 284   unsigned int
 285   shnum() const
 286   { return this->shnum_; }
 287
 288   // Set the number of sections.
 289   void
 290   set_shnum(int shnum)
 291   { this->shnum_ = shnum; }
 292
 293   // Functions used by both Sized_relobj and Sized_dynobj.
 294
 295   // Read the section data into a Read_symbols_data object.
 296   template<int size, bool big_endian>
 297   void
 298   read_section_data(elfcpp::Elf_file<size, big_endian, Object>*,
 299                     Read_symbols_data*);
 300
 301   // If NAME is the name of a special .gnu.warning section, arrange
 302   // for the warning to be issued.  SHNDX is the section index.
 303   // Return whether it is a warning section.
 304   bool
 305   handle_gnu_warning_section(const char* name, unsigned int shndx,
 306                              Symbol_table*);
 307
 308  private:
 309   // This class may not be copied.
 310   Object(const Object&);
 311   Object& operator=(const Object&);
 312
 313   // Name of object as printed to user.
 314   std::string name_;
 315   // For reading the file.
 316   Input_file* input_file_;
 317   // Offset within the file--0 for an object file, non-0 for an
 318   // archive.
 319   off_t offset_;
 320   // Number of input sections.
 321   unsigned int shnum_;
 322   // Whether this is a dynamic object.
 323   bool is_dynamic_;
 324   // Target functions--may be NULL if the target is not known.
 325   Target* target_;
 326 };
 327
 328 // Implement sized_target inline for efficiency.  This approach breaks
 329 // static type checking, but is made safe using asserts.
 330
 331 template<int size, bool big_endian>
 332 inline Sized_target<size, big_endian>*
 333 Object::sized_target(ACCEPT_SIZE_ENDIAN_ONLY)
 334 {
 335   gold_assert(this->target_->get_size() == size);
 336   gold_assert(this->target_->is_big_endian() ? big_endian : !big_endian);
 337   return static_cast<Sized_target<size, big_endian>*>(this->target_);
 338 }
 339
 340 // A regular object (ET_REL).  This is an abstract base class itself.
 341 // The implementations is the template class Sized_relobj.
 342
 343 class Relobj : public Object
 344 {
 345  public:
 346   Relobj(const std::string& name, Input_file* input_file, off_t offset = 0)
 347     : Object(name, input_file, false, offset)
 348   { }
 349
 350   // Read the relocs.
 351   void
 352   read_relocs(Read_relocs_data* rd)
 353   { return this->do_read_relocs(rd); }
 354
 355   // Scan the relocs and adjust the symbol table.
 356   void
 357   scan_relocs(const General_options& options, Symbol_table* symtab,
 358               Layout* layout, Read_relocs_data* rd)
 359   { return this->do_scan_relocs(options, symtab, layout, rd); }
 360
 361   // Initial local symbol processing: set the offset where local
 362   // symbol information will be stored; add local symbol names to
 363   // *POOL; return the new local symbol index.
 364   unsigned int
 365   finalize_local_symbols(unsigned int index, off_t off, Stringpool* pool)
 366   { return this->do_finalize_local_symbols(index, off, pool); }
 367
 368   // Relocate the input sections and write out the local symbols.
 369   void
 370   relocate(const General_options& options, const Symbol_table* symtab,
 371            const Layout* layout, Output_file* of)
 372   { return this->do_relocate(options, symtab, layout, of); }
 373
 374   // Return whether an input section is being included in the link.
 375   bool
 376   is_section_included(unsigned int shnum) const
 377   {
 378     gold_assert(shnum < this->map_to_output_.size());
 379     return this->map_to_output_[shnum].output_section != NULL;
 380   }
 381
 382   // Given a section index, return the corresponding Output_section
 383   // (which will be NULL if the section is not included in the link)
 384   // and set *POFF to the offset within that section.
 385   inline Output_section*
 386   output_section(unsigned int shnum, off_t* poff);
 387
 388   // Set the offset of an input section within its output section.
 389   void
 390   set_section_offset(unsigned int shndx, off_t off)
 391   {
 392     gold_assert(shndx < this->map_to_output_.size());
 393     this->map_to_output_[shndx].offset = off;
 394   }
 395
 396  protected:
 397   // What we need to know to map an input section to an output
 398   // section.  We keep an array of these, one for each input section,
 399   // indexed by the input section number.
 400   struct Map_to_output
 401   {
 402     // The output section.  This is NULL if the input section is to be
 403     // discarded.
 404     Output_section* output_section;
 405     // The offset within the output section.
 406     off_t offset;
 407   };
 408
 409   // Read the relocs--implemented by child class.
 410   virtual void
 411   do_read_relocs(Read_relocs_data*) = 0;
 412
 413   // Scan the relocs--implemented by child class.
 414   virtual void
 415   do_scan_relocs(const General_options&, Symbol_table*, Layout*,
 416                  Read_relocs_data*) = 0;
 417
 418   // Finalize local symbols--implemented by child class.
 419   virtual unsigned int
 420   do_finalize_local_symbols(unsigned int, off_t, Stringpool*) = 0;
 421
 422   // Relocate the input sections and write out the local
 423   // symbols--implemented by child class.
 424   virtual void
 425   do_relocate(const General_options& options, const Symbol_table* symtab,
 426               const Layout*, Output_file* of) = 0;
 427
 428   // Return the vector mapping input sections to output sections.
 429   std::vector<Map_to_output>&
 430   map_to_output()
 431   { return this->map_to_output_; }
 432
 433  private:
 434   // Mapping from input sections to output section.
 435   std::vector<Map_to_output> map_to_output_;
 436 };
 437
 438 // Implement Object::output_section inline for efficiency.
 439 inline Output_section*
 440 Relobj::output_section(unsigned int shnum, off_t* poff)
 441 {
 442   gold_assert(shnum < this->map_to_output_.size());
 443   const Map_to_output& mo(this->map_to_output_[shnum]);
 444   *poff = mo.offset;
 445   return mo.output_section;
 446 }
 447
 448 // A regular object file.  This is size and endian specific.
 449
 450 template<int size, bool big_endian>
 451 class Sized_relobj : public Relobj
 452 {
 453  public:
 454   typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
 455   typedef std::vector<Address> Local_values;
 456
 457   Sized_relobj(const std::string& name, Input_file* input_file, off_t offset,
 458                const typename elfcpp::Ehdr<size, big_endian>&);
 459
 460   ~Sized_relobj();
 461
 462   // Set up the object file based on the ELF header.
 463   void
 464   setup(const typename elfcpp::Ehdr<size, big_endian>&);
 465
 466   // Return the index of local symbol SYM in the ordinary symbol
 467   // table.  A value of -1U means that the symbol is not being output.
 468   unsigned int
 469   symtab_index(unsigned int sym) const
 470   {
 471     gold_assert(sym < this->local_indexes_.size());
 472     gold_assert(this->local_indexes_[sym] != 0);
 473     return this->local_indexes_[sym];
 474   }
 475
 476   // Read the symbols.
 477   void
 478   do_read_symbols(Read_symbols_data*);
 479
 480   // Lay out the input sections.
 481   void
 482   do_layout(const General_options&, Symbol_table*, Layout*,
 483             Read_symbols_data*);
 484
 485   // Add the symbols to the symbol table.
 486   void
 487   do_add_symbols(Symbol_table*, Read_symbols_data*);
 488
 489   // Read the relocs.
 490   void
 491   do_read_relocs(Read_relocs_data*);
 492
 493   // Scan the relocs and adjust the symbol table.
 494   void
 495   do_scan_relocs(const General_options&, Symbol_table*, Layout*,
 496                  Read_relocs_data*);
 497
 498   // Finalize the local symbols.
 499   unsigned int
 500   do_finalize_local_symbols(unsigned int, off_t, Stringpool*);
 501
 502   // Relocate the input sections and write out the local symbols.
 503   void
 504   do_relocate(const General_options& options, const Symbol_table* symtab,
 505               const Layout*, Output_file* of);
 506
 507   // Get the name of a section.
 508   std::string
 509   do_section_name(unsigned int shndx)
 510   { return this->elf_file_.section_name(shndx); }
 511
 512   // Return the location of the contents of a section.
 513   Object::Location
 514   do_section_contents(unsigned int shndx)
 515   { return this->elf_file_.section_contents(shndx); }
 516
 517   // Return section flags.
 518   uint64_t
 519   do_section_flags(unsigned int shndx)
 520   { return this->elf_file_.section_flags(shndx); }
 521
 522   // Return the appropriate Sized_target structure.
 523   Sized_target<size, big_endian>*
 524   sized_target()
 525   {
 526     return this->Object::sized_target
 527       SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
 528           SELECT_SIZE_ENDIAN_ONLY(size, big_endian));
 529   }
 530
 531  private:
 532   // For convenience.
 533   typedef Sized_relobj<size, big_endian> This;
 534   static const int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
 535   static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
 536   static const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
 537   typedef elfcpp::Shdr<size, big_endian> Shdr;
 538
 539   // Find the SHT_SYMTAB section, given the section headers.
 540   void
 541   find_symtab(const unsigned char* pshdrs);
 542
 543   // Whether to include a section group in the link.
 544   bool
 545   include_section_group(Layout*, unsigned int,
 546                         const elfcpp::Shdr<size, big_endian>&,
 547                         std::vector<bool>*);
 548
 549   // Whether to include a linkonce section in the link.
 550   bool
 551   include_linkonce_section(Layout*, const char*,
 552                            const elfcpp::Shdr<size, big_endian>&);
 553
 554   // Views and sizes when relocating.
 555   struct View_size
 556   {
 557     unsigned char* view;
 558     typename elfcpp::Elf_types<size>::Elf_Addr address;
 559     off_t offset;
 560     off_t view_size;
 561   };
 562
 563   typedef std::vector<View_size> Views;
 564
 565   // Write section data to the output file.  Record the views and
 566   // sizes in VIEWS for use when relocating.
 567   void
 568   write_sections(const unsigned char* pshdrs, Output_file*, Views*);
 569
 570   // Relocate the sections in the output file.
 571   void
 572   relocate_sections(const General_options& options, const Symbol_table*,
 573                     const Layout*, const unsigned char* pshdrs, Views*);
 574
 575   // Write out the local symbols.
 576   void
 577   write_local_symbols(Output_file*, const Stringpool*);
 578
 579   // General access to the ELF file.
 580   elfcpp::Elf_file<size, big_endian, Object> elf_file_;
 581   // Index of SHT_SYMTAB section.
 582   unsigned int symtab_shndx_;
 583   // The number of local symbols.
 584   unsigned int local_symbol_count_;
 585   // The number of local symbols which go into the output file.
 586   unsigned int output_local_symbol_count_;
 587   // The entries in the symbol table for the external symbols.
 588   Symbol** symbols_;
 589   // File offset for local symbols.
 590   off_t local_symbol_offset_;
 591   // Values of local symbols.
 592   Local_values local_values_;
 593   // Indexes of local symbols in the output file; -1U if not present.
 594   std::vector<unsigned int> local_indexes_;
 595 };
 596
 597 // A class to manage the list of all objects.
 598
 599 class Input_objects
 600 {
 601  public:
 602   Input_objects()
 603     : relobj_list_(), target_(NULL)
 604   { }
 605
 606   // The type of the list of input relocateable objects.
 607   typedef std::vector<Relobj*> Relobj_list;
 608   typedef Relobj_list::const_iterator Relobj_iterator;
 609
 610   // The type of the list of input dynamic objects.
 611   typedef std::vector<Dynobj*> Dynobj_list;
 612   typedef Dynobj_list::const_iterator Dynobj_iterator;
 613
 614   // Add an object to the list.
 615   void
 616   add_object(Object*);
 617
 618   // Get the target we should use for the output file.
 619   Target*
 620   target() const
 621   { return this->target_; }
 622
 623   // Iterate over all regular objects.
 624
 625   Relobj_iterator
 626   relobj_begin() const
 627   { return this->relobj_list_.begin(); }
 628
 629   Relobj_iterator
 630   relobj_end() const
 631   { return this->relobj_list_.end(); }
 632
 633   // Iterate over all dynamic objects.
 634
 635   Dynobj_iterator
 636   dynobj_begin() const
 637   { return this->dynobj_list_.begin(); }
 638
 639   Dynobj_iterator
 640   dynobj_end() const
 641   { return this->dynobj_list_.end(); }
 642
 643   // Return whether we have seen any dynamic objects.
 644   bool
 645   any_dynamic() const
 646   { return !this->dynobj_list_.empty(); }
 647
 648  private:
 649   Input_objects(const Input_objects&);
 650   Input_objects& operator=(const Input_objects&);
 651
 652   Relobj_list relobj_list_;
 653   Dynobj_list dynobj_list_;
 654   Target* target_;
 655 };
 656
 657 // Some of the information we pass to the relocation routines.  We
 658 // group this together to avoid passing a dozen different arguments.
 659
 660 template<int size, bool big_endian>
 661 struct Relocate_info
 662 {
 663   // Command line options.
 664   const General_options* options;
 665   // Symbol table.
 666   const Symbol_table* symtab;
 667   // Layout.
 668   const Layout* layout;
 669   // Object being relocated.
 670   Sized_relobj<size, big_endian>* object;
 671   // Number of local symbols.
 672   unsigned int local_symbol_count;
 673   // Values of local symbols.
 674   const typename Sized_relobj<size, big_endian>::Local_values* local_values;
 675   // Global symbols.
 676   const Symbol* const * symbols;
 677   // Section index of relocation section.
 678   unsigned int reloc_shndx;
 679   // Section index of section being relocated.
 680   unsigned int data_shndx;
 681
 682   // Return a string showing the location of a relocation.  This is
 683   // only used for error messages.
 684   std::string
 685   location(size_t relnum, off_t reloffset) const;
 686 };
 687
 688 // Return an Object appropriate for the input file.  P is BYTES long,
 689 // and holds the ELF header.
 690
 691 extern Object*
 692 make_elf_object(const std::string& name, Input_file*,
 693                 off_t offset, const unsigned char* p,
 694                 off_t bytes);
 695
 696 } // end namespace gold
 697
 698 #endif // !defined(GOLD_OBJECT_H)