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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [ld/] [ldgram.y] - Blame information for rev 248

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


/* A YACC grammar to parse a superset of the AT&T linker scripting language.
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
   Free Software Foundation, Inc.
   Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
 
   This file is part of the GNU Binutils.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
 
%{
/*
 
 */
 
#define DONTDECLARE_MALLOC
 
#include "sysdep.h"
#include "bfd.h"
#include "bfdlink.h"
#include "ld.h"
#include "ldexp.h"
#include "ldver.h"
#include "ldlang.h"
#include "ldfile.h"
#include "ldemul.h"
#include "ldmisc.h"
#include "ldmain.h"
#include "mri.h"
#include "ldctor.h"
#include "ldlex.h"
 
#ifndef YYDEBUG
#define YYDEBUG 1
#endif
 
static enum section_type sectype;
static lang_memory_region_type *region;
 
bfd_boolean ldgram_had_keep = FALSE;
char *ldgram_vers_current_lang = NULL;
 
#define ERROR_NAME_MAX 20
static char *error_names[ERROR_NAME_MAX];
static int error_index;
#define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;
#define POP_ERROR()   error_index--;
%}
%union {
  bfd_vma integer;
  struct big_int
    {
      bfd_vma integer;
      char *str;
    } bigint;
  fill_type *fill;
  char *name;
  const char *cname;
  struct wildcard_spec wildcard;
  struct wildcard_list *wildcard_list;
  struct name_list *name_list;
  struct flag_info_list *flag_info_list;
  struct flag_info *flag_info;
  int token;
  union etree_union *etree;
  struct phdr_info
    {
      bfd_boolean filehdr;
      bfd_boolean phdrs;
      union etree_union *at;
      union etree_union *flags;
    } phdr;
  struct lang_nocrossref *nocrossref;
  struct lang_output_section_phdr_list *section_phdr;
  struct bfd_elf_version_deps *deflist;
  struct bfd_elf_version_expr *versyms;
  struct bfd_elf_version_tree *versnode;
}
 
%type  exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val
%type  opt_exp_without_type opt_subalign opt_align
%type  fill_opt fill_exp
%type  exclude_name_list
%type  file_NAME_list
%type  sect_flag_list
%type  sect_flags
%type  memspec_opt casesymlist
%type  memspec_at_opt
%type  wildcard_name
%type  wildcard_spec
%token  INT
%token  NAME LNAME
%type  length
%type  phdr_qualifiers
%type  nocrossref_list
%type  phdr_opt
%type  opt_nocrossrefs
 
%right  PLUSEQ MINUSEQ MULTEQ DIVEQ  '=' LSHIFTEQ RSHIFTEQ   ANDEQ OREQ
%right  '?' ':'
%left  OROR
%left   ANDAND
%left  '|'
%left   '^'
%left   '&'
%left   EQ NE
%left   '<' '>' LE GE
%left   LSHIFT RSHIFT
 
%left   '+' '-'
%left   '*' '/' '%'
 
%right UNARY
%token END
%left  '('
%token  ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE
%token SECTIONS PHDRS INSERT_K AFTER BEFORE
%token DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END
%token SORT_BY_NAME SORT_BY_ALIGNMENT
%token SORT_BY_INIT_PRIORITY
%token '{' '}'
%token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
%token INHIBIT_COMMON_ALLOCATION
%token SEGMENT_START
%token INCLUDE
%token MEMORY
%token REGION_ALIAS
%token LD_FEATURE
%token NOLOAD DSECT COPY INFO OVERLAY
%token DEFINED TARGET_K SEARCH_DIR MAP ENTRY
%token  NEXT
%token SIZEOF ALIGNOF ADDR LOADADDR MAX_K MIN_K
%token STARTUP HLL SYSLIB FLOAT NOFLOAT NOCROSSREFS
%token ORIGIN FILL
%token LENGTH CREATE_OBJECT_SYMBOLS INPUT GROUP OUTPUT CONSTRUCTORS
%token ALIGNMOD AT SUBALIGN PROVIDE PROVIDE_HIDDEN AS_NEEDED
%type  assign_op atype attributes_opt sect_constraint
%type   filename
%token CHIP LIST SECT ABSOLUTE  LOAD NEWLINE ENDWORD ORDER NAMEWORD ASSERT_K
%token FORMAT PUBLIC DEFSYMEND BASE ALIAS TRUNCATE REL
%token INPUT_SCRIPT INPUT_MRI_SCRIPT INPUT_DEFSYM CASE EXTERN START
%token  VERS_TAG VERS_IDENTIFIER
%token GLOBAL LOCAL VERSIONK INPUT_VERSION_SCRIPT
%token KEEP ONLY_IF_RO ONLY_IF_RW SPECIAL INPUT_SECTION_FLAGS
%token EXCLUDE_FILE
%token CONSTANT
%type  vers_defns
%type  vers_tag
%type  verdep
%token INPUT_DYNAMIC_LIST
 
%%
 
file:
                INPUT_SCRIPT script_file
        |       INPUT_MRI_SCRIPT mri_script_file
        |       INPUT_VERSION_SCRIPT version_script_file
        |       INPUT_DYNAMIC_LIST dynamic_list_file
        |       INPUT_DEFSYM defsym_expr
        ;
 
 
filename:  NAME;
 
 
defsym_expr:
                { ldlex_defsym(); }
                NAME '=' exp
                {
                  ldlex_popstate();
                  lang_add_assignment (exp_defsym ($2, $4));
                }
        ;
 
/* SYNTAX WITHIN AN MRI SCRIPT FILE */
mri_script_file:
                {
                  ldlex_mri_script ();
                  PUSH_ERROR (_("MRI style script"));
                }
             mri_script_lines
                {
                  ldlex_popstate ();
                  mri_draw_tree ();
                  POP_ERROR ();
                }
        ;
 
mri_script_lines:
                mri_script_lines mri_script_command NEWLINE
          |
        ;
 
mri_script_command:
                CHIP  exp
        |       CHIP  exp ',' exp
        |       NAME    {
                        einfo(_("%P%F: unrecognised keyword in MRI style script '%s'\n"),$1);
                        }
        |       LIST    {
                        config.map_filename = "-";
                        }
        |       ORDER ordernamelist
        |       ENDWORD
        |       PUBLIC NAME '=' exp
                        { mri_public($2, $4); }
        |       PUBLIC NAME ',' exp
                        { mri_public($2, $4); }
        |       PUBLIC NAME  exp
                        { mri_public($2, $3); }
        |       FORMAT NAME
                        { mri_format($2); }
        |       SECT NAME ',' exp
                        { mri_output_section($2, $4);}
        |       SECT NAME  exp
                        { mri_output_section($2, $3);}
        |       SECT NAME '=' exp
                        { mri_output_section($2, $4);}
        |       ALIGN_K NAME '=' exp
                        { mri_align($2,$4); }
        |       ALIGN_K NAME ',' exp
                        { mri_align($2,$4); }
        |       ALIGNMOD NAME '=' exp
                        { mri_alignmod($2,$4); }
        |       ALIGNMOD NAME ',' exp
                        { mri_alignmod($2,$4); }
        |       ABSOLUTE mri_abs_name_list
        |       LOAD     mri_load_name_list
        |       NAMEWORD NAME
                        { mri_name($2); }
        |       ALIAS NAME ',' NAME
                        { mri_alias($2,$4,0);}
        |       ALIAS NAME ',' INT
                        { mri_alias ($2, 0, (int) $4.integer); }
        |       BASE     exp
                        { mri_base($2); }
        |       TRUNCATE INT
                { mri_truncate ((unsigned int) $2.integer); }
        |       CASE casesymlist
        |       EXTERN extern_name_list
        |       INCLUDE filename
                { ldlex_script (); ldfile_open_command_file($2); }
                mri_script_lines END
                { ldlex_popstate (); }
        |       START NAME
                { lang_add_entry ($2, FALSE); }
        |
        ;
 
