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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [ld/] [ldgram.y] - Blame information for rev 816

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* A YACC grammar to parse a superset of the AT&T linker scripting language.
2
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3
   2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
4
   Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
5
 
6
   This file is part of the GNU Binutils.
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
%{
24
/*
25
 
26
 */
27
 
28
#define DONTDECLARE_MALLOC
29
 
30
#include "sysdep.h"
31
#include "bfd.h"
32
#include "bfdlink.h"
33
#include "ld.h"
34
#include "ldexp.h"
35
#include "ldver.h"
36
#include "ldlang.h"
37
#include "ldfile.h"
38
#include "ldemul.h"
39
#include "ldmisc.h"
40
#include "ldmain.h"
41
#include "mri.h"
42
#include "ldctor.h"
43
#include "ldlex.h"
44
 
45
#ifndef YYDEBUG
46
#define YYDEBUG 1
47
#endif
48
 
49
static enum section_type sectype;
50
static lang_memory_region_type *region;
51
 
52
bfd_boolean ldgram_had_keep = FALSE;
53
char *ldgram_vers_current_lang = NULL;
54
 
55
#define ERROR_NAME_MAX 20
56
static char *error_names[ERROR_NAME_MAX];
57
static int error_index;
58
#define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
59
#define POP_ERROR()   error_index--;
60
%}
61
%union {
62
  bfd_vma integer;
63
  struct big_int
64
    {
65
      bfd_vma integer;
66
      char *str;
67
    } bigint;
68
  fill_type *fill;
69
  char *name;
70
  const char *cname;
71
  struct wildcard_spec wildcard;
72
  struct wildcard_list *wildcard_list;
73
  struct name_list *name_list;
74
  int token;
75
  union etree_union *etree;
76
  struct phdr_info
77
    {
78
      bfd_boolean filehdr;
79
      bfd_boolean phdrs;
80
      union etree_union *at;
81
      union etree_union *flags;
82
    } phdr;
83
  struct lang_nocrossref *nocrossref;
84
  struct lang_output_section_phdr_list *section_phdr;
85
  struct bfd_elf_version_deps *deflist;
86
  struct bfd_elf_version_expr *versyms;
87
  struct bfd_elf_version_tree *versnode;
88
}
89
 
90
%type  exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
91
%type  opt_exp_without_type opt_subalign opt_align
92
%type  fill_opt fill_exp
93
%type  exclude_name_list
94
%type  file_NAME_list
95
%type  memspec_opt casesymlist
96
%type  memspec_at_opt
97
%type  wildcard_name
98
%type  wildcard_spec
99
%token  INT
100
%token  NAME LNAME
101
%type  length
102
%type  phdr_qualifiers
103
%type  nocrossref_list
104
%type  phdr_opt
105
%type  opt_nocrossrefs
106
 
107
%right  PLUSEQ MINUSEQ MULTEQ DIVEQ  '=' LSHIFTEQ RSHIFTEQ   ANDEQ OREQ
108
%right  '?' ':'
109
%left  OROR
110
%left   ANDAND
111
%left  '|'
112
%left   '^'
113
%left   '&'
114
%left   EQ NE
115
%left   '<' '>' LE GE
116
%left   LSHIFT RSHIFT
117
 
118
%left   '+' '-'
119
%left   '*' '/' '%'
120
 
121
%right UNARY
122
%token END
123
%left  '('
124
%token  ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE
125
%token SECTIONS PHDRS INSERT_K AFTER BEFORE
126
%token DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END
127
%token SORT_BY_NAME SORT_BY_ALIGNMENT
128
%token '{' '}'
129
%token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
130
%token INHIBIT_COMMON_ALLOCATION
131
%token SEGMENT_START
132
%token INCLUDE
133
%token MEMORY
134
%token NOLOAD DSECT COPY INFO OVERLAY
135
%token DEFINED TARGET_K SEARCH_DIR MAP ENTRY
136
%token  NEXT
137
%token SIZEOF ALIGNOF ADDR LOADADDR MAX_K MIN_K
138
%token STARTUP HLL SYSLIB FLOAT NOFLOAT NOCROSSREFS
139
%token ORIGIN FILL
140
%token LENGTH CREATE_OBJECT_SYMBOLS INPUT GROUP OUTPUT CONSTRUCTORS
141
%token ALIGNMOD AT SUBALIGN PROVIDE PROVIDE_HIDDEN AS_NEEDED
142
%type  assign_op atype attributes_opt sect_constraint
143
%type   filename
144
%token CHIP LIST SECT ABSOLUTE  LOAD NEWLINE ENDWORD ORDER NAMEWORD ASSERT_K
145
%token FORMAT PUBLIC DEFSYMEND BASE ALIAS TRUNCATE REL
146
%token INPUT_SCRIPT INPUT_MRI_SCRIPT INPUT_DEFSYM CASE EXTERN START
147
%token  VERS_TAG VERS_IDENTIFIER
148
%token GLOBAL LOCAL VERSIONK INPUT_VERSION_SCRIPT
149
%token KEEP ONLY_IF_RO ONLY_IF_RW SPECIAL
150
%token EXCLUDE_FILE
151
%token CONSTANT
152
%type  vers_defns
153
%type  vers_tag
154
%type  verdep
155
%token INPUT_DYNAMIC_LIST
156
 
157
%%
158
 
159
file:
160
                INPUT_SCRIPT script_file
161
        |       INPUT_MRI_SCRIPT mri_script_file
162
        |       INPUT_VERSION_SCRIPT version_script_file
163
        |       INPUT_DYNAMIC_LIST dynamic_list_file
164
        |       INPUT_DEFSYM defsym_expr
165
        ;
166
 
167
 
