gold/output.h

   1 // output.h -- manage the output file for gold   -*- C++ -*-
   2
   3 #ifndef GOLD_OUTPUT_H
   4 #define GOLD_OUTPUT_H
   5
   6 #include <cassert>
   7 #include <list>
   8
   9 #include "elfcpp.h"
  10 #include "layout.h"
  11
  12 namespace gold
  13 {
  14
  15 class Object;
  16 class Output_file;
  17
  18 template<int size, bool big_endian>
  19 class Sized_target;
  20
  21 // An abtract class for data which has to go into the output file.
  22
  23 class Output_data
  24 {
  25  public:
  26   explicit Output_data(off_t data_size = 0)
  27     : address_(0), data_size_(data_size), offset_(0)
  28   { }
  29
  30   virtual
  31   ~Output_data();
  32
  33   // Return the address.
  34   uint64_t
  35   address() const
  36   { return this->address_; }
  37
  38   // Return the size of the data.
  39   off_t
  40   data_size() const
  41   { return this->data_size_; }
  42
  43   // Return the file offset.
  44   off_t
  45   offset() const
  46   { return this->offset_; }
  47
  48   // Return the required alignment.
  49   uint64_t
  50   addralign() const
  51   { return this->do_addralign(); }
  52
  53   // Return whether this is an Output_section.
  54   bool
  55   is_section() const
  56   { return this->do_is_section(); }
  57
  58   // Return whether this is an Output_section of the specified type.
  59   bool
  60   is_section_type(elfcpp::Elf_Word stt) const
  61   { return this->do_is_section_type(stt); }
  62
  63   // Return whether this is an Output_section with the specified flag
  64   // set.
  65   bool
  66   is_section_flag_set(elfcpp::Elf_Xword shf) const
  67   { return this->do_is_section_flag_set(shf); }
  68
  69   // Set the address and file offset of this data.
  70   void
  71   set_address(uint64_t addr, off_t off);
  72
  73   // Write the data to the output file.
  74   void
  75   write(Output_file* file)
  76   { this->do_write(file); }
  77
  78  protected:
  79   // Functions that child classes may or in some cases must implement.
  80
  81   // Write the data to the output file.
  82   virtual void
  83   do_write(Output_file*) = 0;
  84
  85   // Return the required alignment.
  86   virtual uint64_t
  87   do_addralign() const = 0;
  88
  89   // Return whether this is an Output_section.
  90   virtual bool
  91   do_is_section() const
  92   { return false; }
  93
  94   // Return whether this is an Output_section of the specified type.
  95   // This only needs to be implement by Output_section.
  96   virtual bool
  97   do_is_section_type(elfcpp::Elf_Word) const
  98   { return false; }
  99
 100   // Return whether this is an Output_section with the specific flag
 101   // set.  This only needs to be implemented by Output_section.
 102   virtual bool
 103   do_is_section_flag_set(elfcpp::Elf_Xword) const
 104   { return false; }
 105
 106   // Set the address and file offset of the data.  This only needs to
 107   // be implemented if the child needs to know.
 108   virtual void
 109   do_set_address(uint64_t, off_t)
 110   { }
 111
 112   // Functions that child classes may call.
 113
 114   // Set the size of the data.
 115   void
 116   set_data_size(off_t data_size)
 117   { this->data_size_ = data_size; }
 118
 119   // Return default alignment for a size--32 or 64.
 120   static uint64_t
 121   default_alignment(int size);
 122
 123  private:
 124   Output_data(const Output_data&);
 125   Output_data& operator=(const Output_data&);
 126
 127   // Memory address in file (not always meaningful).
 128   uint64_t address_;
 129   // Size of data in file.
 130   off_t data_size_;
 131   // Offset within file.
 132   off_t offset_;
 133 };
 134
 135 // A simple case of Output_data in which we have constant data to
 136 // output.
 137
 138 class Output_data_const : public Output_data
 139 {
 140  public:
 141   Output_data_const(const std::string& data, uint64_t addralign)
 142     : Output_data(data.size()), data_(data), addralign_(addralign)
 143   { }
 144
 145   Output_data_const(const char* p, off_t len, uint64_t addralign)
 146     : Output_data(len), data_(p, len), addralign_(addralign)
 147   { }
 148
 149   // Write the data to the file.
 150   void
 151   do_write(Output_file* output);
 152
 153   // Return the required alignment.
 154   uint64_t
 155   do_addralign() const
 156   { return this->addralign_; }
 157
 158  private:
 159   std::string data_;
 160   uint64_t addralign_;
 161 };
 162
 163 // Output the section headers.
 164
 165 class Output_section_headers : public Output_data
 166 {
 167  public:
 168   Output_section_headers(int size,
 169                          const Layout::Segment_list&,
 170                          const Layout::Section_list&);
 171
 172   // Write the data to the file.
 173   void
 174   do_write(Output_file*);
 175
 176   // Return the required alignment.
 177   uint64_t
 178   do_addralign() const
 179   { return Output_data::default_alignment(this->size_); }
 180
 181  private:
 182   int size_;
 183   const Layout::Segment_list& segment_list_;
 184   const Layout::Section_list& section_list_;
 185 };
 186
 187 // Output the segment headers.
 188
 189 class Output_segment_headers : public Output_data
 190 {
 191  public:
 192   Output_segment_headers(int size, const Layout::Segment_list& segment_list)
 193     : size_(size), segment_list_(segment_list)
 194   { }
 195
 196   // Write the data to the file.
 197   void
 198   do_write(Output_file*);
 199
 200   // Return the required alignment.
 201   uint64_t
 202   do_addralign() const
 203   { return Output_data::default_alignment(this->size_); }
 204
 205  private:
 206   int size_;
 207   const Layout::Segment_list& segment_list_;
 208 };
 209
 210 // Output the ELF file header.
 211
 212 class Output_file_header : public Output_data
 213 {
 214  public:
 215   Output_file_header(int size,
 216                      const General_options&,
 217                      const Target*,
 218                      const Symbol_table*,
 219                      const Output_segment_headers*);
 220
 221   // Add information about the section headers.  We lay out the ELF
 222   // file header before we create the section headers.
 223   void set_section_info(const Output_section_headers*,
 224                         const Output_section* shstrtab);
 225
 226   // Write the data to the file.
 227   void
 228   do_write(Output_file*);
 229
 230   // Return the required alignment.
 231   uint64_t
 232   do_addralign() const
 233   { return Output_data::default_alignment(this->size_); }
 234
 235   // Set the address and offset--we only implement this for error
 236   // checking.
 237   void
 238   do_set_address(uint64_t, off_t off) const
 239   { assert(off == 0); }
 240
 241  private:
 242   int size_;
 243   const General_options& options_;
 244   const Target* target_;
 245   const Symbol_table* symtab_;
 246   const Output_segment_headers* program_header_;
 247   const Output_section_headers* section_header_;
 248   const Output_section* shstrtab_;
 249 };
 250
 251 // An output section.  We don't expect to have too many output
 252 // sections, so we don't bother to do a template on the size.
 253
 254 class Output_section : public Output_data
 255 {
 256  public:
 257   // Create an output section, giving the name, type, and flags.
 258   Output_section(const char* name, elfcpp::Elf_Word, elfcpp::Elf_Xword);
 259   virtual ~Output_section();
 260
 261   // Add a new input section named NAME with header SHDR from object
 262   // OBJECT.  Return the offset within the output section.
 263   template<int size, bool big_endian>
 264   off_t
 265   add_input_section(Object* object, const char *name,
 266                     const elfcpp::Shdr<size, big_endian>& shdr);
 267
 268   // Return the section name.
 269   const char*
 270   name() const
 271   { return this->name_; }
 272
 273   // Return the section type.
 274   elfcpp::Elf_Word
 275   type() const
 276   { return this->type_; }
 277
 278   // Return the section flags.
 279   elfcpp::Elf_Xword
 280   flags() const
 281   { return this->flags_; }
 282
 283   // Return the address alignment.
 284   uint64_t
 285   addralign() const
 286   { return this->addralign_; }
 287
 288   // Write the data to the file.  For a typical Output_section, this
 289   // does nothing.  We write out the data by looping over all the
 290   // input sections.
 291   virtual void
 292   do_write(Output_file*)
 293   { }
 294
 295   // Return the address alignment--function required by parent class.
 296   uint64_t
 297   do_addralign() const
 298   { return this->addralign_; }
 299
 300   // Return whether this is an Output_section.
 301   bool
 302   do_is_section() const
 303   { return true; }
 304
 305   // Return whether this is a section of the specified type.
 306   bool
 307   do_is_section_type(elfcpp::Elf_Word type) const
 308   { return this->type_ == type; }
 309
 310   // Return whether the specified section flag is set.
 311   bool
 312   do_is_section_flag_set(elfcpp::Elf_Xword flag) const
 313   { return (this->flags_ & flag) != 0; }
 314
 315  private:
 316   // Most of these fields are only valid after layout.
 317
 318   // The name of the section.  This will point into a Stringpool.
 319   const char* name_;
 320   // The section address is in the parent class.
 321   // The section alignment.
 322   uint64_t addralign_;
 323   // The section entry size.
 324   uint64_t entsize_;
 325   // The file offset is in the parent class.
 326   // The section link field.
 327   unsigned int link_;
 328   // The section info field.
 329   unsigned int info_;
 330   // The section type.
 331   elfcpp::Elf_Word type_;
 332   // The section flags.
 333   elfcpp::Elf_Xword flags_;
 334 };
 335
 336 // A special Output_section which represents the symbol table
 337 // (SHT_SYMTAB).
 338
 339 class Output_section_symtab : public Output_section
 340 {
 341  public:
 342   Output_section_symtab(const char* name, off_t size);
 343 };
 344
 345 // A special Output_section which holds a string table.
 346
 347 class Output_section_strtab : public Output_section
 348 {
 349  public:
 350   Output_section_strtab(const char* name, Stringpool* contents);
 351
 352   // Write out the data.
 353   void
 354   do_write(Output_file*);
 355
 356  private:
 357   Stringpool* contents_;
 358 };
 359
 360 // An output segment.  PT_LOAD segments are built from collections of
 361 // output sections.  Other segments typically point within PT_LOAD
 362 // segments, and are built directly as needed.
 363
 364 class Output_segment
 365 {
 366  public:
 367   // Create an output segment, specifying the type and flags.
 368   Output_segment(elfcpp::Elf_Word, elfcpp::Elf_Word);
 369
 370   // Return the virtual address.
 371   uint64_t
 372   vaddr() const
 373   { return this->vaddr_; }
 374
 375   // Return the physical address.
 376   uint64_t
 377   paddr() const
 378   { return this->paddr_; }
 379
 380   // Return the segment type.
 381   elfcpp::Elf_Word
 382   type() const
 383   { return this->type_; }
 384
 385   // Return the segment flags.
 386   elfcpp::Elf_Word
 387   flags() const
 388   { return this->flags_; }
 389
 390   // Return the maximum alignment of the Output_data.
 391   uint64_t
 392   max_data_align() const;
 393
 394   // Add an Output_section to this segment.
 395   void
 396   add_output_section(Output_section*, elfcpp::Elf_Word seg_flags);
 397
 398   // Add an Output_data (which is not an Output_section) to the start
 399   // of this segment.
 400   void
 401   add_initial_output_data(Output_data*);
 402
 403   // Set the address of the segment to ADDR and the offset to *POFF
 404   // (aligned if necessary), and set the addresses and offsets of all
 405   // contained output sections accordingly.  Return the address of the
 406   // immediately following segment.  Update *POFF.  This should only
 407   // be called for a PT_LOAD segment.
 408   uint64_t
 409   set_section_addresses(uint64_t addr, off_t* poff);
 410
 411   // Set the offset of this segment based on the section.  This should
 412   // only be called for a non-PT_LOAD segment.
 413   void
 414   set_offset();
 415
 416   // Return the number of output sections.
 417   unsigned int
 418   output_section_count() const;
 419
 420  private:
 421   Output_segment(const Output_segment&);
 422   Output_segment& operator=(const Output_segment&);
 423
 424   typedef std::list<Output_data*> Output_data_list;
 425
 426   // Set the section addresses in an Output_data_list.
 427   uint64_t
 428   set_section_list_addresses(Output_data_list*, uint64_t addr, off_t* poff);
 429
 430   // Return the number of Output_sections in an Output_data_list.
 431   unsigned int
 432   output_section_count_list(const Output_data_list*) const;
 433
 434   // The list of output data with contents attached to this segment.
 435   Output_data_list output_data_;
 436   // The list of output data without contents attached to this segment.
 437   Output_data_list output_bss_;
 438   // The segment virtual address.
 439   uint64_t vaddr_;
 440   // The segment physical address.
 441   uint64_t paddr_;
 442   // The size of the segment in memory.
 443   uint64_t memsz_;
 444   // The segment alignment.
 445   uint64_t align_;
 446   // The offset of the segment data within the file.
 447   off_t offset_;
 448   // The size of the segment data in the file.
 449   off_t filesz_;
 450   // The segment type;
 451   elfcpp::Elf_Word type_;
 452   // The segment flags.
 453   elfcpp::Elf_Word flags_;
 454 };
 455
 456 // This class represents the output file.  The output file is a
 457 // collection of output segments and a collection of output sections
 458 // which are not associated with segments.
 459
 460 class Output_file
 461 {
 462  public:
 463   Output_file();
 464   ~Output_file();
 465
 466   // Write data to the output file.
 467   void
 468   write(off_t off, const void* data, off_t len);
 469 };
 470
 471 } // End namespace gold.
 472
 473 #endif // !defined(GOLD_OUTPUT_H)