Home | History | Annotate | Download | only in gold
      1 // script-sections.h -- linker script SECTIONS for gold   -*- C++ -*-
      2 
      3 // Copyright (C) 2008-2014 Free Software Foundation, Inc.
      4 // Written by Ian Lance Taylor <iant (at) google.com>.
      5 
      6 // This file is part of gold.
      7 
      8 // This program is free software; you can redistribute it and/or modify
      9 // it under the terms of the GNU General Public License as published by
     10 // the Free Software Foundation; either version 3 of the License, or
     11 // (at your option) any later version.
     12 
     13 // This program is distributed in the hope that it will be useful,
     14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 // GNU General Public License for more details.
     17 
     18 // You should have received a copy of the GNU General Public License
     19 // along with this program; if not, write to the Free Software
     20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
     21 // MA 02110-1301, USA.
     22 
     23 // This is for the support of the SECTIONS clause in linker scripts.
     24 
     25 #ifndef GOLD_SCRIPT_SECTIONS_H
     26 #define GOLD_SCRIPT_SECTIONS_H
     27 
     28 #include <cstdio>
     29 #include <list>
     30 #include <vector>
     31 
     32 namespace gold
     33 {
     34 
     35 struct Parser_output_section_header;
     36 struct Parser_output_section_trailer;
     37 struct Input_section_spec;
     38 class Expression;
     39 class Sections_element;
     40 class Memory_region;
     41 class Phdrs_element;
     42 class Output_data;
     43 class Output_section_definition;
     44 class Output_section;
     45 class Output_segment;
     46 class Orphan_section_placement;
     47 
     48 class Script_sections
     49 {
     50  public:
     51   // This is a list, not a vector, because we insert orphan sections
     52   // in the middle.
     53   typedef std::list<Sections_element*> Sections_elements;
     54 
     55   // Logical script section types.  We map section types returned by the
     56   // parser into these since some section types have the same semantics.
     57   enum Section_type
     58   {
     59     // No section type specified.
     60     ST_NONE,
     61     // Section is NOLOAD.  We allocate space in the output but section
     62     // is not loaded in runtime.
     63     ST_NOLOAD,
     64     // No space is allocated to section.
     65     ST_NOALLOC
     66   };
     67 
     68   Script_sections();
     69 
     70   // Start a SECTIONS clause.
     71   void
     72   start_sections();
     73 
     74   // Finish a SECTIONS clause.
     75   void
     76   finish_sections();
     77 
     78   // Return whether we ever saw a SECTIONS clause.  If we did, then
     79   // all section layout needs to go through this class.
     80   bool
     81   saw_sections_clause() const
     82   { return this->saw_sections_clause_; }
     83 
     84   // Return whether we are currently processing a SECTIONS clause.
     85   bool
     86   in_sections_clause() const
     87   { return this->in_sections_clause_; }
     88 
     89   // Return whether we ever saw a PHDRS clause.  We ignore the PHDRS
     90   // clause unless we also saw a SECTIONS clause.
     91   bool
     92   saw_phdrs_clause() const
     93   { return this->saw_sections_clause_ && this->phdrs_elements_ != NULL; }
     94 
     95   // Start processing entries for an output section.
     96   void
     97   start_output_section(const char* name, size_t namelen,
     98 		       const Parser_output_section_header*);
     99 
    100   // Finish processing entries for an output section.
    101   void
    102   finish_output_section(const Parser_output_section_trailer*);
    103 
    104   // Add a data item to the current output section.
    105   void
    106   add_data(int size, bool is_signed, Expression* val);
    107 
    108   // Add a symbol to be defined.
    109   void
    110   add_symbol_assignment(const char* name, size_t length, Expression* value,
    111 			bool provide, bool hidden);
    112 
    113   // Add an assignment to the special dot symbol.
    114   void
    115   add_dot_assignment(Expression* value);
    116 
    117   // Add an assertion.
    118   void
    119   add_assertion(Expression* check, const char* message, size_t messagelen);
    120 
    121   // Add a setting for the fill value.
    122   void
    123   add_fill(Expression* val);
    124 
    125   // Add an input section specification.
    126   void
    127   add_input_section(const Input_section_spec* spec, bool keep);
    128 
    129   // Saw DATA_SEGMENT_ALIGN.
    130   void
    131   data_segment_align();
    132 
    133   // Saw DATA_SEGMENT_RELRO_END.
    134   void
    135   data_segment_relro_end();
    136 
    137   // Create any required sections.
    138   void
    139   create_sections(Layout*);
    140 
    141   // Add any symbols we are defining to the symbol table.
    142   void
    143   add_symbols_to_table(Symbol_table*);
    144 
    145   // Finalize symbol values and check assertions.
    146   void
    147   finalize_symbols(Symbol_table* symtab, const Layout* layout);
    148 
    149   // Find the name of the output section to use for an input file name
    150   // and section name.  This returns a name, and sets
    151   // *OUTPUT_SECTION_SLOT to point to the address where the actual
    152   // output section may be stored.
    153   // 1) If the input section should be discarded, this returns NULL
    154   //    and sets *OUTPUT_SECTION_SLOT to NULL.
    155   // 2) If the input section is mapped by the SECTIONS clause, this
    156   //    returns the name to use for the output section (in permanent
    157   //    storage), and sets *OUTPUT_SECTION_SLOT to point to where the
    158   //    output section should be stored.  **OUTPUT_SECTION_SLOT will be
    159   //    non-NULL if we have seen this output section already.
    160   // 3) If the input section is not mapped by the SECTIONS clause,
    161   //    this returns SECTION_NAME, and sets *OUTPUT_SECTION_SLOT to
    162   //    NULL.
    163   // PSCRIPT_SECTION_TYPE points to a location for returning the section
    164   // type specified in script.  This can be SCRIPT_SECTION_TYPE_NONE if
    165   // no type is specified.
    166   // *KEEP indicates whether the section should survive garbage collection.
    167   const char*
    168   output_section_name(const char* file_name, const char* section_name,
    169 		      Output_section*** output_section_slot,
    170 		      Section_type* pscript_section_type,
    171 		      bool* keep);
    172 
    173   // Place a marker for an orphan output section into the SECTIONS
    174   // clause.
    175   void
    176   place_orphan(Output_section* os);
    177 
    178   // Set the addresses of all the output sections.  Return the segment
    179   // which holds the file header and segment headers, if any.
    180   Output_segment*
    181   set_section_addresses(Symbol_table*, Layout*);
    182 
    183   // Add a program header definition.
    184   void
    185   add_phdr(const char* name, size_t namelen, unsigned int type,
    186 	   bool filehdr, bool phdrs, bool is_flags_valid, unsigned int flags,
    187 	   Expression* load_address);
    188 
    189   // Return the number of segments we expect to create based on the
    190   // SECTIONS clause.
    191   size_t
    192   expected_segment_count(const Layout*) const;
    193 
    194   // Add the file header and segment header to non-load segments as
    195   // specified by the PHDRS clause.
    196   void
    197   put_headers_in_phdrs(Output_data* file_header, Output_data* segment_headers);
    198 
    199   // Look for an output section by name and return the address, the
    200   // load address, the alignment, and the size.  This is used when an
    201   // expression refers to an output section which was not actually
    202   // created.  This returns true if the section was found, false
    203   // otherwise.
    204   bool
    205   get_output_section_info(const char* name, uint64_t* address,
    206                           uint64_t* load_address, uint64_t* addralign,
    207                           uint64_t* size) const;
    208 
    209   // Release all Output_segments.  This is used in relaxation.
    210   void
    211   release_segments();
    212 
    213   // Whether we ever saw a SEGMENT_START expression, the presence of which
    214   // changes the behaviour of -Ttext, -Tdata and -Tbss options.
    215   bool
    216   saw_segment_start_expression() const
    217   { return this->saw_segment_start_expression_; }
    218 
    219   // Set the flag which indicates whether we saw a SEGMENT_START expression.
    220   void
    221   set_saw_segment_start_expression(bool value)
    222   { this->saw_segment_start_expression_ = value; }
    223 
    224   // Add a memory region.
    225   void
    226   add_memory_region(const char*, size_t, unsigned int,
    227 		    Expression*, Expression*);
    228 
    229   // Find a memory region's origin.
    230   Expression*
    231   find_memory_region_origin(const char*, size_t);
    232 
    233   // Find a memory region's length.
    234   Expression*
    235   find_memory_region_length(const char*, size_t);
    236 
    237   // Find a memory region by name.
    238   Memory_region*
    239   find_memory_region(const char*, size_t);
    240 
    241   // Find a memory region that should be used by a given output section.
    242   Memory_region*
    243   find_memory_region(Output_section_definition*, bool,
    244 		     Output_section_definition**);
    245 
    246   // Returns true if the provide block of memory is contained
    247   // within a memory region.
    248   bool
    249   block_in_region(Symbol_table*, Layout*, uint64_t, uint64_t) const;
    250 
    251   // Set the memory region of the section.
    252   void
    253   set_memory_region(Memory_region*, bool);
    254 
    255   // Print the contents to the FILE.  This is for debugging.
    256   void
    257   print(FILE*) const;
    258 
    259   // Used for orphan sections.
    260   typedef Sections_elements::iterator Elements_iterator;
    261 
    262  private:
    263   typedef std::vector<Memory_region*> Memory_regions;
    264   typedef std::vector<Phdrs_element*> Phdrs_elements;
    265 
    266   // Create segments.
    267   Output_segment*
    268   create_segments(Layout*, uint64_t);
    269 
    270   // Create PT_NOTE and PT_TLS segments.
    271   void
    272   create_note_and_tls_segments(Layout*, const std::vector<Output_section*>*);
    273 
    274   // Return whether the section is a BSS section.
    275   static bool
    276   is_bss_section(const Output_section*);
    277 
    278   // Return the total size of the headers.
    279   size_t
    280   total_header_size(Layout* layout) const;
    281 
    282   // Return the amount we have to subtract from the LMA to accomodate
    283   // headers of the given size.
    284   uint64_t
    285   header_size_adjustment(uint64_t lma, size_t sizeof_headers) const;
    286 
    287   // Create the segments from a PHDRS clause.
    288   Output_segment*
    289   create_segments_from_phdrs_clause(Layout* layout, uint64_t);
    290 
    291   // Attach sections to segments from a PHDRS clause.
    292   void
    293   attach_sections_using_phdrs_clause(Layout*);
    294 
    295   // Set addresses of segments from a PHDRS clause.
    296   Output_segment*
    297   set_phdrs_clause_addresses(Layout*, uint64_t);
    298 
    299   // True if we ever saw a SECTIONS clause.
    300   bool saw_sections_clause_;
    301   // True if we are currently processing a SECTIONS clause.
    302   bool in_sections_clause_;
    303   // The list of elements in the SECTIONS clause.
    304   Sections_elements* sections_elements_;
    305   // The current output section, if there is one.
    306   Output_section_definition* output_section_;
    307   // The list of memory regions in the MEMORY clause.
    308   Memory_regions* memory_regions_;
    309   // The list of program headers in the PHDRS clause.
    310   Phdrs_elements* phdrs_elements_;
    311   // Where to put orphan sections.
    312   Orphan_section_placement* orphan_section_placement_;
    313   // A pointer to the last Sections_element when we see
    314   // DATA_SEGMENT_ALIGN.
    315   Sections_elements::iterator data_segment_align_start_;
    316   // Whether we have seen DATA_SEGMENT_ALIGN.
    317   bool saw_data_segment_align_;
    318   // Whether we have seen DATA_SEGMENT_RELRO_END.
    319   bool saw_relro_end_;
    320   // Whether we have seen SEGMENT_START.
    321   bool saw_segment_start_expression_;
    322 };
    323 
    324 // Attributes for memory regions.
    325 enum
    326 {
    327   MEM_EXECUTABLE   = (1 << 0),
    328   MEM_WRITEABLE    = (1 << 1),
    329   MEM_READABLE     = (1 << 2),
    330   MEM_ALLOCATABLE  = (1 << 3),
    331   MEM_INITIALIZED  = (1 << 4),
    332   MEM_ATTR_MASK    = (1 << 5) - 1
    333 };
    334 
    335 } // End namespace gold.
    336 
    337 #endif // !defined(GOLD_SCRIPT_SECTIONS_H
    338