168
filename:  NAME;
169
 
170
 
171
defsym_expr:
172
                { ldlex_defsym(); }
173
                NAME '=' exp
174
                {
175
                  ldlex_popstate();
176
                  lang_add_assignment(exp_assop($3,$2,$4));
177
                }
178
        ;
179
 
180
/* SYNTAX WITHIN AN MRI SCRIPT FILE */
181
mri_script_file:
182
                {
183
                  ldlex_mri_script ();
184
                  PUSH_ERROR (_("MRI style script"));
185
                }
186
             mri_script_lines
187
                {
188
                  ldlex_popstate ();
189
                  mri_draw_tree ();
190
                  POP_ERROR ();
191
                }
192
        ;
193
 
194
mri_script_lines:
195
                mri_script_lines mri_script_command NEWLINE
196
          |
197
        ;
198
 
199
mri_script_command:
200
                CHIP  exp
201
        |       CHIP  exp ',' exp
202
        |       NAME    {
203
                        einfo(_("%P%F: unrecognised keyword in MRI style script '%s'\n"),$1);
204
                        }
205
        |       LIST    {
206
                        config.map_filename = "-";
207
                        }
208
        |       ORDER ordernamelist
209
        |       ENDWORD
210
        |       PUBLIC NAME '=' exp
211
                        { mri_public($2, $4); }
212
        |       PUBLIC NAME ',' exp
213
                        { mri_public($2, $4); }
214
        |       PUBLIC NAME  exp
215
                        { mri_public($2, $3); }
216
        |       FORMAT NAME
217
                        { mri_format($2); }
218
        |       SECT NAME ',' exp
219
                        { mri_output_section($2, $4);}
220
        |       SECT NAME  exp
221
                        { mri_output_section($2, $3);}
222
        |       SECT NAME '=' exp
223
                        { mri_output_section($2, $4);}
224
        |       ALIGN_K NAME '=' exp
225
                        { mri_align($2,$4); }
226
        |       ALIGN_K NAME ',' exp
227
                        { mri_align($2,$4); }
228
        |       ALIGNMOD NAME '=' exp
229
                        { mri_alignmod($2,$4); }
230
        |       ALIGNMOD NAME ',' exp
231
                        { mri_alignmod($2,$4); }
232
        |       ABSOLUTE mri_abs_name_list
233
        |       LOAD     mri_load_name_list
234
        |       NAMEWORD NAME
235
                        { mri_name($2); }
236
        |       ALIAS NAME ',' NAME
237
                        { mri_alias($2,$4,0);}
238
        |       ALIAS NAME ',' INT
239
                        { mri_alias ($2, 0, (int) $4.integer); }
240
        |       BASE     exp
241
                        { mri_base($2); }
242
        |       TRUNCATE INT
243
                { mri_truncate ((unsigned int) $2.integer); }
244
        |       CASE casesymlist
245
        |       EXTERN extern_name_list
246
        |       INCLUDE filename
247
                { ldlex_script (); ldfile_open_command_file($2); }
248
                mri_script_lines END
249
                { ldlex_popstate (); }
250
        |       START NAME
251
                { lang_add_entry ($2, FALSE); }
252
        |
253
        ;
254
 
255
ordernamelist:
256
              ordernamelist ',' NAME         { mri_order($3); }
257
        |     ordernamelist  NAME         { mri_order($2); }
258
        |
259
        ;
260
 
261
mri_load_name_list:
262
                NAME
263
                        { mri_load($1); }
264
        |       mri_load_name_list ',' NAME { mri_load($3); }
265
        ;
266
 
267
mri_abs_name_list:
268
                NAME
269
                        { mri_only_load($1); }
270
        |       mri_abs_name_list ','  NAME
271
                        { mri_only_load($3); }
272
        ;
273
 
274
casesymlist:
275
          /* empty */ { $$ = NULL; }
276
        | NAME
277
        | casesymlist ',' NAME
278
        ;
279
 
280
/* Parsed as expressions so that commas separate entries */
281
extern_name_list:
282
        { ldlex_expression (); }
283
        extern_name_list_body
284
        { ldlex_popstate (); }
285
 
286
extern_name_list_body:
287
          NAME
288
                        { ldlang_add_undef ($1); }
289
        | extern_name_list_body NAME
290
                        { ldlang_add_undef ($2); }
291
        | extern_name_list_body ',' NAME
292
                        { ldlang_add_undef ($3); }
293
        ;
294
 
295
script_file:
296
        { ldlex_both(); }
297
        ifile_list
298
        { ldlex_popstate(); }
299
        ;
300
 
301
ifile_list:
302
        ifile_list ifile_p1
303
        |
304
        ;
305
 
306
 
307
ifile_p1:
308
                memory
309
        |       sections
310
        |       phdrs
311
        |       startup
312
        |       high_level_library
313
        |       low_level_library
314
        |       floating_point_support
315
        |       statement_anywhere
316
        |       version
317
        |        ';'
318
        |       TARGET_K '(' NAME ')'
319
                { lang_add_target($3); }
320
        |       SEARCH_DIR '(' filename ')'
321
                { ldfile_add_library_path ($3, FALSE); }
322
        |       OUTPUT '(' filename ')'
323
                { lang_add_output($3, 1); }
324
        |       OUTPUT_FORMAT '(' NAME ')'
325
                  { lang_add_output_format ($3, (char *) NULL,
326
                                            (char *) NULL, 1); }
327
        |       OUTPUT_FORMAT '(' NAME ',' NAME ',' NAME ')'
328
                  { lang_add_output_format ($3, $5, $7, 1); }
329
        |       OUTPUT_ARCH '(' NAME ')'
