OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [yyscript.y] - Blame information for rev 90

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 27 khays
/* yyscript.y -- linker script grammar for gold.  */
2
 
3
/* Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
4
   Written by Ian Lance Taylor .
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 a bison grammar to parse a subset of the original GNU ld
24
   linker script language.  */
25
 
26
%{
27
 
28
#include "config.h"
29
 
30
#include 
31
#include 
32
#include 
33
#include 
34
 
35
#include "script-c.h"
36
 
37
%}
38
 
39
/* We need to use a pure parser because we might be multi-threaded.
40
   We pass some arguments through the parser to the lexer.  */
41
 
42
%pure-parser
43
 
44
%parse-param {void* closure}
45
%lex-param {void* closure}
46
 
47
/* Since we require bison anyhow, we take advantage of it.  */
48
 
49
%error-verbose
50
 
51
/* The values associated with tokens.  */
52
 
53
%union {
54
  /* A string.  */
55
  struct Parser_string string;
56
  /* A number.  */
57
  uint64_t integer;
58
  /* An expression.  */
59
  Expression_ptr expr;
60
  /* An output section header.  */
61
  struct Parser_output_section_header output_section_header;
62
  /* An output section trailer.  */
63
  struct Parser_output_section_trailer output_section_trailer;
64
  /* A section constraint.  */
65
  enum Section_constraint constraint;
66
  /* A complete input section specification.  */
67
  struct Input_section_spec input_section_spec;
68
  /* A list of wildcard specifications, with exclusions.  */
69
  struct Wildcard_sections wildcard_sections;
70
  /* A single wildcard specification.  */
71
  struct Wildcard_section wildcard_section;
72
  /* A list of strings.  */
73
  String_list_ptr string_list;
74
  /* Information for a program header.  */
75
  struct Phdr_info phdr_info;
76
  /* Used for version scripts and within VERSION {}.  */
77
  struct Version_dependency_list* deplist;
78
  struct Version_expression_list* versyms;
79
  struct Version_tree* versnode;
80
  enum Script_section_type section_type;
81
}
82
 
83
/* Operators, including a precedence table for expressions.  */
84
 
85
%right PLUSEQ MINUSEQ MULTEQ DIVEQ '=' LSHIFTEQ RSHIFTEQ ANDEQ OREQ
86
%right '?' ':'
87
%left OROR
88
%left ANDAND
89
%left '|'
90
%left '^'
91
%left '&'
92
%left EQ NE
93
%left '<' '>' LE GE
94
%left LSHIFT RSHIFT
95
%left '+' '-'
96
%left '*' '/' '%'
97
 
98
/* A fake operator used to indicate unary operator precedence.  */
99
%right UNARY
100
 
101
/* Constants.  */
102
 
103
%token  STRING
104
%token  QUOTED_STRING
105
%token  INTEGER
106
 
107
/* Keywords.  This list is taken from ldgram.y and ldlex.l in the old
108
   GNU linker, with the keywords which only appear in MRI mode
109
   removed.  Not all these keywords are actually used in this grammar.
110
   In most cases the keyword is recognized as the token name in upper
111
   case.  The comments indicate where this is not the case.  */
112
 
113
%token ABSOLUTE
114
%token ADDR
115
%token ALIGN_K          /* ALIGN */
116
%token ALIGNOF
117
%token ASSERT_K         /* ASSERT */
118
%token AS_NEEDED
119
%token AT
120
%token BIND
121
%token BLOCK
122
%token BYTE
123
%token CONSTANT
124
%token CONSTRUCTORS
125
%token COPY
126
%token CREATE_OBJECT_SYMBOLS
127
%token DATA_SEGMENT_ALIGN
128
%token DATA_SEGMENT_END
129
%token DATA_SEGMENT_RELRO_END
130
%token DEFINED
131
%token DSECT
132
%token ENTRY
133
%token EXCLUDE_FILE
134
%token EXTERN
135
%token FILL
136
%token FLOAT
137
%token FORCE_COMMON_ALLOCATION
138
%token GLOBAL           /* global */
139
%token GROUP
140
%token HLL
141
%token INCLUDE
142
%token INHIBIT_COMMON_ALLOCATION
143
%token INFO
144
%token INPUT
145
%token KEEP
146
%token LEN
147
%token LENGTH           /* LENGTH, l, len */
148
%token LOADADDR
149
%token LOCAL            /* local */
150
%token LONG
151
%token MAP
152
%token MAX_K            /* MAX */
153
%token MEMORY
154
%token MIN_K            /* MIN */
155
%token NEXT
156
%token NOCROSSREFS
157
%token NOFLOAT
158
%token NOLOAD
159
%token ONLY_IF_RO
160
%token ONLY_IF_RW
161
%token ORG
162
%token ORIGIN           /* ORIGIN, o, org */
163
%token OUTPUT
164
%token OUTPUT_ARCH
165
%token OUTPUT_FORMAT
166
%token OVERLAY
167
%token PHDRS
168
%token PROVIDE
169
%token PROVIDE_HIDDEN
170
%token QUAD
171
%token SEARCH_DIR
172
%token SECTIONS
173
%token SEGMENT_START
174
%token SHORT
175
%token SIZEOF
176
%token SIZEOF_HEADERS   /* SIZEOF_HEADERS, sizeof_headers */
177
%token SORT_BY_ALIGNMENT
178
%token SORT_BY_NAME
179
%token SPECIAL
180
%token SQUAD
181
%token STARTUP
182
%token SUBALIGN
183
%token SYSLIB
184
%token TARGET_K         /* TARGET */
185
%token TRUNCATE
186
%token VERSIONK         /* VERSION */
187
 