ordernamelist:
              ordernamelist ',' NAME         { mri_order($3); }
        |     ordernamelist  NAME         { mri_order($2); }
        |
        ;
 
mri_load_name_list:
                NAME
                        { mri_load($1); }
        |       mri_load_name_list ',' NAME { mri_load($3); }
        ;
 
mri_abs_name_list:
                NAME
                        { mri_only_load($1); }
        |       mri_abs_name_list ','  NAME
                        { mri_only_load($3); }
        ;
 
casesymlist:
          /* empty */ { $$ = NULL; }
        | NAME
        | casesymlist ',' NAME
        ;
 
/* Parsed as expressions so that commas separate entries */
extern_name_list:
        { ldlex_expression (); }
        extern_name_list_body
        { ldlex_popstate (); }
 
extern_name_list_body:
          NAME
                        { ldlang_add_undef ($1, FALSE); }
        | extern_name_list_body NAME
                        { ldlang_add_undef ($2, FALSE); }
        | extern_name_list_body ',' NAME
                        { ldlang_add_undef ($3, FALSE); }
        ;
 
script_file:
        { ldlex_both(); }
        ifile_list
        { ldlex_popstate(); }
        ;
 
ifile_list:
        ifile_list ifile_p1
        |
        ;
 
 
ifile_p1:
                memory
        |       sections
        |       phdrs
        |       startup
        |       high_level_library
        |       low_level_library
        |       floating_point_support
        |       statement_anywhere
        |       version
        |        ';'
        |       TARGET_K '(' NAME ')'
                { lang_add_target($3); }
        |       SEARCH_DIR '(' filename ')'
                { ldfile_add_library_path ($3, FALSE); }
        |       OUTPUT '(' filename ')'
                { lang_add_output($3, 1); }
        |       OUTPUT_FORMAT '(' NAME ')'
                  { lang_add_output_format ($3, (char *) NULL,
                                            (char *) NULL, 1); }
        |       OUTPUT_FORMAT '(' NAME ',' NAME ',' NAME ')'
                  { lang_add_output_format ($3, $5, $7, 1); }
        |       OUTPUT_ARCH '(' NAME ')'
                  { ldfile_set_output_arch ($3, bfd_arch_unknown); }
        |       FORCE_COMMON_ALLOCATION
                { command_line.force_common_definition = TRUE ; }
        |       INHIBIT_COMMON_ALLOCATION
                { command_line.inhibit_common_definition = TRUE ; }
        |       INPUT '(' input_list ')'
        |       GROUP
                  { lang_enter_group (); }
                    '(' input_list ')'
                  { lang_leave_group (); }
        |       MAP '(' filename ')'
                { lang_add_map($3); }
        |       INCLUDE filename
                { ldlex_script (); ldfile_open_command_file($2); }
                ifile_list END
                { ldlex_popstate (); }
        |       NOCROSSREFS '(' nocrossref_list ')'
                {
                  lang_add_nocrossref ($3);
                }
        |       EXTERN '(' extern_name_list ')'
        |       INSERT_K AFTER NAME
                { lang_add_insert ($3, 0); }
        |       INSERT_K BEFORE NAME
                { lang_add_insert ($3, 1); }
        |       REGION_ALIAS '(' NAME ',' NAME ')'
                { lang_memory_region_alias ($3, $5); }
        |       LD_FEATURE '(' NAME ')'
                { lang_ld_feature ($3); }
        ;
 
input_list:
                NAME
                { lang_add_input_file($1,lang_input_file_is_search_file_enum,
                                 (char *)NULL); }
        |       input_list ',' NAME
                { lang_add_input_file($3,lang_input_file_is_search_file_enum,
                                 (char *)NULL); }
        |       input_list NAME
                { lang_add_input_file($2,lang_input_file_is_search_file_enum,
                                 (char *)NULL); }
        |       LNAME
                { lang_add_input_file($1,lang_input_file_is_l_enum,
                                 (char *)NULL); }
        |       input_list ',' LNAME
                { lang_add_input_file($3,lang_input_file_is_l_enum,
                                 (char *)NULL); }
        |       input_list LNAME
                { lang_add_input_file($2,lang_input_file_is_l_enum,
                                 (char *)NULL); }
        |       AS_NEEDED '('
                  { $$ = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; }
                     input_list ')'
                  { add_DT_NEEDED_for_regular = $3; }
        |       input_list ',' AS_NEEDED '('
                  { $$ = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; }
                     input_list ')'
                  { add_DT_NEEDED_for_regular = $5; }
        |       input_list AS_NEEDED '('
                  { $$ = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; }
                     input_list ')'
                  { add_DT_NEEDED_for_regular = $4; }
        ;
 
sections:
                SECTIONS '{' sec_or_group_p1 '}'
        ;
 
sec_or_group_p1:
                sec_or_group_p1 section
        |       sec_or_group_p1 statement_anywhere
        |
        ;
 
statement_anywhere:
                ENTRY '(' NAME ')'
                { lang_add_entry ($3, FALSE); }
        |       assignment end
        |       ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')'
                { ldlex_popstate ();
                  lang_add_assignment (exp_assert ($4, $6)); }
        ;
 
/* The '*' and '?' cases are there because the lexer returns them as
   separate tokens rather than as NAME.  */
wildcard_name:
                NAME
                        {
                          $$ = $1;
                        }
        |       '*'
                        {
                          $$ = "*";
                        }
        |       '?'
                        {
                          $$ = "?";
                        }
        ;
 
wildcard_spec:
                wildcard_name
                        {
                          $$.name = $1;
                          $$.sorted = none;
                          $$.exclude_name_list = NULL;
                          $$.section_flag_list = NULL;
                        }
        |       EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name
                        {
                          $$.name = $5;
                          $$.sorted = none;
                          $$.exclude_name_list = $3;
                          $$.section_flag_list = NULL;
                        }
        |       SORT_BY_NAME '(' wildcard_name ')'
                        {
                          $$.name = $3;
                          $$.sorted = by_name;
                          $$.exclude_name_list = NULL;
                          $$.section_flag_list = NULL;
                        }
        |       SORT_BY_ALIGNMENT '(' wildcard_name ')'
                        {
                          $$.name = $3;
                          $$.sorted = by_alignment;
                          $$.exclude_name_list = NULL;
                          $$.section_flag_list = NULL;
                        }
        |       SORT_BY_NAME '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
                        {
                          $$.name = $5;
                          $$.sorted = by_name_alignment;
                          $$.exclude_name_list = NULL;
                          $$.section_flag_list = NULL;
                        }
        |       SORT_BY_NAME '(' SORT_BY_NAME '(' wildcard_name ')' ')'
                        {
                          $$.name = $5;
                          $$.sorted = by_name;
                          $$.exclude_name_list = NULL;
                          $$.section_flag_list = NULL;
                        }
        |       SORT_BY_ALIGNMENT '(' SORT_BY_NAME '(' wildcard_name ')' ')'
                        {
                          $$.name = $5;
                          $$.sorted = by_alignment_name;
                          $$.exclude_name_list = NULL;
                          $$.section_flag_list = NULL;
                        }
        |       SORT_BY_ALIGNMENT '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'
                        {
                          $$.name = $5;
                          $$.sorted = by_alignment;
                          $$.exclude_name_list = NULL;
                          $$.section_flag_list = NULL;
                        }
        |       SORT_BY_NAME '(' EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name ')'
                        {
                          $$.name = $7;
                          $$.sorted = by_name;
                          $$.exclude_name_list = $5;
                          $$.section_flag_list = NULL;
                        }
        |       SORT_BY_INIT_PRIORITY '(' wildcard_name ')'
                        {
                          $$.name = $3;
                          $$.sorted = by_init_priority;
                          $$.exclude_name_list = NULL;
                          $$.section_flag_list = NULL;
                        }
        ;
 