330
                  { ldfile_set_output_arch ($3, bfd_arch_unknown); }
331
        |       FORCE_COMMON_ALLOCATION
332
                { command_line.force_common_definition = TRUE ; }
333
        |       INHIBIT_COMMON_ALLOCATION
334
                { command_line.inhibit_common_definition = TRUE ; }
335
        |       INPUT '(' input_list ')'
336
        |       GROUP
337
                  { lang_enter_group (); }
338
                    '(' input_list ')'
339
                  { lang_leave_group (); }
340
        |       MAP '(' filename ')'
341
                { lang_add_map($3); }
342
        |       INCLUDE filename
343
                { ldlex_script (); ldfile_open_command_file($2); }
344
                ifile_list END
345
                { ldlex_popstate (); }
346
        |       NOCROSSREFS '(' nocrossref_list ')'
347
                {
348
                  lang_add_nocrossref ($3);
349
                }
350
        |       EXTERN '(' extern_name_list ')'
351
        |       INSERT_K AFTER NAME
352
                { lang_add_insert ($3, 0); }
353
        |       INSERT_K BEFORE NAME
354
                { lang_add_insert ($3, 1); }
355
        ;
356
 
357
input_list:
358
                NAME
359
                { lang_add_input_file($1,lang_input_file_is_search_file_enum,
360
                                 (char *)NULL); }
361
        |       input_list ',' NAME
362
                { lang_add_input_file($3,lang_input_file_is_search_file_enum,
363
                                 (char *)NULL); }
364
        |       input_list NAME
365
                { lang_add_input_file($2,lang_input_file_is_search_file_enum,
366
                                 (char *)NULL); }
367
        |       LNAME
368
                { lang_add_input_file($1,lang_input_file_is_l_enum,
369
                                 (char *)NULL); }
370
        |       input_list ',' LNAME
371
                { lang_add_input_file($3,lang_input_file_is_l_enum,
372
                                 (char *)NULL); }
373
        |       input_list LNAME
374
                { lang_add_input_file($2,lang_input_file_is_l_enum,
375
                                 (char *)NULL); }
376
        |       AS_NEEDED '('
377
                  { $$ = as_needed; as_needed = TRUE; }
378
                     input_list ')'
379
                  { as_needed = $3; }
380
        |       input_list ',' AS_NEEDED '('
381
                  { $$ = as_needed; as_needed = TRUE; }
382
                     input_list ')'
383
                  { as_needed = $5; }
384
        |       input_list AS_NEEDED '('
385
                  { $$ = as_needed; as_needed = TRUE; }
386
                     input_list ')'
387
                  { as_needed = $4; }
388
        ;
389
 
390
sections:
391
                SECTIONS '{' sec_or_group_p1 '}'
392
        ;
393
 
394
sec_or_group_p1:
395
                sec_or_group_p1 section
396
        |       sec_or_group_p1 statement_anywhere
397
        |
398
        ;
399
 
400
statement_anywhere:
401
                ENTRY '(' NAME ')'
402
                { lang_add_entry ($3, FALSE); }
403
        |       assignment end
404
        |       ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')'
405
                { ldlex_popstate ();
406
                  lang_add_assignment (exp_assert ($4, $6)); }
407
        ;
408
 
409
/* The '*' and '?' cases are there because the lexer returns them as
410
   separate tokens rather than as NAME.  */
411
wildcard_name:
412
                NAME
413
                        {
414
                          $$ = $1;
415
                        }
416
        |       '*'
417
                        {
418
                          $$ = "*";
419
                        }
420
        |       '?'
421
                        {
422
                          $$ = "?";
423
                        }
424
        ;
425
 
426
wildcard_spec:
427
                wildcard_name
428
                        {
429
                          $$.name = $1;
430
                          $$.sorted = none;
431
                          $$.exclude_name_list = NULL;
432
                        }
433
        |       EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name
434
                        {
435
                          $$.name = $5;
436
                          $$.sorted = none;
437
                          $$.exclude_name_list = $3;
438
                        }
439
        |       SORT_BY_NAME '(' wildcard_name ')'
440
                        {
441
                          $$.name = $3;
442
                          $$.sorted = by_name;
443
                          $$.exclude_name_list = NULL;
444
                        }
445
        |       SORT_BY_ALIGNMENT '(' wildcard_name ')'
446
                        {
447
                          $$.name = $3;
448
                          $$.sorted = by_alignment;
449
                          $$.exclude_name_list = NULL;
450
                        }
451
        |       SORT_BY_NAME '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
452
                        {
453
                          $$.name = $5;
454
                          $$.sorted = by_name_alignment;
455
                          $$.exclude_name_list = NULL;
456
                        }
457
        |       SORT_BY_NAME '(' SORT_BY_NAME '(' wildcard_name ')' ')'
458
                        {
459
                          $$.name = $5;
460
                          $$.sorted = by_name;
461
                          $$.exclude_name_list = NULL;
462
                        }
463
        |       SORT_BY_ALIGNMENT '(' SORT_BY_NAME '(' wildcard_name ')' ')'
464
                        {
465
                          $$.name = $5;
466
                          $$.sorted = by_alignment_name;
467
                          $$.exclude_name_list = NULL;
468
                        }
469
        |       SORT_BY_ALIGNMENT '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
470
                        {
471
                          $$.name = $5;
472
                          $$.sorted = by_alignment;
473
                          $$.exclude_name_list = NULL;
474
                        }
475
        |       SORT_BY_NAME '(' EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name ')'
476
                        {
477
                          $$.name = $7;
478
                          $$.sorted = by_name;
479
                          $$.exclude_name_list = $5;
480
                        }
481
        ;
482
 
483
exclude_name_list:
484
                exclude_name_list wildcard_name