188
/* Keywords, part 2.  These are keywords that are unique to gold,
189
   and not present in the old GNU linker.  As before, unless the
190
   comments say otherwise, the keyword is recognized as the token
191
   name in upper case. */
192
 
193
%token OPTION
194
 
195
/* Special tokens used to tell the grammar what type of tokens we are
196
   parsing.  The token stream always begins with one of these tokens.
197
   We do this because version scripts can appear embedded within
198
   linker scripts, and because --defsym uses the expression
199
   parser.  */
200
%token PARSING_LINKER_SCRIPT
201
%token PARSING_VERSION_SCRIPT
202
%token PARSING_DEFSYM
203
%token PARSING_DYNAMIC_LIST
204
 
205
/* Non-terminal types, where needed.  */
206
 
207
%type  parse_exp exp
208
%type  opt_at opt_align opt_subalign opt_fill
209
%type  section_header opt_address_and_section_type
210
%type  section_type
211
%type  section_trailer
212
%type  opt_constraint
213
%type  opt_phdr
214
%type  data_length
215
%type  input_section_no_keep
216
%type  wildcard_sections
217
%type  wildcard_file wildcard_section
218
%type  exclude_names
219
%type  wildcard_name
220
%type  phdr_type memory_attr
221
%type  phdr_info
222
%type  vers_defns
223
%type  vers_tag
224
%type  verdep
225
%type  string
226
 
227
%%
228
 
229
/* Read the special token to see what to read next.  */
230
top:
231
          PARSING_LINKER_SCRIPT linker_script
232
        | PARSING_VERSION_SCRIPT version_script
233
        | PARSING_DEFSYM defsym_expr
234
        | PARSING_DYNAMIC_LIST dynamic_list_expr
235
        ;
236
 
237
/* A file contains a list of commands.  */
238
linker_script:
239
          linker_script file_cmd
240
        | /* empty */
241
        ;
242
 
243
/* A command which may appear at top level of a linker script.  */
244
file_cmd:
245
          EXTERN '(' extern_name_list ')'
246
        | FORCE_COMMON_ALLOCATION
247
            { script_set_common_allocation(closure, 1); }
248
        | GROUP
249
            { script_start_group(closure); }
250
          '(' input_list ')'
251
            { script_end_group(closure); }
252
        | INHIBIT_COMMON_ALLOCATION
253
            { script_set_common_allocation(closure, 0); }
254
        | INPUT '(' input_list ')'
255
        | MEMORY '{' memory_defs '}'
256
        | OPTION '(' string ')'
257
            { script_parse_option(closure, $3.value, $3.length); }
258
        | OUTPUT_FORMAT '(' string ')'
259
            {
260
              if (!script_check_output_format(closure, $3.value, $3.length,
261
                                              NULL, 0, NULL, 0))
262
                YYABORT;
263
            }
264
        | OUTPUT_FORMAT '(' string ',' string ',' string ')'
265
            {
266
              if (!script_check_output_format(closure, $3.value, $3.length,
267
                                              $5.value, $5.length,
268
                                              $7.value, $7.length))
269
                YYABORT;
270
            }
271
        | PHDRS '{' phdrs_defs '}'
272
        | SEARCH_DIR '(' string ')'
273
            { script_add_search_dir(closure, $3.value, $3.length); }
274
        | SECTIONS '{'
275
            { script_start_sections(closure); }
276
          sections_block '}'
277
            { script_finish_sections(closure); }
278
        | TARGET_K '(' string ')'
279
            { script_set_target(closure, $3.value, $3.length); }
280
        | VERSIONK '{'
281
            { script_push_lex_into_version_mode(closure); }
282
          version_script '}'
283
            { script_pop_lex_mode(closure); }
284
        | file_or_sections_cmd
285
        | ignore_cmd
286
        | ';'
287
        ;
288
 
289
/* Top level commands which we ignore.  The GNU linker uses these to
290
   select the output format, but we don't offer a choice.  Ignoring
291
   these is more-or-less OK since most scripts simply explicitly
292
   choose the default.  */
293
ignore_cmd:
294
          OUTPUT_ARCH '(' string ')'
295
        ;
296
 
297
/* A list of external undefined symbols.  We put the lexer into
298
   expression mode so that commas separate names; this is what the GNU
299
   linker does.  */
300
 
301
extern_name_list:
302
            { script_push_lex_into_expression_mode(closure); }
303
          extern_name_list_body