sect_flag_list: NAME
                        {
                          struct flag_info_list *n;
                          n = ((struct flag_info_list *) xmalloc (sizeof *n));
                          if ($1[0] == '!')
                            {
                              n->with = without_flags;
                              n->name = &$1[1];
                            }
                          else
                            {
                              n->with = with_flags;
                              n->name = $1;
                            }
                          n->valid = FALSE;
                          n->next = NULL;
                          $$ = n;
                        }
        |       sect_flag_list '&' NAME
                        {
                          struct flag_info_list *n;
                          n = ((struct flag_info_list *) xmalloc (sizeof *n));
                          if ($3[0] == '!')
                            {
                              n->with = without_flags;
                              n->name = &$3[1];
                            }
                          else
                            {
                              n->with = with_flags;
                              n->name = $3;
                            }
                          n->valid = FALSE;
                          n->next = $1;
                          $$ = n;
                        }
        ;
 
sect_flags:
                INPUT_SECTION_FLAGS '(' sect_flag_list ')'
                        {
                          struct flag_info *n;
                          n = ((struct flag_info *) xmalloc (sizeof *n));
                          n->flag_list = $3;
                          n->flags_initialized = FALSE;
                          n->not_with_flags = 0;
                          n->only_with_flags = 0;
                          $$ = n;
                        }
        ;
 
exclude_name_list:
                exclude_name_list wildcard_name
                        {
                          struct name_list *tmp;
                          tmp = (struct name_list *) xmalloc (sizeof *tmp);
                          tmp->name = $2;
                          tmp->next = $1;
                          $$ = tmp;
                        }
        |
                wildcard_name
                        {
                          struct name_list *tmp;
                          tmp = (struct name_list *) xmalloc (sizeof *tmp);
                          tmp->name = $1;
                          tmp->next = NULL;
                          $$ = tmp;
                        }
        ;
 
file_NAME_list:
                file_NAME_list opt_comma wildcard_spec
                        {
                          struct wildcard_list *tmp;
                          tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
                          tmp->next = $1;
                          tmp->spec = $3;
                          $$ = tmp;
                        }
        |
                wildcard_spec
                        {
                          struct wildcard_list *tmp;
                          tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
                          tmp->next = NULL;
                          tmp->spec = $1;
                          $$ = tmp;
                        }
        ;
 
input_section_spec_no_keep:
                NAME
                        {
                          struct wildcard_spec tmp;
                          tmp.name = $1;
                          tmp.exclude_name_list = NULL;
                          tmp.sorted = none;
                          tmp.section_flag_list = NULL;
                          lang_add_wild (&tmp, NULL, ldgram_had_keep);
                        }
        |       sect_flags NAME
                        {
                          struct wildcard_spec tmp;
                          tmp.name = $2;
                          tmp.exclude_name_list = NULL;
                          tmp.sorted = none;
                          tmp.section_flag_list = $1;
                          lang_add_wild (&tmp, NULL, ldgram_had_keep);
                        }
        |       '[' file_NAME_list ']'
                        {
                          lang_add_wild (NULL, $2, ldgram_had_keep);
                        }
        |       sect_flags '[' file_NAME_list ']'
                        {
                          struct wildcard_spec tmp;
                          tmp.name = NULL;
                          tmp.exclude_name_list = NULL;
                          tmp.sorted = none;
                          tmp.section_flag_list = $1;
                          lang_add_wild (&tmp, $3, ldgram_had_keep);
                        }
        |       wildcard_spec '(' file_NAME_list ')'
                        {
                          lang_add_wild (&$1, $3, ldgram_had_keep);
                        }
        |       sect_flags wildcard_spec '(' file_NAME_list ')'
                        {
                          $2.section_flag_list = $1;
                          lang_add_wild (&$2, $4, ldgram_had_keep);
                        }
        ;
 
input_section_spec:
                input_section_spec_no_keep
        |       KEEP '('
                        { ldgram_had_keep = TRUE; }
                input_section_spec_no_keep ')'
                        { ldgram_had_keep = FALSE; }
        ;
 
statement:
                assignment end
        |       CREATE_OBJECT_SYMBOLS
                {
                lang_add_attribute(lang_object_symbols_statement_enum);
                }
        |       ';'
        |       CONSTRUCTORS
                {
 
                  lang_add_attribute(lang_constructors_statement_enum);
                }
        | SORT_BY_NAME '(' CONSTRUCTORS ')'
                {
                  constructors_sorted = TRUE;
                  lang_add_attribute (lang_constructors_statement_enum);
                }
        | input_section_spec
        | length '(' mustbe_exp ')'
                        {
                          lang_add_data ((int) $1, $3);
                        }
 
        | FILL '(' fill_exp ')'
                        {
                          lang_add_fill ($3);
                        }
        | ASSERT_K  {ldlex_expression ();} '(' exp ',' NAME ')' end
                        { ldlex_popstate ();
                          lang_add_assignment (exp_assert ($4, $6)); }
        | INCLUDE filename
                { ldlex_script (); ldfile_open_command_file($2); }
                statement_list_opt END
                { ldlex_popstate (); }
        ;
 
statement_list:
                statement_list statement
        |       statement
        ;
 
statement_list_opt:
                /* empty */
        |       statement_list
        ;
 
length:
                QUAD
                        { $$ = $1; }
        |       SQUAD
                        { $$ = $1; }
        |       LONG
                        { $$ = $1; }
        |       SHORT
                        { $$ = $1; }
        |       BYTE
                        { $$ = $1; }
        ;
 
fill_exp:
        mustbe_exp
                {
                  $$ = exp_get_fill ($1, 0, "fill value");
                }
        ;
 
fill_opt:
          '=' fill_exp
                { $$ = $2; }
        |       { $$ = (fill_type *) 0; }
        ;
 
assign_op:
                PLUSEQ
                        { $$ = '+'; }
        |       MINUSEQ
                        { $$ = '-'; }
        |       MULTEQ
                        { $$ = '*'; }
        |       DIVEQ
                        { $$ = '/'; }
        |       LSHIFTEQ
                        { $$ = LSHIFT; }
        |       RSHIFTEQ
                        { $$ = RSHIFT; }
        |       ANDEQ
                        { $$ = '&'; }
        |       OREQ
                        { $$ = '|'; }
 
        ;
 
end:    ';' | ','
        ;
 
 
assignment:
                NAME '=' mustbe_exp
                {
                  lang_add_assignment (exp_assign ($1, $3));
                }
        |       NAME assign_op mustbe_exp
                {
                  lang_add_assignment (exp_assign ($1,
                                                   exp_binop ($2,
                                                              exp_nameop (NAME,
                                                                          $1),
                                                              $3)));
                }
        |       PROVIDE '(' NAME '=' mustbe_exp ')'
                {
                  lang_add_assignment (exp_provide ($3, $5, FALSE));
                }
        |       PROVIDE_HIDDEN '(' NAME '=' mustbe_exp ')'
                {
                  lang_add_assignment (exp_provide ($3, $5, TRUE));
                }
        ;
 
 
opt_comma:
                ','     |       ;
 
 
memory:
                MEMORY '{' memory_spec_list_opt '}'
        ;
 
memory_spec_list_opt: memory_spec_list | ;
 
memory_spec_list:
                memory_spec_list opt_comma memory_spec
        |       memory_spec
        ;
 
 
memory_spec:    NAME
                { region = lang_memory_region_lookup ($1, TRUE); }
                attributes_opt ':'
                origin_spec opt_comma length_spec
                {}
        |       INCLUDE filename
                { ldlex_script (); ldfile_open_command_file($2); }
                memory_spec_list_opt END
                { ldlex_popstate (); }
        ;
 
origin_spec:
        ORIGIN '=' mustbe_exp
                {
                  region->origin = exp_get_vma ($3, 0, "origin");
                  region->current = region->origin;
                }
        ;
 
length_spec:
             LENGTH '=' mustbe_exp
                {
                  region->length = exp_get_vma ($3, -1, "length");
                }
        ;
 