485
                        {
486
                          struct name_list *tmp;
487
                          tmp = (struct name_list *) xmalloc (sizeof *tmp);
488
                          tmp->name = $2;
489
                          tmp->next = $1;
490
                          $$ = tmp;
491
                        }
492
        |
493
                wildcard_name
494
                        {
495
                          struct name_list *tmp;
496
                          tmp = (struct name_list *) xmalloc (sizeof *tmp);
497
                          tmp->name = $1;
498
                          tmp->next = NULL;
499
                          $$ = tmp;
500
                        }
501
        ;
502
 
503
file_NAME_list:
504
                file_NAME_list opt_comma wildcard_spec
505
                        {
506
                          struct wildcard_list *tmp;
507
                          tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
508
                          tmp->next = $1;
509
                          tmp->spec = $3;
510
                          $$ = tmp;
511
                        }
512
        |
513
                wildcard_spec
514
                        {
515
                          struct wildcard_list *tmp;
516
                          tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
517
                          tmp->next = NULL;
518
                          tmp->spec = $1;
519
                          $$ = tmp;
520
                        }
521
        ;
522
 
523
input_section_spec_no_keep:
524
                NAME
525
                        {
526
                          struct wildcard_spec tmp;
527
                          tmp.name = $1;
528
                          tmp.exclude_name_list = NULL;
529
                          tmp.sorted = none;
530
                          lang_add_wild (&tmp, NULL, ldgram_had_keep);
531
                        }
532
        |       '[' file_NAME_list ']'
533
                        {
534
                          lang_add_wild (NULL, $2, ldgram_had_keep);
535
                        }
536
        |       wildcard_spec '(' file_NAME_list ')'
537
                        {
538
                          lang_add_wild (&$1, $3, ldgram_had_keep);
539
                        }
540
        ;
541
 
542
input_section_spec:
543
                input_section_spec_no_keep
544
        |       KEEP '('
545
                        { ldgram_had_keep = TRUE; }
546
                input_section_spec_no_keep ')'
547
                        { ldgram_had_keep = FALSE; }
548
        ;
549
 
550
statement:
551
                assignment end
552
        |       CREATE_OBJECT_SYMBOLS
553
                {
554
                lang_add_attribute(lang_object_symbols_statement_enum);
555
                }
556
        |       ';'
557
        |       CONSTRUCTORS
558
                {
559
 
560
                  lang_add_attribute(lang_constructors_statement_enum);
561
                }
562
        | SORT_BY_NAME '(' CONSTRUCTORS ')'
563
                {
564
                  constructors_sorted = TRUE;
565
                  lang_add_attribute (lang_constructors_statement_enum);
566
                }
567
        | input_section_spec
568
        | length '(' mustbe_exp ')'
569
                        {
570
                          lang_add_data ((int) $1, $3);
571
                        }
572
 
573
        | FILL '(' fill_exp ')'
574
                        {
575
                          lang_add_fill ($3);
576
                        }
577
        | ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')' end
578
                        { ldlex_popstate ();
579
                          lang_add_assignment (exp_assert ($4, $6)); }
580
        ;
581
 
582
statement_list:
583
                statement_list statement
584
        |       statement
585
        ;
586
 
587
statement_list_opt:
588
                /* empty */
589
        |       statement_list
590
        ;
591
 
592
length:
593
                QUAD
594
                        { $$ = $1; }
595
        |       SQUAD
596
                        { $$ = $1; }
597
        |       LONG
598
                        { $$ = $1; }
599
        |       SHORT
600
                        { $$ = $1; }
601
        |       BYTE
602
                        { $$ = $1; }
603
        ;
604
 
605
fill_exp:
606
        mustbe_exp
607
                {
608
                  $$ = exp_get_fill ($1, 0, "fill value");
609
                }
610
        ;
611
 
612
fill_opt:
613
          '=' fill_exp
614
                { $$ = $2; }
615
        |       { $$ = (fill_type *) 0; }
616
        ;
617
 
618
assign_op:
619
                PLUSEQ
620
                        { $$ = '+'; }
621
        |       MINUSEQ
622
                        { $$ = '-'; }
623
        |       MULTEQ
624
                        { $$ = '*'; }
625
        |       DIVEQ
626
                        { $$ = '/'; }
627
        |       LSHIFTEQ
628
                        { $$ = LSHIFT; }
629
        |       RSHIFTEQ
630
                        { $$ = RSHIFT; }
631
        |       ANDEQ
632
                        { $$ = '&'; }
633
        |       OREQ
634
                        { $$ = '|'; }
635
 
636
        ;
637
 
638
end:    ';' | ','
639
        ;
640
 
641
 
642
assignment:
643
                NAME '=' mustbe_exp
644
                {
645
                  lang_add_assignment (exp_assop ($2, $1, $3));
646
                }
647
        |       NAME assign_op mustbe_exp
648
                {
649
                  lang_add_assignment (exp_assop ('=', $1,
650
                                                  exp_binop ($2,
651
                                                             exp_nameop (NAME,
652
                                                                         $1),
653
                                                             $3)));
654
                }
655
        |       PROVIDE '(' NAME '=' mustbe_exp ')'
656
                {
657
                  lang_add_assignment (exp_provide ($3, $5, FALSE));
658
                }
659
        |       PROVIDE_HIDDEN '(' NAME '=' mustbe_exp ')'
660
                {
661
                  lang_add_assignment (exp_provide ($3, $5, TRUE));
662
                }
663
        ;
664
 
665
 
666
opt_comma:
667
                ','     |       ;
668
 
669
 
670
memory:
671
                MEMORY '{' memory_spec memory_spec_list '}'