304
            { script_pop_lex_mode(closure); }
305
        ;
306
 
307
extern_name_list_body:
308
          string
309
            { script_add_extern(closure, $1.value, $1.length); }
310
        | extern_name_list_body string
311
            { script_add_extern(closure, $2.value, $2.length); }
312
        | extern_name_list_body ',' string
313
            { script_add_extern(closure, $3.value, $3.length); }
314
        ;
315
 
316
/* A list of input file names.  */
317
input_list:
318
          input_list_element
319
        | input_list opt_comma input_list_element
320
        ;
321
 
322
/* An input file name.  */
323
input_list_element:
324
          string
325
            { script_add_file(closure, $1.value, $1.length); }
326
        | '-' STRING
327
            { script_add_library(closure, $2.value, $2.length); }
328
        | AS_NEEDED
329
            { script_start_as_needed(closure); }
330
          '(' input_list ')'
331
            { script_end_as_needed(closure); }
332
        ;
333
 
334
/* Commands in a SECTIONS block.  */
335
sections_block:
336
          sections_block section_block_cmd
337
        | /* empty */
338
        ;
339
 
340
/* A command which may appear within a SECTIONS block.  */
341
section_block_cmd:
342
          file_or_sections_cmd
343
        | string section_header
344
            { script_start_output_section(closure, $1.value, $1.length, &$2); }
345
          '{' section_cmds '}' section_trailer
346
            { script_finish_output_section(closure, &$7); }
347
        ;
348
 
349
/* The header of an output section in a SECTIONS block--everything
350
   after the name.  */
351
section_header:
352
            { script_push_lex_into_expression_mode(closure); }
353
          opt_address_and_section_type opt_at opt_align opt_subalign
354
            { script_pop_lex_mode(closure); }
355
          opt_constraint
356
            {
357
              $$.address = $2.address;
358
              $$.section_type = $2.section_type;
359
              $$.load_address = $3;
360
              $$.align = $4;
361
              $$.subalign = $5;
362
              $$.constraint = $7;
363
            }
364
        ;
365
 
366
/* The optional address followed by the optional section type.  This
367
   is a separate nonterminal to avoid a shift/reduce conflict on
368
   '(' in section_header.  */
369
 
370
opt_address_and_section_type:
371
        ':'
372
            {
373
              $$.address = NULL;
374
              $$.section_type = SCRIPT_SECTION_TYPE_NONE;
375
            }
376
        | '(' ')' ':'
377
            {
378
              $$.address = NULL;
379
              $$.section_type = SCRIPT_SECTION_TYPE_NONE;
380
            }
381
        | exp ':'
382
            {
383
              $$.address = $1;
384
              $$.section_type = SCRIPT_SECTION_TYPE_NONE;
385
            }
386
        | exp '(' ')' ':'
387
            {
388
              $$.address = $1;
389
              $$.section_type = SCRIPT_SECTION_TYPE_NONE;
390
            }
391
        | '(' section_type ')' ':'
392
            {
393
              $$.address = NULL;
394
              $$.section_type = $2;
395
            }
396
        | exp '(' section_type ')' ':'
397
            {
398
              $$.address = $1;
399
              $$.section_type = $3;
400
            }
401
        ;
402
 
403
/* We only support NOLOAD.  */
404
section_type:
405
        NOLOAD
406
            { $$ = SCRIPT_SECTION_TYPE_NOLOAD; }
407
        | DSECT
408
            {
409
              yyerror(closure, "DSECT section type is unsupported");
410
              $$ = SCRIPT_SECTION_TYPE_DSECT;
411
            }
412
        | COPY
413
            {
414
              yyerror(closure, "COPY section type is unsupported");
415
              $$ = SCRIPT_SECTION_TYPE_COPY;
416
            }
417
        | INFO
418
            {
419
              yyerror(closure, "INFO section type is unsupported");
420
              $$ = SCRIPT_SECTION_TYPE_INFO;
421
            }
422
        | OVERLAY
423
            {
424
              yyerror(closure, "OVERLAY section type is unsupported");
425
              $$ = SCRIPT_SECTION_TYPE_OVERLAY;
426
            }
427
        ;
428
 
429
/* The address at which an output section should be loaded.  */
430
opt_at:
431
          /* empty */
432
            { $$ = NULL; }
433
        | AT '(' exp ')'
434
            { $$ = $3; }
435
        ;
436
 
437
/* The alignment of an output section.  */
438
opt_align:
439
          /* empty */
440
            { $$ = NULL; }
441
        | ALIGN_K '(' exp ')'
442
            { $$ = $3; }
443
        ;
444
 
445
/* The input section alignment within an output section.  */
446
opt_subalign:
447
          /* empty */
448
            { $$ = NULL; }
449
        | SUBALIGN '(' exp ')'
450
            { $$ = $3; }
451
        ;
452
 
453
/* A section constraint.  */
454
opt_constraint:
455
          /* empty */
456
            { $$ = CONSTRAINT_NONE; }
457
        | ONLY_IF_RO
458
            { $$ = CONSTRAINT_ONLY_IF_RO; }