attributes_opt:
                /* empty */
                  { /* dummy action to avoid bison 1.25 error message */ }
        |       '(' attributes_list ')'
        ;
 
attributes_list:
                attributes_string
        |       attributes_list attributes_string
        ;
 
attributes_string:
                NAME
                  { lang_set_flags (region, $1, 0); }
        |       '!' NAME
                  { lang_set_flags (region, $2, 1); }
        ;
 
startup:
        STARTUP '(' filename ')'
                { lang_startup($3); }
        ;
 
high_level_library:
                HLL '(' high_level_library_NAME_list ')'
        |       HLL '(' ')'
                        { ldemul_hll((char *)NULL); }
        ;
 
high_level_library_NAME_list:
                high_level_library_NAME_list opt_comma filename
                        { ldemul_hll($3); }
        |       filename
                        { ldemul_hll($1); }
 
        ;
 
low_level_library:
        SYSLIB '(' low_level_library_NAME_list ')'
        ; low_level_library_NAME_list:
                low_level_library_NAME_list opt_comma filename
                        { ldemul_syslib($3); }
        |
        ;
 
floating_point_support:
                FLOAT
                        { lang_float(TRUE); }
        |       NOFLOAT
                        { lang_float(FALSE); }
        ;
 
nocrossref_list:
                /* empty */
                {
                  $$ = NULL;
                }
        |       NAME nocrossref_list
                {
                  struct lang_nocrossref *n;
 
                  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
                  n->name = $1;
                  n->next = $2;
                  $$ = n;
                }
        |       NAME ',' nocrossref_list
                {
                  struct lang_nocrossref *n;
 
                  n = (struct lang_nocrossref *) xmalloc (sizeof *n);
                  n->name = $1;
                  n->next = $3;
                  $$ = n;
                }
        ;
 
mustbe_exp:              { ldlex_expression (); }
                exp
                         { ldlex_popstate (); $$=$2;}
        ;
 
exp     :
                '-' exp %prec UNARY
                        { $$ = exp_unop ('-', $2); }
        |       '(' exp ')'
                        { $$ = $2; }
        |       NEXT '(' exp ')' %prec UNARY
                        { $$ = exp_unop ((int) $1,$3); }
        |       '!' exp %prec UNARY
                        { $$ = exp_unop ('!', $2); }
        |       '+' exp %prec UNARY
                        { $$ = $2; }
        |       '~' exp %prec UNARY
                        { $$ = exp_unop ('~', $2);}
 
        |       exp '*' exp
                        { $$ = exp_binop ('*', $1, $3); }
        |       exp '/' exp
                        { $$ = exp_binop ('/', $1, $3); }
        |       exp '%' exp
                        { $$ = exp_binop ('%', $1, $3); }
        |       exp '+' exp
                        { $$ = exp_binop ('+', $1, $3); }
        |       exp '-' exp
                        { $$ = exp_binop ('-' , $1, $3); }
        |       exp LSHIFT exp
                        { $$ = exp_binop (LSHIFT , $1, $3); }
        |       exp RSHIFT exp
                        { $$ = exp_binop (RSHIFT , $1, $3); }
        |       exp EQ exp
                        { $$ = exp_binop (EQ , $1, $3); }
        |       exp NE exp
                        { $$ = exp_binop (NE , $1, $3); }
        |       exp LE exp
                        { $$ = exp_binop (LE , $1, $3); }
        |       exp GE exp
                        { $$ = exp_binop (GE , $1, $3); }
        |       exp '<' exp
                        { $$ = exp_binop ('<' , $1, $3); }
        |       exp '>' exp
                        { $$ = exp_binop ('>' , $1, $3); }
        |       exp '&' exp
                        { $$ = exp_binop ('&' , $1, $3); }
        |       exp '^' exp
                        { $$ = exp_binop ('^' , $1, $3); }
        |       exp '|' exp
                        { $$ = exp_binop ('|' , $1, $3); }
        |       exp '?' exp ':' exp
                        { $$ = exp_trinop ('?' , $1, $3, $5); }
        |       exp ANDAND exp
                        { $$ = exp_binop (ANDAND , $1, $3); }
        |       exp OROR exp
                        { $$ = exp_binop (OROR , $1, $3); }
        |       DEFINED '(' NAME ')'
                        { $$ = exp_nameop (DEFINED, $3); }
        |       INT
                        { $$ = exp_bigintop ($1.integer, $1.str); }
        |       SIZEOF_HEADERS
                        { $$ = exp_nameop (SIZEOF_HEADERS,0); }
 
        |       ALIGNOF '(' NAME ')'
                        { $$ = exp_nameop (ALIGNOF,$3); }
        |       SIZEOF '(' NAME ')'
                        { $$ = exp_nameop (SIZEOF,$3); }
        |       ADDR '(' NAME ')'
                        { $$ = exp_nameop (ADDR,$3); }
        |       LOADADDR '(' NAME ')'
                        { $$ = exp_nameop (LOADADDR,$3); }
        |       CONSTANT '(' NAME ')'
                        { $$ = exp_nameop (CONSTANT,$3); }
        |       ABSOLUTE '(' exp ')'
                        { $$ = exp_unop (ABSOLUTE, $3); }
        |       ALIGN_K '(' exp ')'
                        { $$ = exp_unop (ALIGN_K,$3); }
        |       ALIGN_K '(' exp ',' exp ')'
                        { $$ = exp_binop (ALIGN_K,$3,$5); }
        |       DATA_SEGMENT_ALIGN '(' exp ',' exp ')'
                        { $$ = exp_binop (DATA_SEGMENT_ALIGN, $3, $5); }
        |       DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
                        { $$ = exp_binop (DATA_SEGMENT_RELRO_END, $5, $3); }
        |       DATA_SEGMENT_END '(' exp ')'
                        { $$ = exp_unop (DATA_SEGMENT_END, $3); }
        |       SEGMENT_START '(' NAME ',' exp ')'
                        { /* The operands to the expression node are
                             placed in the opposite order from the way
                             in which they appear in the script as
                             that allows us to reuse more code in
                             fold_binary.  */
                          $$ = exp_binop (SEGMENT_START,
                                          $5,
                                          exp_nameop (NAME, $3)); }
        |       BLOCK '(' exp ')'
                        { $$ = exp_unop (ALIGN_K,$3); }
        |       NAME
                        { $$ = exp_nameop (NAME,$1); }
        |       MAX_K '(' exp ',' exp ')'
                        { $$ = exp_binop (MAX_K, $3, $5 ); }
        |       MIN_K '(' exp ',' exp ')'
                        { $$ = exp_binop (MIN_K, $3, $5 ); }
        |       ASSERT_K '(' exp ',' NAME ')'
                        { $$ = exp_assert ($3, $5); }
        |       ORIGIN '(' NAME ')'
                        { $$ = exp_nameop (ORIGIN, $3); }
        |       LENGTH '(' NAME ')'
                        { $$ = exp_nameop (LENGTH, $3); }
        ;
 
 
memspec_at_opt:
                AT '>' NAME { $$ = $3; }
        |       { $$ = 0; }
        ;
 
opt_at:
                AT '(' exp ')' { $$ = $3; }
        |       { $$ = 0; }
        ;
 
opt_align:
                ALIGN_K '(' exp ')' { $$ = $3; }
        |       { $$ = 0; }
        ;
 
opt_subalign:
                SUBALIGN '(' exp ')' { $$ = $3; }
        |       { $$ = 0; }
        ;
 
sect_constraint:
                ONLY_IF_RO { $$ = ONLY_IF_RO; }
        |       ONLY_IF_RW { $$ = ONLY_IF_RW; }
        |       SPECIAL { $$ = SPECIAL; }
        |       { $$ = 0; }
        ;
 
