gold/script-sections.h

   1 // script-sections.h -- linker script SECTIONS for gold   -*- C++ -*-
   2
   3 // Copyright (C) 2008-2020 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@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   // MATCH_INPUT_SPEC indicates whether the section should be matched
 168   // with input section specs or simply against the output section name
 169   // (i.e., for linker-created sections like .dynamic).
 170   const char*
 171   output_section_name(const char* file_name, const char* section_name,
 172                       Output_section*** output_section_slot,
 173                       Section_type* pscript_section_type,
 174                       bool* keep, bool match_input_spec);
 175
 176   // Place a marker for an orphan output section into the SECTIONS
 177   // clause.
 178   void
 179   place_orphan(Output_section* os);
 180
 181   // Set the addresses of all the output sections.  Return the segment
 182   // which holds the file header and segment headers, if any.
 183   Output_segment*
 184   set_section_addresses(Symbol_table*, Layout*);
 185
 186   // Add a program header definition.
 187   void
 188   add_phdr(const char* name, size_t namelen, unsigned int type,
 189            bool filehdr, bool phdrs, bool is_flags_valid, unsigned int flags,
 190            Expression* load_address);
 191
 192   // Return the number of segments we expect to create based on the
 193   // SECTIONS clause.
 194   size_t
 195   expected_segment_count(const Layout*) const;
 196
 197   // Add the file header and segment header to non-load segments as
 198   // specified by the PHDRS clause.
 199   void
 200   put_headers_in_phdrs(Output_data* file_header, Output_data* segment_headers);
 201
 202   // Look for an output section by name and return the address, the
 203   // load address, the alignment, and the size.  This is used when an
 204   // expression refers to an output section which was not actually
 205   // created.  This returns true if the section was found, false
 206   // otherwise.
 207   bool
 208   get_output_section_info(const char* name, uint64_t* address,
 209                           uint64_t* load_address, uint64_t* addralign,
 210                           uint64_t* size) const;
 211
 212   // Release all Output_segments.  This is used in relaxation.
 213   void
 214   release_segments();
 215
 216   // Whether we ever saw a SEGMENT_START expression, the presence of which
 217   // changes the behaviour of -Ttext, -Tdata and -Tbss options.
 218   bool
 219   saw_segment_start_expression() const
 220   { return this->saw_segment_start_expression_; }
 221
 222   // Set the flag which indicates whether we saw a SEGMENT_START expression.
 223   void
 224   set_saw_segment_start_expression(bool value)
 225   { this->saw_segment_start_expression_ = value; }
 226
 227   // Add a memory region.
 228   void
 229   add_memory_region(const char*, size_t, unsigned int,
 230                     Expression*, Expression*);
 231
 232   // Find a memory region's origin.
 233   Expression*
 234   find_memory_region_origin(const char*, size_t);
 235
 236   // Find a memory region's length.
 237   Expression*
 238   find_memory_region_length(const char*, size_t);
 239
 240   // Find a memory region by name.
 241   Memory_region*
 242   find_memory_region(const char*, size_t);
 243
 244   // Find a memory region that should be used by a given output section.
 245   Memory_region*
 246   find_memory_region(Output_section_definition*, bool, bool,
 247                      Output_section_definition**);
 248
 249   // Returns true if the provide block of memory is contained
 250   // within a memory region.
 251   bool
 252   block_in_region(Symbol_table*, Layout*, uint64_t, uint64_t) const;
 253
 254   // Set the memory region of the section.
 255   void
 256   set_memory_region(Memory_region*, bool);
 257
 258   // Print the contents to the FILE.  This is for debugging.
 259   void
 260   print(FILE*) const;
 261
 262   // Used for orphan sections.
 263   typedef Sections_elements::iterator Elements_iterator;
 264
 265  private:
 266   typedef std::vector<Memory_region*> Memory_regions;
 267   typedef std::vector<Phdrs_element*> Phdrs_elements;
 268
 269   // Create segments.
 270   Output_segment*
 271   create_segments(Layout*, uint64_t);
 272
 273   // Create PT_NOTE and PT_TLS segments.
 274   void
 275   create_note_and_tls_segments(Layout*, const std::vector<Output_section*>*);
 276
 277   // Return whether the section is a BSS section.
 278   static bool
 279   is_bss_section(const Output_section*);
 280
 281   // Return the total size of the headers.
 282   size_t
 283   total_header_size(Layout* layout) const;
 284
 285   // Return the amount we have to subtract from the LMA to accommodate
 286   // headers of the given size.
 287   uint64_t
 288   header_size_adjustment(uint64_t lma, size_t sizeof_headers) const;
 289
 290   // Create the segments from a PHDRS clause.
 291   Output_segment*
 292   create_segments_from_phdrs_clause(Layout* layout, uint64_t);
 293
 294   // Attach sections to segments from a PHDRS clause.
 295   void
 296   attach_sections_using_phdrs_clause(Layout*);
 297
 298   // Set addresses of segments from a PHDRS clause.
 299   Output_segment*
 300   set_phdrs_clause_addresses(Layout*, uint64_t);
 301
 302   // True if we ever saw a SECTIONS clause.
 303   bool saw_sections_clause_;
 304   // True if we are currently processing a SECTIONS clause.
 305   bool in_sections_clause_;
 306   // The list of elements in the SECTIONS clause.
 307   Sections_elements* sections_elements_;
 308   // The current output section, if there is one.
 309   Output_section_definition* output_section_;
 310   // The list of memory regions in the MEMORY clause.
 311   Memory_regions* memory_regions_;
 312   // The list of program headers in the PHDRS clause.
 313   Phdrs_elements* phdrs_elements_;
 314   // Where to put orphan sections.
 315   Orphan_section_placement* orphan_section_placement_;
 316   // A pointer to the last Sections_element when we see
 317   // DATA_SEGMENT_ALIGN.
 318   Sections_elements::iterator data_segment_align_start_;
 319   // Whether we have seen DATA_SEGMENT_ALIGN.
 320   bool saw_data_segment_align_;
 321   // Whether we have seen DATA_SEGMENT_RELRO_END.
 322   bool saw_relro_end_;
 323   // Whether we have seen SEGMENT_START.
 324   bool saw_segment_start_expression_;
 325   // Whether we have created all necessary segments.
 326   bool segments_created_;
 327 };
 328
 329 // Attributes for memory regions.
 330 enum
 331 {
 332   MEM_EXECUTABLE   = (1 << 0),
 333   MEM_WRITEABLE    = (1 << 1),
 334   MEM_READABLE     = (1 << 2),
 335   MEM_ALLOCATABLE  = (1 << 3),
 336   MEM_INITIALIZED  = (1 << 4),
 337   MEM_ATTR_MASK    = (1 << 5) - 1
 338 };
 339
 340 } // End namespace gold.
 341
 342 #endif // !defined(GOLD_SCRIPT_SECTIONS_H