459
        | ONLY_IF_RW
460
            { $$ = CONSTRAINT_ONLY_IF_RW; }
461
        | SPECIAL
462
            { $$ = CONSTRAINT_SPECIAL; }
463
        ;
464
 
465
/* The trailer of an output section in a SECTIONS block.  */
466
section_trailer:
467
          opt_memspec opt_at_memspec opt_phdr opt_fill opt_comma
468
            {
469
              $$.fill = $4;
470
              $$.phdrs = $3;
471
            }
472
        ;
473
 
474
/* A memory specification for an output section.  */
475
opt_memspec:
476
          '>' string
477
            { script_set_section_region(closure, $2.value, $2.length, 1); }
478
        | /* empty */
479
        ;
480
 
481
/* A memory specification for where to load an output section.  */
482
opt_at_memspec:
483
          AT '>' string
484
            { script_set_section_region(closure, $3.value, $3.length, 0); }
485
        | /* empty */
486
        ;
487
 
488
/* The program segment an output section should go into.  */
489
opt_phdr:
490
          opt_phdr ':' string
491
            { $$ = script_string_list_push_back($1, $3.value, $3.length); }
492
        | /* empty */
493
            { $$ = NULL; }
494
        ;
495
 
496
/* The value to use to fill an output section.  FIXME: This does not
497
   handle a string of arbitrary length.  */
498
opt_fill:
499
          '=' parse_exp
500
            { $$ = $2; }
501
        | /* empty */
502
            { $$ = NULL; }
503
        ;
504
 
505
/* Commands which may appear within the description of an output
506
   section in a SECTIONS block.  */
507
section_cmds:
508
          /* empty */
509
        | section_cmds section_cmd
510
        ;
511
 
512
/* A command which may appear within the description of an output
513
   section in a SECTIONS block.  */
514
section_cmd:
515
          assignment end
516
        | input_section_spec
517
        | data_length '(' parse_exp ')'
518
            { script_add_data(closure, $1, $3); }
519
        | ASSERT_K '(' parse_exp ',' string ')'
520
            { script_add_assertion(closure, $3, $5.value, $5.length); }
521
        | FILL '(' parse_exp ')'
522
            { script_add_fill(closure, $3); }
523
        | CONSTRUCTORS
524
            {
525
              /* The GNU linker uses CONSTRUCTORS for the a.out object
526
                 file format.  It does nothing when using ELF.  Since
527
                 some ELF linker scripts use it although it does
528
                 nothing, we accept it and ignore it.  */
529
            }
530
        | SORT_BY_NAME '(' CONSTRUCTORS ')'
531
        | ';'
532
        ;
533
 
534
/* The length of data which may appear within the description of an
535
   output section in a SECTIONS block.  */
536
data_length:
537
          QUAD
538
            { $$ = QUAD; }
539
        | SQUAD
540
            { $$ = SQUAD; }
541
        | LONG
542
            { $$ = LONG; }
543
        | SHORT
544
            { $$ = SHORT; }
545
        | BYTE
546
            { $$ = BYTE; }
547
        ;
548
 
549
/* An input section specification.  This may appear within the
550
   description of an output section in a SECTIONS block.  */
551
input_section_spec:
552
          input_section_no_keep
553
            { script_add_input_section(closure, &$1, 0); }
554
        | KEEP '(' input_section_no_keep ')'
555
            { script_add_input_section(closure, &$3, 1); }
556
        ;
557
 
558
/* An input section specification within a KEEP clause.  */
559
input_section_no_keep:
560
          string
561
            {
562
              $$.file.name = $1;
563
              $$.file.sort = SORT_WILDCARD_NONE;
564
              $$.input_sections.sections = NULL;
565
              $$.input_sections.exclude = NULL;
566
            }
567
        | wildcard_file '(' wildcard_sections ')'
568
            {
569
              $$.file = $1;
570
              $$.input_sections = $3;
571
            }
572
        ;
573
 
574
/* A wildcard file specification.  */
575
wildcard_file:
576
          wildcard_name
577
            {
578
              $$.name = $1;
579
              $$.sort = SORT_WILDCARD_NONE;
580
            }
581
        | SORT_BY_NAME '(' wildcard_name ')'
582
            {
583
              $$.name = $3;
584
              $$.sort = SORT_WILDCARD_BY_NAME;
585
            }
586
        ;
587
 
588
/* A list of wild card section specifications.  */
589
wildcard_sections:
590
          wildcard_sections opt_comma wildcard_section
591
            {
592
              $$.sections = script_string_sort_list_add($1.sections, &$3);
593
              $$.exclude = $1.exclude;
594
            }
595
        | wildcard_section
596
            {
597
              $$.sections = script_new_string_sort_list(&$1);
598
              $$.exclude = NULL;
599
            }
600
        | wildcard_sections opt_comma EXCLUDE_FILE '(' exclude_names ')'
601
            {
602
              $$.sections = $1.sections;
603
              $$.exclude = script_string_list_append($1.exclude, $5);
604
            }