section:        NAME            { ldlex_expression(); }
                opt_exp_with_type
                opt_at
                opt_align
                opt_subalign    { ldlex_popstate (); ldlex_script (); }
                sect_constraint
                '{'
                        {
                          lang_enter_output_section_statement($1, $3,
                                                              sectype,
                                                              $5, $6, $4, $8);
                        }
                statement_list_opt
                '}' { ldlex_popstate (); ldlex_expression (); }
                memspec_opt memspec_at_opt phdr_opt fill_opt
                {
                  ldlex_popstate ();
                  lang_leave_output_section_statement ($17, $14, $16, $15);
                }
                opt_comma
                {}
        |       OVERLAY
                        { ldlex_expression (); }
                opt_exp_without_type opt_nocrossrefs opt_at opt_subalign
                        { ldlex_popstate (); ldlex_script (); }
                '{'
                        {
                          lang_enter_overlay ($3, $6);
                        }
                overlay_section
                '}'
                        { ldlex_popstate (); ldlex_expression (); }
                memspec_opt memspec_at_opt phdr_opt fill_opt
                        {
                          ldlex_popstate ();
                          lang_leave_overlay ($5, (int) $4,
                                              $16, $13, $15, $14);
                        }
                opt_comma
        |       /* The GROUP case is just enough to support the gcc
                   svr3.ifile script.  It is not intended to be full
                   support.  I'm not even sure what GROUP is supposed
                   to mean.  */
                GROUP { ldlex_expression (); }
                opt_exp_with_type
                {
                  ldlex_popstate ();
                  lang_add_assignment (exp_assign (".", $3));
                }
                '{' sec_or_group_p1 '}'
        |       INCLUDE filename
                { ldlex_script (); ldfile_open_command_file($2); }
                sec_or_group_p1 END
                { ldlex_popstate (); }
        ;
 
type:
           NOLOAD  { sectype = noload_section; }
        |  DSECT   { sectype = noalloc_section; }
        |  COPY    { sectype = noalloc_section; }
        |  INFO    { sectype = noalloc_section; }
        |  OVERLAY { sectype = noalloc_section; }
        ;
 
atype:
                '(' type ')'
        |       /* EMPTY */ { sectype = normal_section; }
        |       '(' ')' { sectype = normal_section; }
        ;
 
opt_exp_with_type:
                exp atype ':'           { $$ = $1; }
        |       atype ':'               { $$ = (etree_type *)NULL;  }
        |       /* The BIND cases are to support the gcc svr3.ifile
                   script.  They aren't intended to implement full
                   support for the BIND keyword.  I'm not even sure
                   what BIND is supposed to mean.  */
                BIND '(' exp ')' atype ':' { $$ = $3; }
        |       BIND '(' exp ')' BLOCK '(' exp ')' atype ':'
                { $$ = $3; }
        ;
 
opt_exp_without_type:
                exp ':'         { $$ = $1; }
        |       ':'             { $$ = (etree_type *) NULL;  }
        ;
 
opt_nocrossrefs:
                /* empty */
                        { $$ = 0; }
        |       NOCROSSREFS
                        { $$ = 1; }
        ;
 
memspec_opt:
                '>' NAME
                { $$ = $2; }
        |       { $$ = DEFAULT_MEMORY_REGION; }
        ;
 
phdr_opt:
                /* empty */
                {
                  $$ = NULL;
                }
        |       phdr_opt ':' NAME
                {
                  struct lang_output_section_phdr_list *n;
 
                  n = ((struct lang_output_section_phdr_list *)
                       xmalloc (sizeof *n));
                  n->name = $3;
                  n->used = FALSE;
                  n->next = $1;
                  $$ = n;
                }
        ;
 
overlay_section:
                /* empty */
        |       overlay_section
                NAME
                        {
                          ldlex_script ();
                          lang_enter_overlay_section ($2);
                        }
                '{' statement_list_opt '}'
                        { ldlex_popstate (); ldlex_expression (); }
                phdr_opt fill_opt
                        {
                          ldlex_popstate ();
                          lang_leave_overlay_section ($9, $8);
                        }
                opt_comma
        ;
 
phdrs:
                PHDRS '{' phdr_list '}'
        ;
 
phdr_list:
                /* empty */
        |       phdr_list phdr
        ;
 
phdr:
                NAME { ldlex_expression (); }
                  phdr_type phdr_qualifiers { ldlex_popstate (); }
                  ';'
                {
                  lang_new_phdr ($1, $3, $4.filehdr, $4.phdrs, $4.at,
                                 $4.flags);
                }
        ;
 
phdr_type:
                exp
                {
                  $$ = $1;
 
                  if ($1->type.node_class == etree_name
                      && $1->type.node_code == NAME)
                    {
                      const char *s;
                      unsigned int i;
                      static const char * const phdr_types[] =
                        {
                          "PT_NULL", "PT_LOAD", "PT_DYNAMIC",
                          "PT_INTERP", "PT_NOTE", "PT_SHLIB",
                          "PT_PHDR", "PT_TLS"
                        };
 
                      s = $1->name.name;
                      for (i = 0;
                           i < sizeof phdr_types / sizeof phdr_types[0];
                           i++)
                        if (strcmp (s, phdr_types[i]) == 0)
                          {
                            $$ = exp_intop (i);
                            break;
                          }
                      if (i == sizeof phdr_types / sizeof phdr_types[0])
                        {
                          if (strcmp (s, "PT_GNU_EH_FRAME") == 0)
                            $$ = exp_intop (0x6474e550);
                          else if (strcmp (s, "PT_GNU_STACK") == 0)
                            $$ = exp_intop (0x6474e551);
                          else
                            {
                              einfo (_("\
%X%P:%S: unknown phdr type `%s' (try integer literal)\n"),
                                     NULL, s);
                              $$ = exp_intop (0);
                            }
                        }
                    }
                }
        ;
 
phdr_qualifiers:
                /* empty */
                {
                  memset (&$$, 0, sizeof (struct phdr_info));
                }
        |       NAME phdr_val phdr_qualifiers
                {
                  $$ = $3;
                  if (strcmp ($1, "FILEHDR") == 0 && $2 == NULL)
                    $$.filehdr = TRUE;
                  else if (strcmp ($1, "PHDRS") == 0 && $2 == NULL)
                    $$.phdrs = TRUE;
                  else if (strcmp ($1, "FLAGS") == 0 && $2 != NULL)
                    $$.flags = $2;
                  else
                    einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"),
                           NULL, $1);
                }
        |       AT '(' exp ')' phdr_qualifiers
                {
                  $$ = $5;
                  $$.at = $3;
                }
        ;
 
phdr_val:
                /* empty */
                {
                  $$ = NULL;
                }
        | '(' exp ')'
                {
                  $$ = $2;
                }
        ;
 
dynamic_list_file:
                {
                  ldlex_version_file ();
                  PUSH_ERROR (_("dynamic list"));
                }
                dynamic_list_nodes
                {
                  ldlex_popstate ();
                  POP_ERROR ();
                }
        ;
 
dynamic_list_nodes:
                dynamic_list_node
        |       dynamic_list_nodes dynamic_list_node
        ;
 
dynamic_list_node:
                '{' dynamic_list_tag '}' ';'
        ;
 
dynamic_list_tag:
                vers_defns ';'
                {
                  lang_append_dynamic_list ($1);
                }
        ;
 
/* This syntax is used within an external version script file.  */
 
version_script_file:
                {
                  ldlex_version_file ();
                  PUSH_ERROR (_("VERSION script"));
                }
                vers_nodes
                {
                  ldlex_popstate ();
                  POP_ERROR ();
                }
        ;
 
/* This is used within a normal linker script file.  */
 
version:
                {
                  ldlex_version_script ();
                }
                VERSIONK '{' vers_nodes '}'
                {
                  ldlex_popstate ();
                }
        ;
 
vers_nodes:
                vers_node
        |       vers_nodes vers_node
        ;
 
