Home | History | Annotate | Download | only in gold
      1 /* script-c.h -- C interface for linker scripts in gold.  */
      2 
      3 /* Copyright (C) 2006-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 file exists so that both the bison parser and script.cc can
     24    include it, so that they can communicate back and forth.  */
     25 
     26 #ifndef GOLD_SCRIPT_C_H
     27 #define GOLD_SCRIPT_C_H
     28 
     29 #ifdef __cplusplus
     30 #include <vector>
     31 #include <string>
     32 #endif
     33 
     34 #ifdef __cplusplus
     35 
     36 // For the C++ code we declare the various supporting structures in
     37 // the gold namespace.  For the C code we declare it at the top level.
     38 // The namespace level should not affect the layout of the structure.
     39 
     40 namespace gold
     41 {
     42 #endif
     43 
     44 /* A string value for the bison parser.  */
     45 
     46 struct Parser_string
     47 {
     48   const char* value;
     49   size_t length;
     50 };
     51 
     52 /* The expression functions deal with pointers to Expression objects.
     53    Since the bison parser generates C code, this is a hack to keep the
     54    C++ code type safe.  This hacks assumes that all pointers look
     55    alike.  */
     56 
     57 #ifdef __cplusplus
     58 class Expression;
     59 typedef Expression* Expression_ptr;
     60 #else
     61 typedef void* Expression_ptr;
     62 #endif
     63 
     64 /* Script_section type.  */
     65 enum Script_section_type
     66 {
     67   /* No section type.  */
     68   SCRIPT_SECTION_TYPE_NONE,
     69   SCRIPT_SECTION_TYPE_NOLOAD,
     70   SCRIPT_SECTION_TYPE_DSECT,
     71   SCRIPT_SECTION_TYPE_COPY,
     72   SCRIPT_SECTION_TYPE_INFO,
     73   SCRIPT_SECTION_TYPE_OVERLAY
     74 };
     75 
     76 /* A constraint for whether to use a particular output section
     77    definition.  */
     78 
     79 enum Section_constraint
     80 {
     81   /* No constraint.  */
     82   CONSTRAINT_NONE,
     83   /* Only if all input sections are read-only.  */
     84   CONSTRAINT_ONLY_IF_RO,
     85   /* Only if at least input section is writable.  */
     86   CONSTRAINT_ONLY_IF_RW,
     87   /* Special constraint.  */
     88   CONSTRAINT_SPECIAL
     89 };
     90 
     91 /* The information we store for an output section header in the bison
     92    parser.  */
     93 
     94 struct Parser_output_section_header
     95 {
     96   /* The address.  This may be NULL.  */
     97   Expression_ptr address;
     98   /* Section type.  May be NULL string.  */
     99   enum Script_section_type section_type;
    100   /* The load address, from the AT specifier.  This may be NULL.  */
    101   Expression_ptr load_address;
    102   /* The alignment, from the ALIGN specifier.  This may be NULL.  */
    103   Expression_ptr align;
    104   /* The input section alignment, from the SUBALIGN specifier.  This
    105      may be NULL.  */
    106   Expression_ptr subalign;
    107   /* A constraint on this output section.  */
    108   enum Section_constraint constraint;
    109 };
    110 
    111 /* We keep vectors of strings.  In order to manage this in both C and
    112    C++, we use a pointer to a vector.  This assumes that all pointers
    113    look the same.  */
    114 
    115 #ifdef __cplusplus
    116 typedef std::vector<std::string> String_list;
    117 typedef String_list* String_list_ptr;
    118 #else
    119 typedef void* String_list_ptr;
    120 #endif
    121 
    122 /* The information we store for an output section trailer in the bison
    123    parser.  */
    124 
    125 struct Parser_output_section_trailer
    126 {
    127   /* The fill value.  This may be NULL.  */
    128   Expression_ptr fill;
    129   /* The program segments this section should go into.  This may be
    130      NULL.  */
    131   String_list_ptr phdrs;
    132 };
    133 
    134 /* The different sorts we can find in a linker script.  */
    135 
    136 enum Sort_wildcard
    137 {
    138   SORT_WILDCARD_NONE,
    139   SORT_WILDCARD_BY_NAME,
    140   SORT_WILDCARD_BY_ALIGNMENT,
    141   SORT_WILDCARD_BY_NAME_BY_ALIGNMENT,
    142   SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
    143 };
    144 
    145 /* The information we build for a single wildcard specification.  */
    146 
    147 struct Wildcard_section
    148 {
    149   /* The wildcard spec itself.  */
    150   struct Parser_string name;
    151   /* How the entries should be sorted.  */
    152   enum Sort_wildcard sort;
    153 };
    154 
    155 /* A vector of Wildcard_section entries.  */
    156 
    157 #ifdef __cplusplus
    158 typedef std::vector<Wildcard_section> String_sort_list;
    159 typedef String_sort_list* String_sort_list_ptr;
    160 #else
    161 typedef void* String_sort_list_ptr;
    162 #endif
    163 
    164 /* A list of wildcard specifications, which may include EXCLUDE_FILE
    165    clauses.  */
    166 
    167 struct Wildcard_sections
    168 {
    169   /* Wildcard specs.  */
    170   String_sort_list_ptr sections;
    171   /* Exclusions.  */
    172   String_list_ptr exclude;
    173 };
    174 
    175 /* A complete input section specification.  */
    176 
    177 struct Input_section_spec
    178 {
    179   /* The file name.  */
    180   struct Wildcard_section file;
    181   /* The list of sections.  */
    182   struct Wildcard_sections input_sections;
    183 };
    184 
    185 /* Information for a program header.  */
    186 
    187 struct Phdr_info
    188 {
    189   /* A boolean value: whether to include the file header.  */
    190   int includes_filehdr;
    191   /* A boolean value: whether to include the program headers.  */
    192   int includes_phdrs;
    193   /* A boolean value: whether the flags field is valid.  */
    194   int is_flags_valid;
    195   /* The value to use for the flags.  */
    196   unsigned int flags;
    197   /* The load address.  */
    198   Expression_ptr load_address;
    199 };
    200 
    201 struct Version_dependency_list;
    202 struct Version_expression_list;
    203 struct Version_tree;
    204 
    205 #ifdef __cplusplus
    206 extern "C" {
    207 #endif
    208 
    209 /* The bison parser definitions.  */
    210 
    211 #include "yyscript.h"
    212 
    213 /* The bison parser function.  */
    214 
    215 extern int
    216 yyparse(void* closure);
    217 
    218 /* Called by the bison parser skeleton to return the next token.  */
    219 
    220 extern int
    221 yylex(YYSTYPE*, void* closure);
    222 
    223 /* Called by the bison parser skeleton to report an error.  */
    224 
    225 extern void
    226 yyerror(void* closure, const char*);
    227 
    228 /* Called by the bison parser to add an external symbol (a symbol in
    229    an EXTERN declaration) to the link.  */
    230 
    231 extern void
    232 script_add_extern(void* closure, const char*, size_t);
    233 
    234 /* Called by the bison parser to add a file to the link.  */
    235 
    236 extern void
    237 script_add_file(void* closure, const char*, size_t);
    238 
    239 /* Called by the bison parser to add a library to the link.  */
    240 
    241 extern void
    242 script_add_library(void* closure, const char*, size_t);
    243 
    244 /* Called by the bison parser to start and stop a group.  */
    245 
    246 extern void
    247 script_start_group(void* closure);
    248 extern void
    249 script_end_group(void* closure);
    250 
    251 /* Called by the bison parser to start and end an AS_NEEDED list.  */
    252 
    253 extern void
    254 script_start_as_needed(void* closure);
    255 extern void
    256 script_end_as_needed(void* closure);
    257 
    258 /* Called by the bison parser to set the entry symbol.  */
    259 
    260 extern void
    261 script_set_entry(void* closure, const char*, size_t);
    262 
    263 /* Called by the bison parser to set whether to define common symbols.  */
    264 
    265 extern void
    266 script_set_common_allocation(void* closure, int);
    267 
    268 /* Called by the bison parser to parse an OPTION.  */
    269 
    270 extern void
    271 script_parse_option(void* closure, const char*, size_t);
    272 
    273 /* Called by the bison parser to handle OUTPUT_FORMAT.  This return 0
    274    if the parse should be aborted.  */
    275 
    276 extern int
    277 script_check_output_format(void* closure, const char*, size_t,
    278 			   const char*, size_t, const char*, size_t);
    279 
    280 /* Called by the bison parser to handle TARGET.  */
    281 extern void
    282 script_set_target(void* closure, const char*, size_t);
    283 
    284 /* Called by the bison parser to handle SEARCH_DIR.  */
    285 
    286 extern void
    287 script_add_search_dir(void* closure, const char*, size_t);
    288 
    289 /* Called by the bison parser to push the lexer into expression
    290    mode.  */
    291 
    292 extern void
    293 script_push_lex_into_expression_mode(void* closure);
    294 
    295 /* Called by the bison parser to push the lexer into version
    296    mode.  */
    297 
    298 extern void
    299 script_push_lex_into_version_mode(void* closure);
    300 
    301 /* Called by the bison parser to pop the lexer mode.  */
    302 
    303 extern void
    304 script_pop_lex_mode(void* closure);
    305 
    306 /* Called by the bison parser to get the value of a symbol.  This is
    307    called for a reference to a symbol, but is not called for something
    308    like "sym += 10".  Uses of the special symbol "." can just call
    309    script_exp_string.  */
    310 
    311 extern Expression_ptr
    312 script_symbol(void* closure, const char*, size_t);
    313 
    314 /* Called by the bison parser to set a symbol to a value.  PROVIDE is
    315    non-zero if the symbol should be provided--only defined if there is
    316    an undefined reference.  HIDDEN is non-zero if the symbol should be
    317    hidden.  */
    318 
    319 extern void
    320 script_set_symbol(void* closure, const char*, size_t, Expression_ptr,
    321 		  int provide, int hidden);
    322 
    323 /* Called by the bison parser to add an assertion.  */
    324 
    325 extern void
    326 script_add_assertion(void* closure, Expression_ptr, const char* message,
    327 		     size_t messagelen);
    328 
    329 /* Called by the bison parser to start a SECTIONS clause.  */
    330 
    331 extern void
    332 script_start_sections(void* closure);
    333 
    334 /* Called by the bison parser to finish a SECTIONS clause.  */
    335 
    336 extern void
    337 script_finish_sections(void* closure);
    338 
    339 /* Called by the bison parser to start handling input section
    340    specifications for an output section.  */
    341 
    342 extern void
    343 script_start_output_section(void* closure, const char* name, size_t namelen,
    344 			    const struct Parser_output_section_header*);
    345 
    346 /* Called by the bison parser when done handling input section
    347    specifications for an output section.  */
    348 
    349 extern void
    350 script_finish_output_section(void* closure,
    351 			     const struct Parser_output_section_trailer*);
    352 
    353 /* Called by the bison parser to handle a data statement (LONG, BYTE,
    354    etc.) in an output section.  */
    355 
    356 extern void
    357 script_add_data(void* closure, int data_token, Expression_ptr val);
    358 
    359 /* Called by the bison parser to set the fill value in an output
    360    section.  */
    361 
    362 extern void
    363 script_add_fill(void* closure, Expression_ptr val);
    364 
    365 /* Called by the bison parser to add an input section specification to
    366    an output section.  The KEEP parameter is non-zero if this is
    367    within a KEEP clause, meaning that the garbage collector should not
    368    discard it.  */
    369 
    370 extern void
    371 script_add_input_section(void* closure, const struct Input_section_spec*,
    372 			 int keep);
    373 
    374 /* Create a new list of string and sort entries.  */
    375 
    376 extern String_sort_list_ptr
    377 script_new_string_sort_list(const struct Wildcard_section*);
    378 
    379 /* Add an entry to a list of string and sort entries.  */
    380 
    381 extern String_sort_list_ptr
    382 script_string_sort_list_add(String_sort_list_ptr,
    383 			    const struct Wildcard_section*);
    384 
    385 /* Create a new list of strings.  */
    386 
    387 extern String_list_ptr
    388 script_new_string_list(const char*, size_t);
    389 
    390 /* Add an element to a list of strings.  */
    391 
    392 extern String_list_ptr
    393 script_string_list_push_back(String_list_ptr, const char*, size_t);
    394 
    395 /* Concatenate two string lists.  */
    396 
    397 extern String_list_ptr
    398 script_string_list_append(String_list_ptr, String_list_ptr);
    399 
    400 /* Define a new program header.  */
    401 
    402 extern void
    403 script_add_phdr(void* closure, const char* name, size_t namelen,
    404 		unsigned int type, const struct Phdr_info*);
    405 
    406 /* Convert a program header string to a type.  */
    407 
    408 extern unsigned int
    409 script_phdr_string_to_type(void* closure, const char*, size_t);
    410 
    411 /* Handle DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END.  */
    412 
    413 extern void
    414 script_data_segment_align(void* closure);
    415 
    416 extern void
    417 script_data_segment_relro_end(void* closure);
    418 
    419 /* Record the fact that a SEGMENT_START expression is seen.  */
    420 
    421 extern void
    422 script_saw_segment_start_expression(void* closure);
    423 
    424 /* Called by the bison parser for MEMORY regions.  */
    425 
    426 extern void
    427 script_add_memory(void*, const char*, size_t, unsigned int,
    428 		  Expression_ptr, Expression_ptr);
    429 
    430 extern unsigned int
    431 script_parse_memory_attr(void*, const char*, size_t, int);
    432 
    433 extern void
    434 script_set_section_region(void*, const char*, size_t, int);
    435 
    436 extern void
    437 script_include_directive(int, void *, const char*, size_t);
    438 
    439 /* Called by the bison parser for expressions.  */
    440 
    441 extern Expression_ptr
    442 script_exp_unary_minus(Expression_ptr);
    443 extern Expression_ptr
    444 script_exp_unary_logical_not(Expression_ptr);
    445 extern Expression_ptr
    446 script_exp_unary_bitwise_not(Expression_ptr);
    447 extern Expression_ptr
    448 script_exp_binary_mult(Expression_ptr, Expression_ptr);
    449 extern Expression_ptr
    450 script_exp_binary_div(Expression_ptr, Expression_ptr);
    451 extern Expression_ptr
    452 script_exp_binary_mod(Expression_ptr, Expression_ptr);
    453 extern Expression_ptr
    454 script_exp_binary_add(Expression_ptr, Expression_ptr);
    455 extern Expression_ptr
    456 script_exp_binary_sub(Expression_ptr, Expression_ptr);
    457 extern Expression_ptr
    458 script_exp_binary_lshift(Expression_ptr, Expression_ptr);
    459 extern Expression_ptr
    460 script_exp_binary_rshift(Expression_ptr, Expression_ptr);
    461 extern Expression_ptr
    462 script_exp_binary_eq(Expression_ptr, Expression_ptr);
    463 extern Expression_ptr
    464 script_exp_binary_ne(Expression_ptr, Expression_ptr);
    465 extern Expression_ptr
    466 script_exp_binary_le(Expression_ptr, Expression_ptr);
    467 extern Expression_ptr
    468 script_exp_binary_ge(Expression_ptr, Expression_ptr);
    469 extern Expression_ptr
    470 script_exp_binary_lt(Expression_ptr, Expression_ptr);
    471 extern Expression_ptr
    472 script_exp_binary_gt(Expression_ptr, Expression_ptr);
    473 extern Expression_ptr
    474 script_exp_binary_bitwise_and(Expression_ptr, Expression_ptr);
    475 extern Expression_ptr
    476 script_exp_binary_bitwise_xor(Expression_ptr, Expression_ptr);
    477 extern Expression_ptr
    478 script_exp_binary_bitwise_or(Expression_ptr, Expression_ptr);
    479 extern Expression_ptr
    480 script_exp_binary_logical_and(Expression_ptr, Expression_ptr);
    481 extern Expression_ptr
    482 script_exp_binary_logical_or(Expression_ptr, Expression_ptr);
    483 extern Expression_ptr
    484 script_exp_trinary_cond(Expression_ptr, Expression_ptr, Expression_ptr);
    485 extern Expression_ptr
    486 script_exp_integer(uint64_t);
    487 extern Expression_ptr
    488 script_exp_string(const char*, size_t);
    489 extern Expression_ptr
    490 script_exp_function_max(Expression_ptr, Expression_ptr);
    491 extern Expression_ptr
    492 script_exp_function_min(Expression_ptr, Expression_ptr);
    493 extern Expression_ptr
    494 script_exp_function_defined(const char*, size_t);
    495 extern Expression_ptr
    496 script_exp_function_sizeof_headers(void);
    497 extern Expression_ptr
    498 script_exp_function_alignof(const char*, size_t);
    499 extern Expression_ptr
    500 script_exp_function_sizeof(const char*, size_t);
    501 extern Expression_ptr
    502 script_exp_function_addr(const char*, size_t);
    503 extern Expression_ptr
    504 script_exp_function_loadaddr(const char*, size_t);
    505 extern Expression_ptr
    506 script_exp_function_origin(void*, const char*, size_t);
    507 extern Expression_ptr
    508 script_exp_function_length(void*, const char*, size_t);
    509 extern Expression_ptr
    510 script_exp_function_constant(const char*, size_t);
    511 extern Expression_ptr
    512 script_exp_function_absolute(Expression_ptr);
    513 extern Expression_ptr
    514 script_exp_function_align(Expression_ptr, Expression_ptr);
    515 extern Expression_ptr
    516 script_exp_function_data_segment_align(Expression_ptr, Expression_ptr);
    517 extern Expression_ptr
    518 script_exp_function_data_segment_relro_end(Expression_ptr, Expression_ptr);
    519 extern Expression_ptr
    520 script_exp_function_data_segment_end(Expression_ptr);
    521 extern Expression_ptr
    522 script_exp_function_segment_start(const char*, size_t, Expression_ptr);
    523 extern Expression_ptr
    524 script_exp_function_assert(Expression_ptr, const char*, size_t);
    525 
    526 extern void
    527 script_register_vers_node(void* closure,
    528 			  const char* tag,
    529 			  int taglen,
    530 			  struct Version_tree*,
    531 			  struct Version_dependency_list*);
    532 
    533 extern struct Version_dependency_list*
    534 script_add_vers_depend(void* closure,
    535 		       struct Version_dependency_list* existing_dependencies,
    536 		       const char* depend_to_add, int deplen);
    537 
    538 extern struct Version_expression_list*
    539 script_new_vers_pattern(void* closure,
    540 			struct Version_expression_list*,
    541 			const char*, int, int);
    542 
    543 extern struct Version_expression_list*
    544 script_merge_expressions(struct Version_expression_list* a,
    545                          struct Version_expression_list* b);
    546 
    547 extern struct Version_tree*
    548 script_new_vers_node(void* closure,
    549 		     struct Version_expression_list* global,
    550 		     struct Version_expression_list* local);
    551 
    552 extern void
    553 version_script_push_lang(void* closure, const char* lang, int langlen);
    554 
    555 extern void
    556 version_script_pop_lang(void* closure);
    557 
    558 #ifdef __cplusplus
    559 } // End extern "C"
    560 #endif
    561 
    562 #ifdef __cplusplus
    563 } // End namespace gold.
    564 #endif
    565 
    566 #endif /* !defined(GOLD_SCRIPT_C_H) */
    567