672
        ;
673
 
674
memory_spec_list:
675
                memory_spec_list memory_spec
676
        |       memory_spec_list ',' memory_spec
677
        |
678
        ;
679
 
680
 
681
memory_spec:    NAME
682
                { region = lang_memory_region_lookup ($1, TRUE); }
683
                attributes_opt ':'
684
                origin_spec opt_comma length_spec
685
                {}
686
        ;
687
 
688
origin_spec:
689
        ORIGIN '=' mustbe_exp
690
                {
691
                  region->origin = exp_get_vma ($3, 0, "origin");
692
                  region->current = region->origin;
693
                }
694
        ;
695
 
696
length_spec:
697
             LENGTH '=' mustbe_exp
698
                {
699
                  region->length = exp_get_vma ($3, -1, "length");
700
                }
701
        ;
702
 
703
attributes_opt:
704
                /* empty */
705
                  { /* dummy action to avoid bison 1.25 error message */ }
706
        |       '(' attributes_list ')'
707
        ;
708
 
709
attributes_list:
710
                attributes_string
711
        |       attributes_list attributes_string
712
        ;
713
 
714
attributes_string:
715
                NAME
716
                  { lang_set_flags (region, $1, 0); }
717
        |       '!' NAME
718
                  { lang_set_flags (region, $2, 1); }
719
        ;
720
 
721
startup:
722
        STARTUP '(' filename ')'
723
                { lang_startup($3); }
724
        ;
725
 
726
high_level_library:
727
                HLL '(' high_level_library_NAME_list ')'
728
        |       HLL '(' ')'
729
                        { ldemul_hll((char *)NULL); }
730
        ;
731
 
732
high_level_library_NAME_list:
733
                high_level_library_NAME_list opt_comma filename
734
                        { ldemul_hll($3); }
735
        |       filename
736
                        { ldemul_hll($1); }
737
 
738
        ;
739
 
740
low_level_library:
741
        SYSLIB '(' low_level_library_NAME_list ')'
742
        ; low_level_library_NAME_list:
743
                low_level_library_NAME_list opt_comma filename
744
                        { ldemul_syslib($3); }
745
        |
746
        ;
747
 
748
floating_point_support:
749
                FLOAT
750
                        { lang_float(TRUE); }
751
        |       NOFLOAT
752
                        { lang_float(FALSE); }
753
        ;
754
 
755
nocrossref_list:
756
                /* empty */
757
                {
758
                  $$ = NULL;
759
                }
760
        |       NAME nocrossref_list
761
                {
762
                  struct lang_nocrossref *n;
763
 
764
                  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
765
                  n->name = $1;
766
                  n->next = $2;
767
                  $$ = n;
768
                }
769
        |       NAME ',' nocrossref_list
770
                {
771
                  struct lang_nocrossref *n;
772
 
773
                  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
774
                  n->name = $1;
775
                  n->next = $3;
776
                  $$ = n;
777
                }
778
        ;
779
 
780
mustbe_exp:              { ldlex_expression (); }
781
                exp
782
                         { ldlex_popstate (); $$=$2;}
783
        ;
784
 
785
exp     :
786
                '-' exp %prec UNARY
787
                        { $$ = exp_unop ('-', $2); }
788
        |       '(' exp ')'
789
                        { $$ = $2; }
790
        |       NEXT '(' exp ')' %prec UNARY
791
                        { $$ = exp_unop ((int) $1,$3); }
792
        |       '!' exp %prec UNARY
793
                        { $$ = exp_unop ('!', $2); }
794
        |       '+' exp %prec UNARY
795
                        { $$ = $2; }
796
        |       '~' exp %prec UNARY
797
                        { $$ = exp_unop ('~', $2);}
798
 
799
        |       exp '*' exp
800
                        { $$ = exp_binop ('*', $1, $3); }
801
        |       exp '/' exp
802
                        { $$ = exp_binop ('/', $1, $3); }
803
        |       exp '%' exp
804
                        { $$ = exp_binop ('%', $1, $3); }
805
        |       exp '+' exp
806
                        { $$ = exp_binop ('+', $1, $3); }
807
        |       exp '-' exp
808
                        { $$ = exp_binop ('-' , $1, $3); }
809
        |       exp LSHIFT exp
810
                        { $$ = exp_binop (LSHIFT , $1, $3); }
811
        |       exp RSHIFT exp
812
                        { $$ = exp_binop (RSHIFT , $1, $3); }
813
        |       exp EQ exp
814
                        { $$ = exp_binop (EQ , $1, $3); }
815
        |       exp NE exp
816
                        { $$ = exp_binop (NE , $1, $3); }
817
        |       exp LE exp
818
                        { $$ = exp_binop (LE , $1, $3); }
819
        |       exp GE exp
820
                        { $$ = exp_binop (GE , $1, $3); }
821
        |       exp '<' exp
822
                        { $$ = exp_binop ('<' , $1, $3); }
823
        |       exp '>' exp
824
                        { $$ = exp_binop ('>' , $1, $3); }
825
        |       exp '&' exp
826
                        { $$ = exp_binop ('&' , $1, $3); }
827
        |       exp '^' exp
828
                        { $$ = exp_binop ('^' , $1, $3); }
829
        |       exp '|' exp
830
                        { $$ = exp_binop ('|' , $1, $3); }
831
        |       exp '?' exp ':' exp
832
                        { $$ = exp_trinop ('?' , $1, $3, $5); }
833
        |       exp ANDAND exp
834
                        { $$ = exp_binop (ANDAND , $1, $3); }
835
        |       exp OROR exp
836
                        { $$ = exp_binop (OROR , $1, $3); }
837
        |       DEFINED '(' NAME ')'
