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 <cassert>
   7 #include <list>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "elfcpp.h"
  12 #include "fileread.h"
  13 #include "target.h"
  14 #include "symtab.h"
  15
  16 namespace gold
  17 {
  18
  19 class General_options;
  20 class Stringpool;
  21 class Layout;
  22 class Output_section;
  23 class Output_file;
  24
  25 // Data to pass from read_symbols() to add_symbols().
  26
  27 struct Read_symbols_data
  28 {
  29   // Section headers.
  30   File_view* section_headers;
  31   // Section names.
  32   File_view* section_names;
  33   // Size of section name data in bytes.
  34   off_t section_names_size;
  35   // Symbol data.
  36   File_view* symbols;
  37   // Size of symbol data in bytes.
  38   off_t symbols_size;
  39   // Symbol names.
  40   File_view* symbol_names;
  41   // Size of symbol name data in bytes.
  42   off_t symbol_names_size;
  43 };
  44
  45 // Data about a single relocation section.  This is read in
  46 // read_relocs and processed in scan_relocs.
  47
  48 struct Section_relocs
  49 {
  50   // Index of reloc section.
  51   unsigned int reloc_shndx;
  52   // Index of section that relocs apply to.
  53   unsigned int data_shndx;
  54   // Contents of reloc section.
  55   File_view* contents;
  56   // Reloc section type.
  57   unsigned int sh_type;
  58   // Number of reloc entries.
  59   size_t reloc_count;
  60 };
  61
  62 // Relocations in an object file.  This is read in read_relocs and
  63 // processed in scan_relocs.
  64
  65 struct Read_relocs_data
  66 {
  67   typedef std::vector<Section_relocs> Relocs_list;
  68   // The relocations.
  69   Relocs_list relocs;
  70   // The local symbols.
  71   File_view* local_symbols;
  72 };
  73
  74 // Object is an interface which represents either a 32-bit or a 64-bit
  75 // input object.  This can be a regular object file (ET_REL) or a
  76 // shared object (ET_DYN).  The actual instantiations are
  77 // Sized_object<32> and Sized_object<64>
  78
  79 class Object
  80 {
  81  public:
  82   // NAME is the name of the object as we would report it to the user
  83   // (e.g., libfoo.a(bar.o) if this is in an archive.  INPUT_FILE is
  84   // used to read the file.  OFFSET is the offset within the input
  85   // file--0 for a .o or .so file, something else for a .a file.
  86   Object(const std::string& name, Input_file* input_file, bool is_dynamic,
  87          off_t offset = 0)
  88     : name_(name), input_file_(input_file), offset_(offset),
  89       shnum_(0), is_dynamic_(is_dynamic), target_(NULL),
  90       map_to_output_()
  91   { }
  92
  93   virtual ~Object()
  94   { }
  95
  96   // Return the name of the object as we would report it to the tuser.
  97   const std::string&
  98   name() const
  99   { return this->name_; }
 100
 101   // Return whether this is a dynamic object.
 102   bool
 103   is_dynamic() const
 104   { return this->is_dynamic_; }
 105
 106   // Return the target structure associated with this object.
 107   Target*
 108   target() const
 109   { return this->target_; }
 110
 111   // Lock the underlying file.
 112   void
 113   lock()
 114   { this->input_file_->file().lock(); }
 115
 116   // Unlock the underlying file.
 117   void
 118   unlock()
 119   { this->input_file_->file().unlock(); }
 120
 121   // Return whether the underlying file is locked.
 122   bool
 123   is_locked() const
 124   { return this->input_file_->file().is_locked(); }
 125
 126   // Return the sized target structure associated with this object.
 127   // This is like the target method but it returns a pointer of
 128   // appropriate checked type.
 129   template<int size, bool big_endian>
 130   Sized_target<size, big_endian>*
 131   sized_target(ACCEPT_SIZE_ENDIAN_ONLY);
 132
 133   // Read the symbol information.
 134   void
 135   read_symbols(Read_symbols_data* sd)
 136   { return this->do_read_symbols(sd); }
 137
 138   // Pass sections which should be included in the link to the Layout
 139   // object, and record where the sections go in the output file.
 140   void
 141   layout(Layout* lay, Read_symbols_data* sd)
 142   { this->do_layout(lay, sd); }
 143
 144   // Add symbol information to the global symbol table.
 145   void
 146   add_symbols(Symbol_table* symtab, Read_symbols_data* sd)
 147   { this->do_add_symbols(symtab, sd); }
 148
 149   // Read the relocs.
 150   void
 151   read_relocs(Read_relocs_data* rd)
 152   { return this->do_read_relocs(rd); }
 153
 154   // Scan the relocs and adjust the symbol table.
 155   void
 156   scan_relocs(const General_options& options, Symbol_table* symtab,
 157               Layout* layout, Read_relocs_data* rd)
 158   { return this->do_scan_relocs(options, symtab, layout, rd); }
 159
 160   // Initial local symbol processing: set the offset where local
 161   // symbol information will be stored; add local symbol names to
 162   // *POOL; return the offset following the local symbols.
 163   off_t
 164   finalize_local_symbols(off_t off, Stringpool* pool)
 165   { return this->do_finalize_local_symbols(off, pool); }
 166
 167   // Relocate the input sections and write out the local symbols.
 168   void
 169   relocate(const General_options& options, const Symbol_table* symtab,
 170            const Layout* layout, Output_file* of)
 171   { return this->do_relocate(options, symtab, layout, of); }
 172
 173   // Return whether an input section is being included in the link.
 174   bool
 175   is_section_included(unsigned int shnum) const
 176   {
 177     assert(shnum < this->map_to_output_.size());
 178     return this->map_to_output_[shnum].output_section != NULL;
 179   }
 180
 181   // Given a section index, return the corresponding Output_section
 182   // (which will be NULL if the section is not included in the link)
 183   // and set *POFF to the offset within that section.
 184   inline Output_section*
 185   output_section(unsigned int shnum, off_t* poff);
 186
 187   // Set the offset of an input section within its output section.
 188   void
 189   set_section_offset(unsigned int shndx, off_t off)
 190   {
 191     assert(shndx < this->map_to_output_.size());
 192     this->map_to_output_[shndx].offset = off;
 193   }
 194
 195   // Return the name of a section given a section index.  This is only
 196   // used for error messages.
 197   std::string
 198   section_name(unsigned int shnum)
 199   { return this->do_section_name(shnum); }
 200
 201  protected:
 202   // What we need to know to map an input section to an output
 203   // section.  We keep an array of these, one for each input section,
 204   // indexed by the input section number.
 205   struct Map_to_output
 206   {
 207     // The output section.  This is NULL if the input section is to be
 208     // discarded.
 209     Output_section* output_section;
 210     // The offset within the output section.
 211     off_t offset;
 212   };
 213
 214   // Read the symbols--implemented by child class.
 215   virtual void
 216   do_read_symbols(Read_symbols_data*) = 0;
 217
 218   // Add symbol information to the global symbol table--implemented by
 219   // child class.
 220   virtual void
 221   do_add_symbols(Symbol_table*, Read_symbols_data*) = 0;
 222
 223   // Read the relocs--implemented by child class.
 224   virtual void
 225   do_read_relocs(Read_relocs_data*) = 0;
 226
 227   // Scan the relocs--implemented by child class.
 228   virtual void
 229   do_scan_relocs(const General_options&, Symbol_table*, Layout*,
 230                  Read_relocs_data*) = 0;
 231
 232   // Lay out sections--implemented by child class.
 233   virtual void
 234   do_layout(Layout*, Read_symbols_data*) = 0;
 235
 236   // Finalize local symbols--implemented by child class.
 237   virtual off_t
 238   do_finalize_local_symbols(off_t, Stringpool*) = 0;
 239
 240   // Relocate the input sections and write out the local
 241   // symbols--implemented by child class.
 242   virtual void
 243   do_relocate(const General_options& options, const Symbol_table* symtab,
 244               const Layout*, Output_file* of) = 0;
 245
 246   // Get the name of a section--implemented by child class.
 247   virtual std::string
 248   do_section_name(unsigned int shnum) = 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 the number of sections.
 266   unsigned int
 267   shnum() const
 268   { return this->shnum_; }
 269
 270   // Set the number of sections.
 271   void
 272   set_shnum(int shnum)
 273   { this->shnum_ = shnum; }
 274
 275   // Set the target.
 276   void
 277   set_target(Target* target)
 278   { this->target_ = target; }
 279
 280   // Read data from the underlying file.
 281   void
 282   read(off_t start, off_t size, void* p)
 283   { this->input_file_->file().read(start + this->offset_, size, p); }
 284
 285   // Get a lasting view into the underlying file.
 286   File_view*
 287   get_lasting_view(off_t start, off_t size)
 288   {
 289     return this->input_file_->file().get_lasting_view(start + this->offset_,
 290                                                       size);
 291   }
 292
 293   // Return the vector mapping input sections to output sections.
 294   std::vector<Map_to_output>&
 295   map_to_output()
 296   { return this->map_to_output_; }
 297
 298  private:
 299   // This class may not be copied.
 300   Object(const Object&);
 301   Object& operator=(const Object&);
 302
 303   // Name of object as printed to user.
 304   std::string name_;
 305   // For reading the file.
 306   Input_file* input_file_;
 307   // Offset within the file--0 for an object file, non-0 for an
 308   // archive.
 309   off_t offset_;
 310   // Number of input sections.
 311   unsigned int shnum_;
 312   // Whether this is a dynamic object.
 313   bool is_dynamic_;
 314   // Target functions--may be NULL if the target is not known.
 315   Target* target_;
 316   // Mapping from input sections to output section.
 317   std::vector<Map_to_output> map_to_output_;
 318 };
 319
 320 // Implement sized_target inline for efficiency.  This approach breaks
 321 // static type checking, but is made safe using asserts.
 322
 323 template<int size, bool big_endian>
 324 inline Sized_target<size, big_endian>*
 325 Object::sized_target(ACCEPT_SIZE_ENDIAN_ONLY)
 326 {
 327   assert(this->target_->get_size() == size);
 328   assert(this->target_->is_big_endian() ? big_endian : !big_endian);
 329   return static_cast<Sized_target<size, big_endian>*>(this->target_);
 330 }
 331
 332 // Implement Object::output_section inline for efficiency.
 333 inline Output_section*
 334 Object::output_section(unsigned int shnum, off_t* poff)
 335 {
 336   assert(shnum < this->map_to_output_.size());
 337   const Map_to_output& mo(this->map_to_output_[shnum]);
 338   *poff = mo.offset;
 339   return mo.output_section;
 340 }
 341
 342 // A regular object file.  This is size and endian specific.
 343
 344 template<int size, bool big_endian>
 345 class Sized_object : public Object
 346 {
 347  public:
 348   Sized_object(const std::string& name, Input_file* input_file, off_t offset,
 349                const typename elfcpp::Ehdr<size, big_endian>&);
 350
 351   ~Sized_object();
 352
 353   // Set up the object file based on the ELF header.
 354   void
 355   setup(const typename elfcpp::Ehdr<size, big_endian>&);
 356
 357   // Read the symbols.
 358   void
 359   do_read_symbols(Read_symbols_data*);
 360
 361   // Add the symbols to the symbol table.
 362   void
 363   do_add_symbols(Symbol_table*, Read_symbols_data*);
 364
 365   // Read the relocs.
 366   void
 367   do_read_relocs(Read_relocs_data*);
 368
 369   // Scan the relocs and adjust the symbol table.
 370   void
 371   do_scan_relocs(const General_options&, Symbol_table*, Layout*,
 372                  Read_relocs_data*);
 373
 374   // Lay out the input sections.
 375   void
 376   do_layout(Layout*, Read_symbols_data*);
 377
 378   // Finalize the local symbols.
 379   off_t
 380   do_finalize_local_symbols(off_t, Stringpool*);
 381
 382   // Relocate the input sections and write out the local symbols.
 383   void
 384   do_relocate(const General_options& options, const Symbol_table* symtab,
 385               const Layout*, Output_file* of);
 386
 387   // Get the name of a section.
 388   std::string
 389   do_section_name(unsigned int shnum);
 390
 391   // Return the appropriate Sized_target structure.
 392   Sized_target<size, big_endian>*
 393   sized_target()
 394   {
 395     return this->Object::sized_target SELECT_SIZE_ENDIAN_NAME (
 396       SELECT_SIZE_ENDIAN_ONLY(size, big_endian));
 397   }
 398
 399  private:
 400   // This object may not be copied.
 401   Sized_object(const Sized_object&);
 402   Sized_object& operator=(const Sized_object&);
 403
 404   // For convenience.
 405   typedef Sized_object<size, big_endian> This;
 406   static const int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
 407   static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
 408   static const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
 409   typedef elfcpp::Shdr<size, big_endian> Shdr;
 410
 411   // Read the section header for section SHNUM.
 412   const unsigned char*
 413   section_header(unsigned int shnum);
 414
 415   // Whether to include a section group in the link.
 416   bool
 417   include_section_group(Layout*, unsigned int,
 418                         const elfcpp::Shdr<size, big_endian>&,
 419                         std::vector<bool>*);
 420
 421   // Whether to include a linkonce section in the link.
 422   bool
 423   include_linkonce_section(Layout*, const char*,
 424                            const elfcpp::Shdr<size, big_endian>&);
 425
 426   // Views and sizes when relocating.
 427   struct View_size
 428   {
 429     unsigned char* view;
 430     typename elfcpp::Elf_types<size>::Elf_Addr address;
 431     off_t offset;
 432     off_t view_size;
 433   };
 434
 435   typedef std::vector<View_size> Views;
 436
 437   // Write section data to the output file.  Record the views and
 438   // sizes in VIEWS for use when relocating.
 439   void
 440   write_sections(const unsigned char* pshdrs, Output_file*, Views*);
 441
 442   // Relocate the sections in the output file.
 443   void
 444   relocate_sections(const General_options& options, const Symbol_table*,
 445                     const Layout*, const unsigned char* pshdrs, Views*);
 446
 447   // Write out the local symbols.
 448   void
 449   write_local_symbols(Output_file*, const Stringpool*);
 450
 451   // If non-NULL, a view of the section header data.
 452   File_view* section_headers_;
 453   // ELF file header e_flags field.
 454   unsigned int flags_;
 455   // File offset of section header table.
 456   off_t shoff_;
 457   // Offset of SHT_STRTAB section holding section names.
 458   unsigned int shstrndx_;
 459   // Index of SHT_SYMTAB section.
 460   unsigned int symtab_shnum_;
 461   // The number of local symbols.
 462   unsigned int local_symbol_count_;
 463   // The number of local symbols which go into the output file.
 464   unsigned int output_local_symbol_count_;
 465   // The entries in the symbol table for the external symbols.
 466   Symbol** symbols_;
 467   // File offset for local symbols.
 468   off_t local_symbol_offset_;
 469   // Values of local symbols.
 470   typename elfcpp::Elf_types<size>::Elf_Addr *values_;
 471 };
 472
 473 // A class to manage the list of all objects.
 474
 475 class Input_objects
 476 {
 477  public:
 478   Input_objects()
 479     : object_list_(), target_(NULL), any_dynamic_(false)
 480   { }
 481
 482   // The type of the list of input objects.
 483   typedef std::list<Object*> Object_list;
 484
 485   // Add an object to the list.
 486   void
 487   add_object(Object*);
 488
 489   // Get the target we should use for the output file.
 490   Target*
 491   target() const
 492   { return this->target_; }
 493
 494   // Iterate over all objects.
 495   Object_list::const_iterator
 496   begin() const
 497   { return this->object_list_.begin(); }
 498
 499   Object_list::const_iterator
 500   end() const
 501   { return this->object_list_.end(); }
 502
 503   // Return whether we have seen any dynamic objects.
 504   bool
 505   any_dynamic() const
 506   { return this->any_dynamic_; }
 507
 508  private:
 509   Input_objects(const Input_objects&);
 510   Input_objects& operator=(const Input_objects&);
 511
 512   Object_list object_list_;
 513   Target* target_;
 514   bool any_dynamic_;
 515 };
 516
 517 // Some of the information we pass to the relocation routines.  We
 518 // group this together to avoid passing a dozen different arguments.
 519
 520 template<int size, bool big_endian>
 521 struct Relocate_info
 522 {
 523   // Command line options.
 524   const General_options* options;
 525   // Symbol table.
 526   const Symbol_table* symtab;
 527   // Layout.
 528   const Layout* layout;
 529   // Object being relocated.
 530   Sized_object<size, big_endian>* object;
 531   // Number of local symbols.
 532   unsigned int local_symbol_count;
 533   // Values of local symbols.
 534   typename elfcpp::Elf_types<size>::Elf_Addr *values;
 535   // Global symbols.
 536   Symbol** symbols;
 537   // Section index of relocation section.
 538   unsigned int reloc_shndx;
 539   // Section index of section being relocated.
 540   unsigned int data_shndx;
 541
 542   // Return a string showing the location of a relocation.  This is
 543   // only used for error messages.
 544   std::string
 545   location(size_t relnum, off_t reloffset) const;
 546 };
 547
 548 // Return an Object appropriate for the input file.  P is BYTES long,
 549 // and holds the ELF header.
 550
 551 extern Object*
 552 make_elf_object(const std::string& name, Input_file*,
 553                 off_t offset, const unsigned char* p,
 554                 off_t bytes);
 555
 556 } // end namespace gold
 557
 558 #endif // !defined(GOLD_OBJECT_H)