605
        | EXCLUDE_FILE '(' exclude_names ')'
606
            {
607
              $$.sections = NULL;
608
              $$.exclude = $3;
609
            }
610
        ;
611
 
612
/* A single wild card specification.  */
613
wildcard_section:
614
          wildcard_name
615
            {
616
              $$.name = $1;
617
              $$.sort = SORT_WILDCARD_NONE;
618
            }
619
        | SORT_BY_NAME '(' wildcard_section ')'
620
            {
621
              $$.name = $3.name;
622
              switch ($3.sort)
623
                {
624
                case SORT_WILDCARD_NONE:
625
                  $$.sort = SORT_WILDCARD_BY_NAME;
626
                  break;
627
                case SORT_WILDCARD_BY_NAME:
628
                case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
629
                  break;
630
                case SORT_WILDCARD_BY_ALIGNMENT:
631
                case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
632
                  $$.sort = SORT_WILDCARD_BY_NAME_BY_ALIGNMENT;
633
                  break;
634
                default:
635
                  abort();
636
                }
637
            }
638
        | SORT_BY_ALIGNMENT '(' wildcard_section ')'
639
            {
640
              $$.name = $3.name;
641
              switch ($3.sort)
642
                {
643
                case SORT_WILDCARD_NONE:
644
                  $$.sort = SORT_WILDCARD_BY_ALIGNMENT;
645
                  break;
646
                case SORT_WILDCARD_BY_ALIGNMENT:
647
                case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
648
                  break;
649
                case SORT_WILDCARD_BY_NAME:
650
                case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
651
                  $$.sort = SORT_WILDCARD_BY_ALIGNMENT_BY_NAME;
652
                  break;
653
                default:
654
                  abort();
655
                }
656
            }
657
        ;
658
 
659
/* A list of file names to exclude.  */
660
exclude_names:
661
          exclude_names opt_comma wildcard_name
662
            { $$ = script_string_list_push_back($1, $3.value, $3.length); }
663
        | wildcard_name
664
            { $$ = script_new_string_list($1.value, $1.length); }
665
        ;
666
 
667
/* A single wildcard name.  We recognize '*' and '?' specially since
668
   they are expression tokens.  */
669
wildcard_name:
670
          string
671
            { $$ = $1; }
672
        | '*'
673
            {
674
              $$.value = "*";
675
              $$.length = 1;
676
            }
677
        | '?'
678
            {
679
              $$.value = "?";
680
              $$.length = 1;
681
            }
682
        ;
683
 
684
/* A command which may appear at the top level of a linker script, or
685
   within a SECTIONS block.  */
686
file_or_sections_cmd:
687
          ENTRY '(' string ')'
688
            { script_set_entry(closure, $3.value, $3.length); }
689
        | assignment end
690
        | ASSERT_K '(' parse_exp ',' string ')'
691
            { script_add_assertion(closure, $3, $5.value, $5.length); }
692
        ;
693
 
694
/* A list of MEMORY definitions.  */
695
memory_defs:
696
          memory_defs opt_comma memory_def
697
        | /* empty */
698
        ;
699
 
700
/* A single MEMORY definition.  */
701
memory_def:
702
          string memory_attr ':' memory_origin '=' parse_exp opt_comma memory_length '=' parse_exp
703
          { script_add_memory(closure, $1.value, $1.length, $2, $6, $10); }
704
        |
705
          /* LD supports an INCLUDE directive here, currently GOLD does not.  */
706
          INCLUDE string
707
          { script_include_directive(closure, $2.value, $2.length); }
708
        |
709
        ;
710
 
711
/* The (optional) attributes of a MEMORY region.  */
712
memory_attr:
713
          '(' string ')'
714
          { $$ = script_parse_memory_attr(closure, $2.value, $2.length, 0); }
715
        | /* Inverted attributes. */
716
          '(' '!' string ')'
717
          { $$ = script_parse_memory_attr(closure, $3.value, $3.length, 1); }
718
        | /* empty */
719
            { $$ = 0; }
720
        ;
721
 
722
memory_origin:
723
          ORIGIN
724
        |
725
          ORG
726
        |
727
          'o'
728
        ;
729
 
730
memory_length:
731
          LENGTH
732
        |
733
          LEN
734
        |
735
          'l'
736
        ;
737
 
738
/* A list of program header definitions.  */
739
phdrs_defs:
740
          phdrs_defs phdr_def
741
        | /* empty */
742
        ;
743
 
744
/* A program header definition.  */
745
phdr_def:
746
          string phdr_type phdr_info ';'
747
            { script_add_phdr(closure, $1.value, $1.length, $2, &$3); }
748
        ;
749
 
750
/* A program header type.  The GNU linker accepts a general expression
751
   here, but that would be a pain because we would have to dig into
752
   the expression structure.  It's unlikely that anybody uses anything
753
   other than a string or a number here, so that is all we expect.  */
754
phdr_type:
755
          string
756
            { $$ = script_phdr_string_to_type(closure, $1.value, $1.length); }
757
        | INTEGER
758
            { $$ = $1; }