838
                        { $$ = exp_nameop (DEFINED, $3); }
839
        |       INT
840
                        { $$ = exp_bigintop ($1.integer, $1.str); }
841
        |       SIZEOF_HEADERS
842
                        { $$ = exp_nameop (SIZEOF_HEADERS,0); }
843
 
844
        |       ALIGNOF '(' NAME ')'
845
                        { $$ = exp_nameop (ALIGNOF,$3); }
846
        |       SIZEOF '(' NAME ')'
847
                        { $$ = exp_nameop (SIZEOF,$3); }
848
        |       ADDR '(' NAME ')'
849
                        { $$ = exp_nameop (ADDR,$3); }
850
        |       LOADADDR '(' NAME ')'
851
                        { $$ = exp_nameop (LOADADDR,$3); }
852
        |       CONSTANT '(' NAME ')'
853
                        { $$ = exp_nameop (CONSTANT,$3); }
854
        |       ABSOLUTE '(' exp ')'
855
                        { $$ = exp_unop (ABSOLUTE, $3); }
856
        |       ALIGN_K '(' exp ')'
857
                        { $$ = exp_unop (ALIGN_K,$3); }
858
        |       ALIGN_K '(' exp ',' exp ')'
859
                        { $$ = exp_binop (ALIGN_K,$3,$5); }
860
        |       DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