vers_node:
                '{' vers_tag '}' ';'
                {
                  lang_register_vers_node (NULL, $2, NULL);
                }
        |       VERS_TAG '{' vers_tag '}' ';'
                {
                  lang_register_vers_node ($1, $3, NULL);
                }
        |       VERS_TAG '{' vers_tag '}' verdep ';'
                {
                  lang_register_vers_node ($1, $3, $5);
                }
        ;
 
verdep:
                VERS_TAG
                {
                  $$ = lang_add_vers_depend (NULL, $1);
                }
        |       verdep VERS_TAG
                {
                  $$ = lang_add_vers_depend ($1, $2);
                }
        ;
 
vers_tag:
                /* empty */
                {
                  $$ = lang_new_vers_node (NULL, NULL);
                }
        |       vers_defns ';'
                {
                  $$ = lang_new_vers_node ($1, NULL);
                }
        |       GLOBAL ':' vers_defns ';'
                {
                  $$ = lang_new_vers_node ($3, NULL);
                }
        |       LOCAL ':' vers_defns ';'
                {
                  $$ = lang_new_vers_node (NULL, $3);
                }
        |       GLOBAL ':' vers_defns ';' LOCAL ':' vers_defns ';'
                {
                  $$ = lang_new_vers_node ($3, $7);
                }
        ;
 
vers_defns:
                VERS_IDENTIFIER
                {
                  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, FALSE);
                }
        |       NAME
                {
                  $$ = lang_new_vers_pattern (NULL, $1, ldgram_vers_current_lang, TRUE);
                }
        |       vers_defns ';' VERS_IDENTIFIER
                {
                  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, FALSE);
                }
        |       vers_defns ';' NAME
                {
                  $$ = lang_new_vers_pattern ($1, $3, ldgram_vers_current_lang, TRUE);
                }
        |       vers_defns ';' EXTERN NAME '{'
                        {
                          $$ = ldgram_vers_current_lang;
                          ldgram_vers_current_lang = $4;
                        }
                vers_defns opt_semicolon '}'
                        {
                          struct bfd_elf_version_expr *pat;
                          for (pat = $7; pat->next != NULL; pat = pat->next);
                          pat->next = $1;
                          $$ = $7;
                          ldgram_vers_current_lang = $6;
                        }
        |       EXTERN NAME '{'
                        {
                          $$ = ldgram_vers_current_lang;
                          ldgram_vers_current_lang = $2;
                        }
                vers_defns opt_semicolon '}'
                        {
                          $$ = $5;
                          ldgram_vers_current_lang = $4;
                        }
        |       GLOBAL
                {
                  $$ = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE);
                }
        |       vers_defns ';' GLOBAL
                {
                  $$ = lang_new_vers_pattern ($1, "global", ldgram_vers_current_lang, FALSE);
                }
        |       LOCAL
                {
                  $$ = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE);
                }
        |       vers_defns ';' LOCAL
                {
                  $$ = lang_new_vers_pattern ($1, "local", ldgram_vers_current_lang, FALSE);
                }
        |       EXTERN
                {
                  $$ = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE);
                }
        |       vers_defns ';' EXTERN
                {
                  $$ = lang_new_vers_pattern ($1, "extern", ldgram_vers_current_lang, FALSE);
                }
        ;
 
opt_semicolon:
                /* empty */
        |       ';'
        ;
 
%%
void
yyerror(arg)
     const char *arg;
{
  if (ldfile_assumed_script)
    einfo (_("%P:%s: file format not recognized; treating as linker script\n"),
           ldlex_filename ());
  if (error_index > 0 && error_index < ERROR_NAME_MAX)
    einfo ("%P%F:%S: %s in %s\n", NULL, arg, error_names[error_index - 1]);
  else
    einfo ("%P%F:%S: %s\n", NULL, arg);
}