759
        ;
760
 
761
/* Additional information for a program header.  */
762
phdr_info:
763
          /* empty */
764
            { memset(&$$, 0, sizeof(struct Phdr_info)); }
765
        | string phdr_info
766
            {
767
              $$ = $2;
768
              if ($1.length == 7 && strncmp($1.value, "FILEHDR", 7) == 0)
769
                $$.includes_filehdr = 1;
770
              else
771
                yyerror(closure, "PHDRS syntax error");
772
            }
773
        | PHDRS phdr_info
774
            {
775
              $$ = $2;
776
              $$.includes_phdrs = 1;
777
            }
778
        | string '(' INTEGER ')' phdr_info
779
            {
780
              $$ = $5;
781
              if ($1.length == 5 && strncmp($1.value, "FLAGS", 5) == 0)
782
                {
783
                  $$.is_flags_valid = 1;
784
                  $$.flags = $3;
785
                }
786
              else
787
                yyerror(closure, "PHDRS syntax error");
788
            }
789
        | AT '(' parse_exp ')' phdr_info
790
            {
791
              $$ = $5;
792
              $$.load_address = $3;
793
            }
794
        ;
795
 
796
/* Set a symbol to a value.  */
797
assignment:
798
          string '=' parse_exp
799
            { script_set_symbol(closure, $1.value, $1.length, $3, 0, 0); }
800
        | string PLUSEQ parse_exp
801
            {
802
              Expression_ptr s = script_exp_string($1.value, $1.length);
803
              Expression_ptr e = script_exp_binary_add(s, $3);
804
              script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
805
            }
806
        | string MINUSEQ parse_exp
807
            {
808
              Expression_ptr s = script_exp_string($1.value, $1.length);
809
              Expression_ptr e = script_exp_binary_sub(s, $3);
810
              script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
811
            }
812
        | string MULTEQ parse_exp
813
            {
814
              Expression_ptr s = script_exp_string($1.value, $1.length);
815
              Expression_ptr e = script_exp_binary_mult(s, $3);
816
              script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
817
            }
818
        | string DIVEQ parse_exp
819
            {
820
              Expression_ptr s = script_exp_string($1.value, $1.length);
821
              Expression_ptr e = script_exp_binary_div(s, $3);
822
              script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
823
            }
824
        | string LSHIFTEQ parse_exp
825
            {
826
              Expression_ptr s = script_exp_string($1.value, $1.length);
827
              Expression_ptr e = script_exp_binary_lshift(s, $3);
828
              script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
829
            }
830
        | string RSHIFTEQ parse_exp
831
            {
832
              Expression_ptr s = script_exp_string($1.value, $1.length);
833
              Expression_ptr e = script_exp_binary_rshift(s, $3);
834
              script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
835
            }
836
        | string ANDEQ parse_exp
837
            {
838
              Expression_ptr s = script_exp_string($1.value, $1.length);
839
              Expression_ptr e = script_exp_binary_bitwise_and(s, $3);
840
              script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
841
            }
842
        | string OREQ parse_exp
843
            {
844
              Expression_ptr s = script_exp_string($1.value, $1.length);
845
              Expression_ptr e = script_exp_binary_bitwise_or(s, $3);
846
              script_set_symbol(closure, $1.value, $1.length, e, 0, 0);
847
            }
848
        | PROVIDE '(' string '=' parse_exp ')'
849
            { script_set_symbol(closure, $3.value, $3.length, $5, 1, 0); }
850
        | PROVIDE_HIDDEN '(' string '=' parse_exp ')'
851
            { script_set_symbol(closure, $3.value, $3.length, $5, 1, 1); }
852
        ;
853
 
854
/* Parse an expression, putting the lexer into the right mode.  */
855
parse_exp:
856
            { script_push_lex_into_expression_mode(closure); }
857
          exp
858
            {
859
              script_pop_lex_mode(closure);
860
              $$ = $2;
861
            }
862
        ;
863
 
864
/* An expression.  */
865
exp:
866
          '(' exp ')'
867
            { $$ = $2; }
868
        | '-' exp %prec UNARY
869
            { $$ = script_exp_unary_minus($2); }
870
        | '!' exp %prec UNARY
871
            { $$ = script_exp_unary_logical_not($2); }
872
        | '~' exp %prec UNARY
873
            { $$ = script_exp_unary_bitwise_not($2); }
874
        | '+' exp %prec UNARY
875
            { $$ = $2; }
876
        | exp '*' exp
877
            { $$ = script_exp_binary_mult($1, $3); }
878
        | exp '/' exp
879
            { $$ = script_exp_binary_div($1, $3); }
880
        | exp '%' exp
881
            { $$ = script_exp_binary_mod($1, $3); }
882
        | exp '+' exp
883
            { $$ = script_exp_binary_add($1, $3); }
884
        | exp '-' exp
885
            { $$ = script_exp_binary_sub($1, $3); }
886
        | exp LSHIFT exp
887
            { $$ = script_exp_binary_lshift($1, $3); }
888
        | exp RSHIFT exp