861
                        { $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
862
        |       DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
863
                        { $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
864
        |       DATA_SEGMENT_END '(' exp ')'
865
                        { $$ = exp_unop (DATA_SEGMENT_END, $3); }
866
        |       SEGMENT_START '(' NAME ',' exp ')'
867
                        { /* The operands to the expression node are
868
                             placed in the opposite order from the way
869
                             in which they appear in the script as
870
                             that allows us to reuse more code in
871
                             fold_binary.  */
872
                          $$ = exp_binop (SEGMENT_START,
873
                                          $5,
874
                                          exp_nameop (NAME, $3)); }
875
        |       BLOCK '(' exp ')'
876
                        { $$ = exp_unop (ALIGN_K,$3); }
877
        |       NAME
878
                        { $$ = exp_nameop (NAME,$1); }
879
        |       MAX_K '(' exp ',' exp ')'
880
                        { $$ = exp_binop (MAX_K, $3, $5 ); }
881
        |       MIN_K '(' exp ',' exp ')'
882
                        { $$ = exp_binop (MIN_K, $3, $5 ); }
883
        |       ASSERT_K '(' exp ',' NAME ')'
884
                        { $$ = exp_assert ($3, $5); }
885
        |       ORIGIN '(' NAME ')'
886
                        { $$ = exp_nameop (ORIGIN, $3); }
887
        |       LENGTH '(' NAME ')'
888
                        { $$ = exp_nameop (LENGTH, $3); }
889
        ;
890
 
891
 
892
memspec_at_opt:
893
                AT '>' NAME { $$ = $3; }
894
        |       { $$ = 0; }
895
        ;
896
 
897
opt_at:
898
                AT '(' exp ')' { $$ = $3; }
899
        |       { $$ = 0; }
900
        ;
901
 
902
opt_align:
903
                ALIGN_K '(' exp ')' { $$ = $3; }
904
        |       { $$ = 0; }
905
        ;
906
 
907
opt_subalign:
908
                SUBALIGN '(' exp ')' { $$ = $3; }
909
        |       { $$ = 0; }
910
        ;
911
 
912
sect_constraint:
913
                ONLY_IF_RO { $$ = ONLY_IF_RO; }
914
        |       ONLY_IF_RW { $$ = ONLY_IF_RW; }
915
        |       SPECIAL { $$ = SPECIAL; }
916
        |       { $$ = 0; }
917
        ;
918
 
919
section:        NAME            { ldlex_expression(); }
920
                opt_exp_with_type
921
                opt_at
922
                opt_align
923
                opt_subalign    { ldlex_popstate (); ldlex_script (); }
924
                sect_constraint
925
                '{'
926
                        {
927
                          lang_enter_output_section_statement($1, $3,
928
                                                              sectype,
929
                                                              $5, $6, $4, $8);
930
                        }
931
                statement_list_opt
932
                '}' { ldlex_popstate (); ldlex_expression (); }
933
                memspec_opt memspec_at_opt phdr_opt fill_opt
934
                {
935
                  ldlex_popstate ();
936
                  lang_leave_output_section_statement ($17, $14, $16, $15);
937
                }
938
                opt_comma
939
                {}
940
        |       OVERLAY
941
                        { ldlex_expression (); }
942
                opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
943
                        { ldlex_popstate (); ldlex_script (); }
944
                '{'
945
                        {
946
                          lang_enter_overlay ($3, $6);
947
                        }
948
                overlay_section
949
                '}'
950
                        { ldlex_popstate (); ldlex_expression (); }
951
                memspec_opt memspec_at_opt phdr_opt fill_opt
952
                        {
953
                          ldlex_popstate ();
954
                          lang_leave_overlay ($5, (int) $4,
955
                                              $16, $13, $15, $14);
956
                        }
957
                opt_comma
958
        |       /* The GROUP case is just enough to support the gcc
959
                   svr3.ifile script.  It is not intended to be full
960
                   support.  I'm not even sure what GROUP is supposed
961
                   to mean.  */
962
                GROUP { ldlex_expression (); }
963
                opt_exp_with_type
964
                {
965
                  ldlex_popstate ();
966
                  lang_add_assignment (exp_assop ('=', ".", $3));
967
                }
968
                '{' sec_or_group_p1 '}'
969
        ;
970
 
971
type:
972
           NOLOAD  { sectype = noload_section; }
973
        |  DSECT   { sectype = noalloc_section; }
974
        |  COPY    { sectype = noalloc_section; }
975
        |  INFO    { sectype = noalloc_section; }
976
        |  OVERLAY { sectype = noalloc_section; }
977
        ;
978
 
979
atype:
980
                '(' type ')'
981
        |       /* EMPTY */ { sectype = normal_section; }
982
        |       '(' ')' { sectype = normal_section; }
983
        ;
984
 
985
opt_exp_with_type:
986
                exp atype ':'           { $$ = $1; }
987
        |       atype ':'               { $$ = (etree_type *)NULL;  }
988
        |       /* The BIND cases are to support the gcc svr3.ifile
989
                   script.  They aren't intended to implement full
990
                   support for the BIND keyword.  I'm not even sure
991
                   what BIND is supposed to mean.  */
992
                BIND '(' exp ')' atype ':' { $$ = $3; }
993
        |       BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
994
                { $$ = $3; }
995
        ;
996
 
997
opt_exp_without_type:
998
                exp ':'         { $$ = $1; }
999
        |       ':'             { $$ = (etree_type *) NULL;  }
1000
        ;
1001
 
1002
opt_nocrossrefs:
1003
                /* empty */
1004
                        { $$ = 0; }
1005
        |       NOCROSSREFS
1006
                        { $$ = 1; }
1007
        ;
1008
 
1009
memspec_opt:
1010
                '>' NAME
1011
                { $$ = $2; }
1012
        |       { $$ = DEFAULT_MEMORY_REGION; }
1013
        ;
1014
 
1015
phdr_opt:
1016
                /* empty */
1017
                {
1018
                  $$ = NULL;
1019
                }
1020
        |       phdr_opt ':' NAME
1021
                {
1022
                  struct lang_output_section_phdr_list *n;
1023
 
1024
                  n = ((struct lang_output_section_phdr_list *)
1025
                       xmalloc (sizeof *n));
1026
                  n->name = $3;
1027
                  n->used = FALSE;
1028
                  n->next = $1;
1029
                  $$ = n;
1030
                }
1031
        ;
1032
 
1033
overlay_section:
1034
                /* empty */
1035
        |       overlay_section
1036
                NAME
1037
                        {
1038
                          ldlex_script ();
1039
                          lang_enter_overlay_section ($2);
1040
                        }
1041
                '{' statement_list_opt '}'
1042
                        { ldlex_popstate (); ldlex_expression (); }
1043
                phdr_opt fill_opt
1044
                        {
1045
                          ldlex_popstate ();
1046
                          lang_leave_overlay_section ($9, $8);
1047
                        }
1048
                opt_comma
1049
        ;
1050
 
1051
phdrs:
1052
                PHDRS '{' phdr_list '}'
1053
        ;
1054
 
1055
phdr_list:
1056
                /* empty */
1057
        |       phdr_list phdr
1058
        ;
1059
 
1060
phdr:
1061
                NAME { ldlex_expression (); }
1062
                  phdr_type phdr_qualifiers { ldlex_popstate (); }
1063
                  ';'
1064
                {
1065
                  lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
1066
                                 $4.flags);
1067
                }
1068
        ;
1069
 
1070
phdr_type:
1071
                exp
1072
                {
1073
                  $$ = $1;
1074
 
1075
                  if ($1->type.node_class == etree_name
1076
                      && $1->type.node_code == NAME)
1077
                    {
1078
                      const char *s;
1079
                      unsigned int i;
1080
                      static const char * const phdr_types[] =
1081
                        {
1082
                          "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
1083
                          "PT_INTERP", "PT_NOTE", "PT_SHLIB",
1084
                          "PT_PHDR", "PT_TLS"
1085
                        };
1086
 
1087
                      s = $1->name.name;
1088
                      for (i = 0;
1089
                           i < sizeof phdr_types / sizeof phdr_types[0];
1090
                           i++)
1091
                        if (strcmp (s, phdr_types[i]) == 0)
1092
                          {
1093
                            $$ = exp_intop (i);
1094
                            break;
1095
                          }
1096
                      if (i == sizeof phdr_types / sizeof phdr_types[0])
1097
                        {
1098
                          if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
1099
                            $$ = exp_intop (0x6474e550);
1100
                          else if (strcmp (s, "PT_GNU_STACK") == 0)
1101
                            $$ = exp_intop (0x6474e551);
1102
                          else
1103
                            {
1104
                              einfo (_("\
1105
%X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
1106
                                     s);
1107
                              $$ = exp_intop (0);
1108
                            }
1109
                        }
1110
                    }
1111
                }
1112
        ;
1113
 
1114
phdr_qualifiers:
1115
                /* empty */
1116
                {
1117
                  memset (&$$, 0, sizeof (struct phdr_info));
1118
                }
1119
        |       NAME phdr_val phdr_qualifiers
1120
                {
1121
                  $$ = $3;
1122
                  if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
1123
                    $$.filehdr = TRUE;
1124
                  else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
1125
                    $$.phdrs = TRUE;
1126
                  else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
1127
                    $$.flags = $2;
1128
                  else
1129
                    einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), $1);
1130
                }
1131
        |       AT '(' exp ')' phdr_qualifiers
1132
                {
1133
                  $$ = $5;
1134
                  $$.at = $3;
1135
                }
1136
        ;
1137
 
1138
phdr_val:
1139
                /* empty */
1140
                {
1141
                  $$ = NULL;
1142
                }
1143
        | '(' exp ')'
1144
                {
1145
                  $$ = $2;
1146
                }
1147
        ;
1148
 
1149
dynamic_list_file:
1150
                {
1151
                  ldlex_version_file ();
1152
                  PUSH_ERROR (_("dynamic list"));
1153
                }