Line No.	Rev	Author	Line
1	145	khays	`/* 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	166	khays	`2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012`
4	145	khays	`Free Software Foundation, Inc.`
5			`Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).`
6
7			`This file is part of the GNU Binutils.`
8
9			`This program is free software; you can redistribute it and/or modify`
10			`it under the terms of the GNU General Public License as published by`
11			`the Free Software Foundation; either version 3 of the License, or`
12			`(at your option) any later version.`
13
14			`This program is distributed in the hope that it will be useful,`
15			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
16			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
17			`GNU General Public License for more details.`
18
19			`You should have received a copy of the GNU General Public License`
20			`along with this program; if not, write to the Free Software`
21			`Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,`
22			`MA 02110-1301, USA. */`
23
24			`%{`
25			`/*`
26
27			`*/`
28
29			`#define DONTDECLARE_MALLOC`
30
31			`#include "sysdep.h"`
32			`#include "bfd.h"`
33			`#include "bfdlink.h"`
34			`#include "ld.h"`
35			`#include "ldexp.h"`
36			`#include "ldver.h"`
37			`#include "ldlang.h"`
38			`#include "ldfile.h"`
39			`#include "ldemul.h"`
40			`#include "ldmisc.h"`
41			`#include "ldmain.h"`
42			`#include "mri.h"`
43			`#include "ldctor.h"`
44			`#include "ldlex.h"`
45
46			`#ifndef YYDEBUG`
47			`#define YYDEBUG 1`
48			`#endif`
49
50			`static enum section_type sectype;`
51			`static lang_memory_region_type *region;`
52
53			`bfd_boolean ldgram_had_keep = FALSE;`
54			`char *ldgram_vers_current_lang = NULL;`
55
56			`#define ERROR_NAME_MAX 20`
57			`static char *error_names[ERROR_NAME_MAX];`
58			`static int error_index;`
59			`#define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++;`
60			`#define POP_ERROR() error_index--;`
61			`%}`
62			`%union {`
63			`bfd_vma integer;`
64			`struct big_int`
65			`{`
66			`bfd_vma integer;`
67			`char *str;`
68			`} bigint;`
69			`fill_type *fill;`
70			`char *name;`
71			`const char *cname;`
72			`struct wildcard_spec wildcard;`
73			`struct wildcard_list *wildcard_list;`
74			`struct name_list *name_list;`
75	157	khays	`struct flag_info_list *flag_info_list;`
76			`struct flag_info *flag_info;`
77	145	khays	`int token;`
78			`union etree_union *etree;`
79			`struct phdr_info`
80			`{`
81			`bfd_boolean filehdr;`
82			`bfd_boolean phdrs;`
83			`union etree_union *at;`
84			`union etree_union *flags;`
85			`} phdr;`
86			`struct lang_nocrossref *nocrossref;`
87			`struct lang_output_section_phdr_list *section_phdr;`
88			`struct bfd_elf_version_deps *deflist;`
89			`struct bfd_elf_version_expr *versyms;`
90			`struct bfd_elf_version_tree *versnode;`
91			`}`
92
93			`%type exp opt_exp_with_type mustbe_exp opt_at phdr_type phdr_val`
94			`%type opt_exp_without_type opt_subalign opt_align`
95			`%type fill_opt fill_exp`
96			`%type exclude_name_list`
97			`%type file_NAME_list`
98	157	khays	`%type sect_flag_list`
99			`%type sect_flags`
100	145	khays	`%type memspec_opt casesymlist`
101			`%type memspec_at_opt`
102			`%type wildcard_name`
103			`%type wildcard_spec`
104			`%token INT`
105			`%token NAME LNAME`
106			`%type length`
107			`%type phdr_qualifiers`
108			`%type nocrossref_list`
109			`%type phdr_opt`
110			`%type opt_nocrossrefs`
111
112			`%right PLUSEQ MINUSEQ MULTEQ DIVEQ '=' LSHIFTEQ RSHIFTEQ ANDEQ OREQ`
113			`%right '?' ':'`
114			`%left OROR`
115			`%left ANDAND`
116			`%left '\|'`
117			`%left '^'`
118			`%left '&'`
119			`%left EQ NE`
120			`%left '<' '>' LE GE`
121			`%left LSHIFT RSHIFT`
122
123			`%left '+' '-'`
124			`%left '*' '/' '%'`
125
126			`%right UNARY`
127			`%token END`
128			`%left '('`
129			`%token ALIGN_K BLOCK BIND QUAD SQUAD LONG SHORT BYTE`
130			`%token SECTIONS PHDRS INSERT_K AFTER BEFORE`
131			`%token DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END DATA_SEGMENT_END`
132			`%token SORT_BY_NAME SORT_BY_ALIGNMENT`
133			`%token SORT_BY_INIT_PRIORITY`
134			`%token '{' '}'`
135			`%token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH`
136			`%token INHIBIT_COMMON_ALLOCATION`
137			`%token SEGMENT_START`
138			`%token INCLUDE`
139			`%token MEMORY`
140			`%token REGION_ALIAS`
141			`%token LD_FEATURE`
142			`%token NOLOAD DSECT COPY INFO OVERLAY`
143			`%token DEFINED TARGET_K SEARCH_DIR MAP ENTRY`
144			`%token NEXT`
145			`%token SIZEOF ALIGNOF ADDR LOADADDR MAX_K MIN_K`
146			`%token STARTUP HLL SYSLIB FLOAT NOFLOAT NOCROSSREFS`
147			`%token ORIGIN FILL`
148			`%token LENGTH CREATE_OBJECT_SYMBOLS INPUT GROUP OUTPUT CONSTRUCTORS`
149			`%token ALIGNMOD AT SUBALIGN PROVIDE PROVIDE_HIDDEN AS_NEEDED`
150			`%type assign_op atype attributes_opt sect_constraint`
151			`%type filename`
152			`%token CHIP LIST SECT ABSOLUTE LOAD NEWLINE ENDWORD ORDER NAMEWORD ASSERT_K`
153			`%token FORMAT PUBLIC DEFSYMEND BASE ALIAS TRUNCATE REL`
154			`%token INPUT_SCRIPT INPUT_MRI_SCRIPT INPUT_DEFSYM CASE EXTERN START`
155			`%token VERS_TAG VERS_IDENTIFIER`
156			`%token GLOBAL LOCAL VERSIONK INPUT_VERSION_SCRIPT`
157	157	khays	`%token KEEP ONLY_IF_RO ONLY_IF_RW SPECIAL INPUT_SECTION_FLAGS`
158	145	khays	`%token EXCLUDE_FILE`
159			`%token CONSTANT`
160			`%type vers_defns`
161			`%type vers_tag`
162			`%type verdep`
163			`%token INPUT_DYNAMIC_LIST`
164
165			`%%`
166
167			`file:`
168			`INPUT_SCRIPT script_file`
169			`\| INPUT_MRI_SCRIPT mri_script_file`
170			`\| INPUT_VERSION_SCRIPT version_script_file`
171			`\| INPUT_DYNAMIC_LIST dynamic_list_file`
172			`\| INPUT_DEFSYM defsym_expr`
173			`;`
174
175
176			`filename: NAME;`
177
178
179			`defsym_expr:`
180			`{ ldlex_defsym(); }`
181			`NAME '=' exp`
182			`{`
183			`ldlex_popstate();`
184			`lang_add_assignment (exp_defsym ($2, $4));`
185			`}`
186			`;`
187
188			`/* SYNTAX WITHIN AN MRI SCRIPT FILE */`
189			`mri_script_file:`
190			`{`
191			`ldlex_mri_script ();`
192			`PUSH_ERROR (_("MRI style script"));`
193			`}`
194			`mri_script_lines`
195			`{`
196			`ldlex_popstate ();`
197			`mri_draw_tree ();`
198			`POP_ERROR ();`
199			`}`
200			`;`
201
202			`mri_script_lines:`
203			`mri_script_lines mri_script_command NEWLINE`
204			`\|`
205			`;`
206
207			`mri_script_command:`
208			`CHIP exp`
209			`\| CHIP exp ',' exp`
210			`\| NAME {`
211			`einfo(_("%P%F: unrecognised keyword in MRI style script '%s'\n"),$1);`
212			`}`
213			`\| LIST {`
214			`config.map_filename = "-";`
215			`}`
216			`\| ORDER ordernamelist`
217			`\| ENDWORD`
218			`\| PUBLIC NAME '=' exp`
219			`{ mri_public($2, $4); }`
220			`\| PUBLIC NAME ',' exp`
221			`{ mri_public($2, $4); }`
222			`\| PUBLIC NAME exp`
223			`{ mri_public($2, $3); }`
224			`\| FORMAT NAME`
225			`{ mri_format($2); }`
226			`\| SECT NAME ',' exp`
227			`{ mri_output_section($2, $4);}`
228			`\| SECT NAME exp`
229			`{ mri_output_section($2, $3);}`
230			`\| SECT NAME '=' exp`
231			`{ mri_output_section($2, $4);}`
232			`\| ALIGN_K NAME '=' exp`
233			`{ mri_align($2,$4); }`
234			`\| ALIGN_K NAME ',' exp`
235			`{ mri_align($2,$4); }`
236			`\| ALIGNMOD NAME '=' exp`
237			`{ mri_alignmod($2,$4); }`
238			`\| ALIGNMOD NAME ',' exp`
239			`{ mri_alignmod($2,$4); }`
240			`\| ABSOLUTE mri_abs_name_list`
241			`\| LOAD mri_load_name_list`
242			`\| NAMEWORD NAME`
243			`{ mri_name($2); }`
244			`\| ALIAS NAME ',' NAME`
245			`{ mri_alias($2,$4,0);}`
246			`\| ALIAS NAME ',' INT`
247			`{ mri_alias ($2, 0, (int) $4.integer); }`
248			`\| BASE exp`
249			`{ mri_base($2); }`
250			`\| TRUNCATE INT`
251			`{ mri_truncate ((unsigned int) $2.integer); }`
252			`\| CASE casesymlist`
253			`\| EXTERN extern_name_list`
254			`\| INCLUDE filename`
255			`{ ldlex_script (); ldfile_open_command_file($2); }`
256			`mri_script_lines END`
257			`{ ldlex_popstate (); }`
258			`\| START NAME`
259			`{ lang_add_entry ($2, FALSE); }`
260			`\|`
261			`;`
262
263			`ordernamelist:`
264			`ordernamelist ',' NAME { mri_order($3); }`
265			`\| ordernamelist NAME { mri_order($2); }`
266			`\|`
267			`;`
268
269			`mri_load_name_list:`
270			`NAME`
271			`{ mri_load($1); }`
272			`\| mri_load_name_list ',' NAME { mri_load($3); }`
273			`;`
274
275			`mri_abs_name_list:`
276			`NAME`
277			`{ mri_only_load($1); }`
278			`\| mri_abs_name_list ',' NAME`
279			`{ mri_only_load($3); }`
280			`;`
281
282			`casesymlist:`
283			`/* empty */ { $$ = NULL; }`
284			`\| NAME`
285			`\| casesymlist ',' NAME`
286			`;`
287
288			`/* Parsed as expressions so that commas separate entries */`
289			`extern_name_list:`
290			`{ ldlex_expression (); }`
291			`extern_name_list_body`
292			`{ ldlex_popstate (); }`
293
294			`extern_name_list_body:`
295			`NAME`
296			`{ ldlang_add_undef ($1, FALSE); }`
297			`\| extern_name_list_body NAME`
298			`{ ldlang_add_undef ($2, FALSE); }`
299			`\| extern_name_list_body ',' NAME`
300			`{ ldlang_add_undef ($3, FALSE); }`
301			`;`
302
303			`script_file:`
304			`{ ldlex_both(); }`
305			`ifile_list`
306			`{ ldlex_popstate(); }`
307			`;`
308
309			`ifile_list:`
310			`ifile_list ifile_p1`
311			`\|`
312			`;`
313
314
315			`ifile_p1:`
316			`memory`
317			`\| sections`
318			`\| phdrs`
319			`\| startup`
320			`\| high_level_library`
321			`\| low_level_library`
322			`\| floating_point_support`
323			`\| statement_anywhere`
324			`\| version`
325			`\| ';'`
326			`\| TARGET_K '(' NAME ')'`
327			`{ lang_add_target($3); }`
328			`\| SEARCH_DIR '(' filename ')'`
329			`{ ldfile_add_library_path ($3, FALSE); }`
330			`\| OUTPUT '(' filename ')'`
331			`{ lang_add_output($3, 1); }`
332			`\| OUTPUT_FORMAT '(' NAME ')'`
333			`{ lang_add_output_format ($3, (char *) NULL,`
334			`(char *) NULL, 1); }`
335			`\| OUTPUT_FORMAT '(' NAME ',' NAME ',' NAME ')'`
336			`{ lang_add_output_format ($3, $5, $7, 1); }`
337			`\| OUTPUT_ARCH '(' NAME ')'`
338			`{ ldfile_set_output_arch ($3, bfd_arch_unknown); }`
339			`\| FORCE_COMMON_ALLOCATION`
340			`{ command_line.force_common_definition = TRUE ; }`
341			`\| INHIBIT_COMMON_ALLOCATION`
342			`{ command_line.inhibit_common_definition = TRUE ; }`
343			`\| INPUT '(' input_list ')'`
344			`\| GROUP`
345			`{ lang_enter_group (); }`
346			`'(' input_list ')'`
347			`{ lang_leave_group (); }`
348			`\| MAP '(' filename ')'`
349			`{ lang_add_map($3); }`
350			`\| INCLUDE filename`
351			`{ ldlex_script (); ldfile_open_command_file($2); }`
352			`ifile_list END`
353			`{ ldlex_popstate (); }`
354			`\| NOCROSSREFS '(' nocrossref_list ')'`
355			`{`
356			`lang_add_nocrossref ($3);`
357			`}`
358			`\| EXTERN '(' extern_name_list ')'`
359			`\| INSERT_K AFTER NAME`
360			`{ lang_add_insert ($3, 0); }`
361			`\| INSERT_K BEFORE NAME`
362			`{ lang_add_insert ($3, 1); }`
363			`\| REGION_ALIAS '(' NAME ',' NAME ')'`
364			`{ lang_memory_region_alias ($3, $5); }`
365			`\| LD_FEATURE '(' NAME ')'`
366			`{ lang_ld_feature ($3); }`
367			`;`
368
369			`input_list:`
370			`NAME`
371			`{ lang_add_input_file($1,lang_input_file_is_search_file_enum,`
372			`(char *)NULL); }`
373			`\| input_list ',' NAME`
374			`{ lang_add_input_file($3,lang_input_file_is_search_file_enum,`
375			`(char *)NULL); }`
376			`\| input_list NAME`
377			`{ lang_add_input_file($2,lang_input_file_is_search_file_enum,`
378			`(char *)NULL); }`
379			`\| LNAME`
380			`{ lang_add_input_file($1,lang_input_file_is_l_enum,`
381			`(char *)NULL); }`
382			`\| input_list ',' LNAME`
383			`{ lang_add_input_file($3,lang_input_file_is_l_enum,`
384			`(char *)NULL); }`
385			`\| input_list LNAME`
386			`{ lang_add_input_file($2,lang_input_file_is_l_enum,`
387			`(char *)NULL); }`
388			`\| AS_NEEDED '('`
389			`{ $$ = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; }`
390			`input_list ')'`
391			`{ add_DT_NEEDED_for_regular = $3; }`
392			`\| input_list ',' AS_NEEDED '('`
393			`{ $$ = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; }`
394			`input_list ')'`
395			`{ add_DT_NEEDED_for_regular = $5; }`
396			`\| input_list AS_NEEDED '('`
397			`{ $$ = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; }`
398			`input_list ')'`
399			`{ add_DT_NEEDED_for_regular = $4; }`
400			`;`
401
402			`sections:`
403			`SECTIONS '{' sec_or_group_p1 '}'`
404			`;`
405
406			`sec_or_group_p1:`
407			`sec_or_group_p1 section`
408			`\| sec_or_group_p1 statement_anywhere`
409			`\|`
410			`;`
411
412			`statement_anywhere:`
413			`ENTRY '(' NAME ')'`
414			`{ lang_add_entry ($3, FALSE); }`
415			`\| assignment end`
416			`\| ASSERT_K {ldlex_expression ();} '(' exp ',' NAME ')'`
417			`{ ldlex_popstate ();`
418			`lang_add_assignment (exp_assert ($4, $6)); }`
419			`;`
420
421			`/* The '*' and '?' cases are there because the lexer returns them as`
422			`separate tokens rather than as NAME. */`
423			`wildcard_name:`
424			`NAME`
425			`{`
426			`$$ = $1;`
427			`}`
428			`\| '*'`
429			`{`
430			`$$ = "*";`
431			`}`
432			`\| '?'`
433			`{`
434			`$$ = "?";`
435			`}`
436			`;`
437
438			`wildcard_spec:`
439			`wildcard_name`
440			`{`
441			`$$.name = $1;`
442			`$$.sorted = none;`
443			`$$.exclude_name_list = NULL;`
444	157	khays	`$$.section_flag_list = NULL;`
445	145	khays	`}`
446			`\| EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name`
447			`{`
448			`$$.name = $5;`
449			`$$.sorted = none;`
450			`$$.exclude_name_list = $3;`
451	157	khays	`$$.section_flag_list = NULL;`
452	145	khays	`}`
453			`\| SORT_BY_NAME '(' wildcard_name ')'`
454			`{`
455			`$$.name = $3;`
456			`$$.sorted = by_name;`
457			`$$.exclude_name_list = NULL;`
458	157	khays	`$$.section_flag_list = NULL;`
459	145	khays	`}`
460			`\| SORT_BY_ALIGNMENT '(' wildcard_name ')'`
461			`{`
462			`$$.name = $3;`
463			`$$.sorted = by_alignment;`
464			`$$.exclude_name_list = NULL;`
465	157	khays	`$$.section_flag_list = NULL;`
466	145	khays	`}`
467			`\| SORT_BY_NAME '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'`
468			`{`
469			`$$.name = $5;`
470			`$$.sorted = by_name_alignment;`
471			`$$.exclude_name_list = NULL;`
472	157	khays	`$$.section_flag_list = NULL;`
473	145	khays	`}`
474			`\| SORT_BY_NAME '(' SORT_BY_NAME '(' wildcard_name ')' ')'`
475			`{`
476			`$$.name = $5;`
477			`$$.sorted = by_name;`
478			`$$.exclude_name_list = NULL;`
479	157	khays	`$$.section_flag_list = NULL;`
480	145	khays	`}`
481			`\| SORT_BY_ALIGNMENT '(' SORT_BY_NAME '(' wildcard_name ')' ')'`
482			`{`
483			`$$.name = $5;`
484			`$$.sorted = by_alignment_name;`
485			`$$.exclude_name_list = NULL;`
486	157	khays	`$$.section_flag_list = NULL;`
487	145	khays	`}`
488			`\| SORT_BY_ALIGNMENT '(' SORT_BY_ALIGNMENT '(' wildcard_name ')' ')'`
489			`{`
490			`$$.name = $5;`
491			`$$.sorted = by_alignment;`
492			`$$.exclude_name_list = NULL;`
493	157	khays	`$$.section_flag_list = NULL;`
494	145	khays	`}`
495			`\| SORT_BY_NAME '(' EXCLUDE_FILE '(' exclude_name_list ')' wildcard_name ')'`
496			`{`
497			`$$.name = $7;`
498			`$$.sorted = by_name;`
499			`$$.exclude_name_list = $5;`
500	157	khays	`$$.section_flag_list = NULL;`

Browse

Tools

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [ld/] [ldgram.y] - Blame information for rev 248