889
            { $$ = script_exp_binary_rshift($1, $3); }
890
        | exp EQ exp
891
            { $$ = script_exp_binary_eq($1, $3); }
892
        | exp NE exp
893
            { $$ = script_exp_binary_ne($1, $3); }
894
        | exp LE exp
895
            { $$ = script_exp_binary_le($1, $3); }
896
        | exp GE exp
897
            { $$ = script_exp_binary_ge($1, $3); }
898
        | exp '<' exp
899
            { $$ = script_exp_binary_lt($1, $3); }
900
        | exp '>' exp
901
            { $$ = script_exp_binary_gt($1, $3); }
902
        | exp '&' exp
903
            { $$ = script_exp_binary_bitwise_and($1, $3); }
904
        | exp '^' exp
905
            { $$ = script_exp_binary_bitwise_xor($1, $3); }
906
        | exp '|' exp
907
            { $$ = script_exp_binary_bitwise_or($1, $3); }
908
        | exp ANDAND exp
909
            { $$ = script_exp_binary_logical_and($1, $3); }
910
        | exp OROR exp
911
            { $$ = script_exp_binary_logical_or($1, $3); }
912
        | exp '?' exp ':' exp
913
            { $$ = script_exp_trinary_cond($1, $3, $5); }
914
        | INTEGER
915
            { $$ = script_exp_integer($1); }
916
        | string
917
            { $$ = script_symbol(closure, $1.value, $1.length); }
918
        | MAX_K '(' exp ',' exp ')'
919
            { $$ = script_exp_function_max($3, $5); }
920
        | MIN_K '(' exp ',' exp ')'
921
            { $$ = script_exp_function_min($3, $5); }
922
        | DEFINED '(' string ')'
923
            { $$ = script_exp_function_defined($3.value, $3.length); }
924
        | SIZEOF_HEADERS
925
            { $$ = script_exp_function_sizeof_headers(); }
926
        | ALIGNOF '(' string ')'
927
            { $$ = script_exp_function_alignof($3.value, $3.length); }
928
        | SIZEOF '(' string ')'
929
            { $$ = script_exp_function_sizeof($3.value, $3.length); }
930
        | ADDR '(' string ')'
931
            { $$ = script_exp_function_addr($3.value, $3.length); }
932
        | LOADADDR '(' string ')'
933
            { $$ = script_exp_function_loadaddr($3.value, $3.length); }
934
        | ORIGIN '(' string ')'
935
            { $$ = script_exp_function_origin(closure, $3.value, $3.length); }
936
        | LENGTH '(' string ')'
937
            { $$ = script_exp_function_length(closure, $3.value, $3.length); }
938
        | CONSTANT '(' string ')'
939
            { $$ = script_exp_function_constant($3.value, $3.length); }
940
        | ABSOLUTE '(' exp ')'
941
            { $$ = script_exp_function_absolute($3); }
942
        | ALIGN_K '(' exp ')'
943
            { $$ = script_exp_function_align(script_exp_string(".", 1), $3); }
944
        | ALIGN_K '(' exp ',' exp ')'
945
            { $$ = script_exp_function_align($3, $5); }
946
        | BLOCK '(' exp ')'
947
            { $$ = script_exp_function_align(script_exp_string(".", 1), $3); }
948
        | DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
949
            {
950
              script_data_segment_align(closure);
951
              $$ = script_exp_function_data_segment_align($3, $5);
952
            }
953
        | DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
954
            {
955
              script_data_segment_relro_end(closure);
956
              $$ = script_exp_function_data_segment_relro_end($3, $5);
957
            }
958
        | DATA_SEGMENT_END '(' exp ')'
959
            { $$ = script_exp_function_data_segment_end($3); }
960
        | SEGMENT_START '(' string ',' exp ')'
961
            {
962
              $$ = script_exp_function_segment_start($3.value, $3.length, $5);
963
              /* We need to take note of any SEGMENT_START expressions
964
                 because they change the behaviour of -Ttext, -Tdata and
965
                 -Tbss options.  */
966
              script_saw_segment_start_expression(closure);
967
            }
968
        | ASSERT_K '(' exp ',' string ')'
969
            { $$ = script_exp_function_assert($3, $5.value, $5.length); }
970
        ;
971
 
972
/* Handle the --defsym option.  */
973
defsym_expr:
974
          string '=' parse_exp
975
            { script_set_symbol(closure, $1.value, $1.length, $3, 0, 0); }
976
        ;
977
 
978
/* Handle the --dynamic-list option.  A dynamic list has the format
979
   { sym1; sym2; extern "C++" { namespace::sym3 }; };
980
   We store the symbol we see in the "local" list; that is where
981
   Command_line::in_dynamic_list() will look to do its check.
982
   TODO(csilvers): More than one of these brace-lists can appear, and
983
   should just be merged and treated as a single list.  */
984
dynamic_list_expr: dynamic_list_nodes ;
985
 
986
dynamic_list_nodes:
987
          dynamic_list_node
988
        | dynamic_list_nodes dynamic_list_node