1154
                dynamic_list_nodes
1155
                {
1156
                  ldlex_popstate ();
1157
                  POP_ERROR ();
1158
                }
1159
        ;
1160
 
1161
dynamic_list_nodes:
1162
                dynamic_list_node
1163
        |       dynamic_list_nodes dynamic_list_node
1164
        ;
1165
 
1166
dynamic_list_node:
1167
                '{' dynamic_list_tag '}' ';'
1168
        ;
1169
 
1170
dynamic_list_tag:
1171
                vers_defns ';'
1172
                {
1173
                  lang_append_dynamic_list ($1);
1174
                }
1175
        ;
1176
 
1177
/* This syntax is used within an external version script file.  */
1178
 
1179
version_script_file:
1180
                {
1181
                  ldlex_version_file ();
1182
                  PUSH_ERROR (_("VERSION script"));
1183
                }
1184
                vers_nodes
1185
                {
1186
                  ldlex_popstate ();
1187
                  POP_ERROR ();
1188
                }
1189
        ;
1190
 
1191
/* This is used within a normal linker script file.  */
1192
 
1193
version:
1194
                {
1195
                  ldlex_version_script ();
1196
                }
1197
                VERSIONK '{' vers_nodes '}'
1198
                {
1199
                  ldlex_popstate ();
1200
                }
1201
        ;
1202
 
1203
vers_nodes:
1204
                vers_node
1205
        |       vers_nodes vers_node
1206
        ;
1207
 
1208
vers_node:
1209
                '{' vers_tag '}' ';'
1210
                {
1211
                  lang_register_vers_node (NULL, $2, NULL);
1212
                }
1213
        |       VERS_TAG '{' vers_tag '}' ';'
1214
                {
1215
                  lang_register_vers_node ($1, $3, NULL);
1216
                }
1217
        |       VERS_TAG '{' vers_tag '}' verdep ';'
1218
                {
1219
                  lang_register_vers_node ($1, $3, $5);
1220
                }
1221
        ;
1222
 
1223
verdep:
1224
                VERS_TAG
1225
                {
1226
                  $$ = lang_add_vers_depend (NULL, $1);
1227
                }
1228
        |       verdep VERS_TAG
1229
                {
1230
                  $$ = lang_add_vers_depend ($1, $2);
1231
                }
1232
        ;
1233
 
1234
vers_tag:
1235
                /* empty */
1236
                {
1237
                  $$ = lang_new_vers_node (NULL, NULL);
1238
                }
1239
        |       vers_defns ';'
1240
                {
1241
                  $$ = lang_new_vers_node ($1, NULL);
1242
                }
1243
        |       GLOBAL ':' vers_defns ';'
1244
                {
1245
                  $$ = lang_new_vers_node ($3, NULL);
1246
                }
1247
        |       LOCAL ':' vers_defns ';'
1248
                {
1249
                  $$ = lang_new_vers_node (NULL, $3);
1250
                }
1251
        |       GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
1252
                {
1253
                  $$ = lang_new_vers_node ($3, $7);
1254
                }
1255
        ;
1256
 
1257
vers_defns:
1258
                VERS_IDENTIFIER
1259
                {
1260
                  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, FALSE);
1261
                }
1262
        |       NAME
1263
                {
1264
                  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, TRUE);
1265
                }
1266
        |       vers_defns ';' VERS_IDENTIFIER
1267
                {
1268
                  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, FALSE);
1269
                }
1270
        |       vers_defns ';' NAME
1271
                {
1272
                  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, TRUE);
1273
                }
1274
        |       vers_defns ';' EXTERN NAME '{'
1275
                        {
1276
                          $$ = ldgram_vers_current_lang;
1277
                          ldgram_vers_current_lang = $4;
1278
                        }
1279
                vers_defns opt_semicolon '}'
1280
                        {
1281
                          struct bfd_elf_version_expr *pat;
1282
                          for (pat = $7; pat->next != NULL; pat = pat->next);
1283
                          pat->next = $1;
1284
                          $$ = $7;
1285
                          ldgram_vers_current_lang = $6;
1286
                        }
1287
        |       EXTERN NAME '{'
1288
                        {
1289
                          $$ = ldgram_vers_current_lang;
1290
                          ldgram_vers_current_lang = $2;
1291
                        }
1292
                vers_defns opt_semicolon '}'
1293
                        {
1294
                          $$ = $5;
1295
                          ldgram_vers_current_lang = $4;
1296
                        }
1297
        |       GLOBAL
1298
                {
1299
                  $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE);
1300
                }
1301
        |       vers_defns ';' GLOBAL
1302
                {
1303
                  $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, FALSE);
1304
                }
1305
        |       LOCAL
1306
                {
1307
                  $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE);
1308
                }
1309
        |       vers_defns ';' LOCAL
1310
                {
1311
                  $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, FALSE);
1312
                }
1313
        |       EXTERN
1314
                {
1315
                  $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE);
1316
                }
1317
        |       vers_defns ';' EXTERN
1318
                {
1319
                  $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, FALSE);
1320
                }
1321
        ;
1322
 
1323
opt_semicolon:
1324
                /* empty */
1325
        |       ';'
1326
        ;
1327
 
1328
%%
1329
void
1330
yyerror(arg)
1331
     const char *arg;
1332
{
1333
  if (ldfile_assumed_script)
1334
    einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
1335
           ldfile_input_filename);
1336
  if (error_index > 0 && error_index < ERROR_NAME_MAX)
1337
     einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]);
1338
  else
1339
     einfo ("%P%F:%S: %s\n", arg);
1340
}

powered by: WebSVN 2.1.0

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