989
        ;
990
 
991
dynamic_list_node:
992
          '{' vers_defns ';' '}' ';'
993
            { script_new_vers_node (closure, NULL, $2); }
994
        ;
995
 
996
/* A version script.  */
997
version_script:
998
          vers_nodes
999
        ;
1000
 
1001
vers_nodes:
1002
          vers_node
1003
        | vers_nodes vers_node
1004
        ;
1005
 
1006
vers_node:
1007
          '{' vers_tag '}' ';'
1008
            {
1009
              script_register_vers_node (closure, NULL, 0, $2, NULL);
1010
            }
1011
        | string '{' vers_tag '}' ';'
1012
            {
1013
              script_register_vers_node (closure, $1.value, $1.length, $3,
1014
                                         NULL);
1015
            }
1016
        | string '{' vers_tag '}' verdep ';'
1017
            {
1018
              script_register_vers_node (closure, $1.value, $1.length, $3, $5);
1019
            }
1020
        ;
1021
 
1022
verdep:
1023
          string
1024
            {
1025
              $$ = script_add_vers_depend (closure, NULL, $1.value, $1.length);
1026
            }
1027
        | verdep string
1028
            {
1029
              $$ = script_add_vers_depend (closure, $1, $2.value, $2.length);
1030
            }
1031
        ;
1032
 
1033
vers_tag:
1034
          /* empty */
1035
            { $$ = script_new_vers_node (closure, NULL, NULL); }
1036
        | vers_defns ';'
1037
            { $$ = script_new_vers_node (closure, $1, NULL); }
1038
        | GLOBAL ':' vers_defns ';'
1039
            { $$ = script_new_vers_node (closure, $3, NULL); }
1040
        | LOCAL ':' vers_defns ';'
1041
            { $$ = script_new_vers_node (closure, NULL, $3); }
1042
        | GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1043
            { $$ = script_new_vers_node (closure, $3, $7); }
1044
        ;
1045
 
1046
/* Here is one of the rare places we care about the distinction
1047
   between STRING and QUOTED_STRING.  For QUOTED_STRING, we do exact
1048
   matching on the pattern, so we pass in true for the exact_match
1049
   parameter.  For STRING, we do glob matching and pass in false.  */
1050
vers_defns:
1051
          STRING
1052
            {
1053
              $$ = script_new_vers_pattern (closure, NULL, $1.value,
1054
                                            $1.length, 0);
1055
            }
1056
        | QUOTED_STRING
1057
            {
1058
              $$ = script_new_vers_pattern (closure, NULL, $1.value,
1059
                                            $1.length, 1);
1060
            }
1061
        | vers_defns ';' STRING
1062
            {
1063
              $$ = script_new_vers_pattern (closure, $1, $3.value,
1064
                                            $3.length, 0);
1065
            }
1066
        | vers_defns ';' QUOTED_STRING
1067
            {
1068
              $$ = script_new_vers_pattern (closure, $1, $3.value,
1069
                                            $3.length, 1);
1070
            }
1071
        | /* Push string on the language stack. */
1072
          EXTERN string '{'
1073
            { version_script_push_lang (closure, $2.value, $2.length); }
1074
          vers_defns opt_semicolon '}'
1075
            {
1076
              $$ = $5;
1077
              version_script_pop_lang(closure);
1078
            }
1079
        | /* Push string on the language stack.  This is more complicated
1080
             than the other cases because we need to merge the linked-list
1081
             state from the pre-EXTERN defns and the post-EXTERN defns.  */
1082
          vers_defns ';' EXTERN string '{'
1083
            { version_script_push_lang (closure, $4.value, $4.length); }
1084
          vers_defns opt_semicolon '}'
1085
            {
1086
              $$ = script_merge_expressions ($1, $7);
1087
              version_script_pop_lang(closure);
1088
            }
1089
        | EXTERN  // "extern" as a symbol name
1090
            {
1091
              $$ = script_new_vers_pattern (closure, NULL, "extern",
1092
                                            sizeof("extern") - 1, 1);
1093
            }
1094
        | vers_defns ';' EXTERN
1095
            {
1096
              $$ = script_new_vers_pattern (closure, $1, "extern",
1097
                                            sizeof("extern") - 1, 1);
1098
            }
1099
        ;
1100
 
1101
/* A string can be either a STRING or a QUOTED_STRING.  Almost all the
1102
   time we don't care, and we use this rule.  */
1103
string:
1104
          STRING
1105
            { $$ = $1; }
1106
        | QUOTED_STRING
1107
            { $$ = $1; }
1108
        ;
1109
 
1110
/* Some statements require a terminator, which may be a semicolon or a
1111
   comma.  */
1112
end:
1113
          ';'
1114
        | ','
1115
        ;
1116
 
1117
/* An optional semicolon.  */
1118
opt_semicolon:
1119
          ';'
1120
        |  /* empty */
1121
        ;
1122
 
1123
/* An optional comma.  */
1124
opt_comma:
1125
          ','
1126
        | /* empty */
1127
        ;
1128
 
1129
%%

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.