darling-gdb/ld/ldlex.l

684 lines
20 KiB
Plaintext
Raw Normal View History

1999-05-03 07:29:11 +00:00
%{
2002-01-21 19:53:44 +00:00
/* Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
1999-05-03 07:29:11 +00:00
This file is part of GLD, the Gnu Linker.
1999-05-03 07:29:11 +00:00
GLD 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 2, or (at your option)
any later version.
1999-05-03 07:29:11 +00:00
GLD 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.
1999-05-03 07:29:11 +00:00
You should have received a copy of the GNU General Public License
along with GLD; see the file COPYING. If not, write to the Free
2005-05-12 07:32:09 +00:00
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
02110-1301, USA. */
1999-05-03 07:29:11 +00:00
/*
This was written by steve chamberlain
sac@cygnus.com
*/
#include <stdio.h>
#include "bfd.h"
#include "sysdep.h"
#include "safe-ctype.h"
#include "bfdlink.h"
1999-05-03 07:29:11 +00:00
#include "ld.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"
#include <ldgram.h>
1999-05-03 07:29:11 +00:00
#include "ldfile.h"
#include "ldlex.h"
#include "ldmain.h"
#include "libiberty.h"
1999-05-03 07:29:11 +00:00
/* The type of top-level parser input.
yylex and yyparse (indirectly) both check this. */
input_type parser_input;
/* Line number in the current input file.
(FIXME Actually, it doesn't appear to get reset for each file?) */
unsigned int lineno = 1;
/* The string we are currently lexing, or NULL if we are reading a
file. */
const char *lex_string = NULL;
/* Support for flex reading from more than one input file (stream).
`include_stack' is flex's input state for each open file;
`file_name_stack' is the file names. `lineno_stack' is the current
line numbers.
If `include_stack_ptr' is 0, we haven't started reading anything yet.
Otherwise, stack elements 0 through `include_stack_ptr - 1' are valid. */
#undef YY_INPUT
2003-06-28 05:28:54 +00:00
#define YY_INPUT(buf,result,max_size) yy_input (buf, &result, max_size)
1999-05-03 07:29:11 +00:00
#define YY_NO_UNPUT
1999-05-03 07:29:11 +00:00
#define MAX_INCLUDE_DEPTH 10
static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
static const char *file_name_stack[MAX_INCLUDE_DEPTH];
static unsigned int lineno_stack[MAX_INCLUDE_DEPTH];
static unsigned int include_stack_ptr = 0;
static int vers_node_nesting = 0;
2003-06-28 05:28:54 +00:00
static void yy_input (char *, int *, int);
static void comment (void);
static void lex_warn_invalid (char *where, char *what);
1999-05-03 07:29:11 +00:00
2003-06-28 05:28:54 +00:00
/* STATES
1999-05-03 07:29:11 +00:00
EXPRESSION definitely in an expression
SCRIPT definitely in a script
BOTH either EXPRESSION or SCRIPT
DEFSYMEXP in an argument to -defsym
MRI in an MRI script
VERS_START starting a Sun style mapfile
VERS_SCRIPT a Sun style mapfile
VERS_NODE a node within a Sun style mapfile
*/
#define RTOKEN(x) { yylval.token = x; return x; }
/* Some versions of flex want this. */
#ifndef yywrap
2003-06-28 05:28:54 +00:00
int yywrap (void) { return 1; }
1999-05-03 07:29:11 +00:00
#endif
%}
%a 4000
%o 5000
CMDFILENAMECHAR [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-\~]
CMDFILENAMECHAR1 [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\~]
FILENAMECHAR1 [_a-zA-Z\/\.\\\$\_\~]
SYMBOLCHARN [_a-zA-Z\/\.\\\$\_\~0-9]
FILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~]
WILDCHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~\?\*]
2003-06-28 05:28:54 +00:00
WHITE [ \t\n\r]+
1999-05-03 07:29:11 +00:00
NOCFILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
V_TAG [.$_a-zA-Z][._a-zA-Z0-9]*
V_IDENTIFIER [*?.$_a-zA-Z\[\]\-\!\^\\]([*?.$_a-zA-Z0-9\[\]\-\!\^\\]|::)*
1999-05-03 07:29:11 +00:00
%s SCRIPT
%s EXPRESSION
%s BOTH
%s DEFSYMEXP
%s MRI
%s VERS_START
%s VERS_SCRIPT
%s VERS_NODE
%%
if (parser_input != input_selected)
{
/* The first token of the input determines the initial parser state. */
input_type t = parser_input;
parser_input = input_selected;
switch (t)
{
case input_script: return INPUT_SCRIPT; break;
case input_mri_script: return INPUT_MRI_SCRIPT; break;
case input_version_script: return INPUT_VERSION_SCRIPT; break;
case input_defsym: return INPUT_DEFSYM; break;
default: abort ();
}
}
2003-06-28 05:28:54 +00:00
<BOTH,SCRIPT,EXPRESSION,VERS_START,VERS_NODE,VERS_SCRIPT>"/*" { comment (); }
1999-05-03 07:29:11 +00:00
<DEFSYMEXP>"-" { RTOKEN('-');}
<DEFSYMEXP>"+" { RTOKEN('+');}
2003-06-28 05:28:54 +00:00
<DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}* { yylval.name = xstrdup (yytext); return NAME; }
1999-05-03 07:29:11 +00:00
<DEFSYMEXP>"=" { RTOKEN('='); }
<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
2003-06-28 05:28:54 +00:00
yylval.integer = bfd_scan_vma (yytext + 1, 0, 16);
yylval.bigint.str = NULL;
1999-05-03 07:29:11 +00:00
return INT;
}
<MRI,EXPRESSION>([0-9A-Fa-f])+(H|h|X|x|B|b|O|o|D|d) {
int ibase ;
2003-06-28 05:28:54 +00:00
switch (yytext[yyleng - 1]) {
case 'X':
1999-05-03 07:29:11 +00:00
case 'x':
case 'H':
case 'h':
ibase = 16;
break;
case 'O':
case 'o':
ibase = 8;
break;
case 'B':
case 'b':
ibase = 2;
break;
default:
ibase = 10;
}
yylval.integer = bfd_scan_vma (yytext, 0,
ibase);
2003-06-28 05:28:54 +00:00
yylval.bigint.str = NULL;
1999-05-03 07:29:11 +00:00
return INT;
}
Support arbitrary length fill patterns. * ldexp.h (etree_value_type): Add "str" field. (union etree_union): Add "str" to "value" struct. (exp_bigintop): Declare. (exp_get_fill): Declare. * ldexp.c: Include "safe-ctype.h". (exp_intop): Set value.str to NULL. (exp_bigintop): New function. (new_rel): Pass in "str", and set new.str from it. (new_rel_from_section): Set new.str to NULL. (fold_name): Adjust calls to new_rel. (exp_fold_tree): Likewise. (exp_get_fill): New function. * ldgram.y (struct big_int bigint, fill_type *fill): New. (INT): Returns a "bigint". Adjust all code handling INTs. (fill_opt): Returns a "fill". (fill_exp): Split out of fill_opt, use for FILL. * ldlang.h (struct _fill_type): New. (fill_type): Move typedef to ldexp.h. (lang_output_section_statement_type): "fill" is now a pointer. (lang_fill_statement_type): Likewise. (lang_padding_statement_type): Likewise. (lang_add_fill): Now takes a "fill_type *" param. (lang_leave_output_section_statement): Likewise. (lang_do_assignments): Likewise. (lang_size_sections): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. * ldlang.c: Include ldgram.h after ldexp.h. (lang_output_section_statement_lookup): Adjust for fill_type change. (print_fill_statement): Likewise. (print_padding_statement): Likewise. (insert_pad): Now takes a "fill_type *" arg. (size_input_section): Likewise. (lang_size_sections_1): Likewise. (lang_size_sections): Likewise. (lang_do_assignments): Likewise. (lang_add_fill): Likewise. (lang_leave_output_section_statement): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. Adjust all callers of the above function. * ldlex.l: Include ldgram.h after ldexp.h. Allow hex numbers starting with "0X" as well as "0x". Return bigint.str for hex numbers starting with "0x" or "0X", zero bigint.str otherwise. Always use base 16 for numbers starting with "$". * ldmain.c: Include ldgram.h after ldexp.h. * ldwrite.c (build_link_order): Use bfd_data_link_order in place of bfd_fill_link_order. * pe-dll.c: Adjust lang_do_assignments calls. * emultempl/elf32.em: Likewise. * emultempl/hppaelf.em: Likewise. * emultempl/ppc64elf.em: Likewise. * emultempl/beos.em: Include ldgram.h after ldexp.h, adjust lang_add_assignment call. * emultempl/pe.em: Likewise.
2002-02-15 02:11:05 +00:00
<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>((("$"|0[xX])([0-9A-Fa-f])+)|(([0-9])+))(M|K|m|k)? {
1999-05-03 07:29:11 +00:00
char *s = yytext;
Support arbitrary length fill patterns. * ldexp.h (etree_value_type): Add "str" field. (union etree_union): Add "str" to "value" struct. (exp_bigintop): Declare. (exp_get_fill): Declare. * ldexp.c: Include "safe-ctype.h". (exp_intop): Set value.str to NULL. (exp_bigintop): New function. (new_rel): Pass in "str", and set new.str from it. (new_rel_from_section): Set new.str to NULL. (fold_name): Adjust calls to new_rel. (exp_fold_tree): Likewise. (exp_get_fill): New function. * ldgram.y (struct big_int bigint, fill_type *fill): New. (INT): Returns a "bigint". Adjust all code handling INTs. (fill_opt): Returns a "fill". (fill_exp): Split out of fill_opt, use for FILL. * ldlang.h (struct _fill_type): New. (fill_type): Move typedef to ldexp.h. (lang_output_section_statement_type): "fill" is now a pointer. (lang_fill_statement_type): Likewise. (lang_padding_statement_type): Likewise. (lang_add_fill): Now takes a "fill_type *" param. (lang_leave_output_section_statement): Likewise. (lang_do_assignments): Likewise. (lang_size_sections): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. * ldlang.c: Include ldgram.h after ldexp.h. (lang_output_section_statement_lookup): Adjust for fill_type change. (print_fill_statement): Likewise. (print_padding_statement): Likewise. (insert_pad): Now takes a "fill_type *" arg. (size_input_section): Likewise. (lang_size_sections_1): Likewise. (lang_size_sections): Likewise. (lang_do_assignments): Likewise. (lang_add_fill): Likewise. (lang_leave_output_section_statement): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. Adjust all callers of the above function. * ldlex.l: Include ldgram.h after ldexp.h. Allow hex numbers starting with "0X" as well as "0x". Return bigint.str for hex numbers starting with "0x" or "0X", zero bigint.str otherwise. Always use base 16 for numbers starting with "$". * ldmain.c: Include ldgram.h after ldexp.h. * ldwrite.c (build_link_order): Use bfd_data_link_order in place of bfd_fill_link_order. * pe-dll.c: Adjust lang_do_assignments calls. * emultempl/elf32.em: Likewise. * emultempl/hppaelf.em: Likewise. * emultempl/ppc64elf.em: Likewise. * emultempl/beos.em: Include ldgram.h after ldexp.h, adjust lang_add_assignment call. * emultempl/pe.em: Likewise.
2002-02-15 02:11:05 +00:00
int ibase = 0;
1999-05-03 07:29:11 +00:00
if (*s == '$')
Support arbitrary length fill patterns. * ldexp.h (etree_value_type): Add "str" field. (union etree_union): Add "str" to "value" struct. (exp_bigintop): Declare. (exp_get_fill): Declare. * ldexp.c: Include "safe-ctype.h". (exp_intop): Set value.str to NULL. (exp_bigintop): New function. (new_rel): Pass in "str", and set new.str from it. (new_rel_from_section): Set new.str to NULL. (fold_name): Adjust calls to new_rel. (exp_fold_tree): Likewise. (exp_get_fill): New function. * ldgram.y (struct big_int bigint, fill_type *fill): New. (INT): Returns a "bigint". Adjust all code handling INTs. (fill_opt): Returns a "fill". (fill_exp): Split out of fill_opt, use for FILL. * ldlang.h (struct _fill_type): New. (fill_type): Move typedef to ldexp.h. (lang_output_section_statement_type): "fill" is now a pointer. (lang_fill_statement_type): Likewise. (lang_padding_statement_type): Likewise. (lang_add_fill): Now takes a "fill_type *" param. (lang_leave_output_section_statement): Likewise. (lang_do_assignments): Likewise. (lang_size_sections): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. * ldlang.c: Include ldgram.h after ldexp.h. (lang_output_section_statement_lookup): Adjust for fill_type change. (print_fill_statement): Likewise. (print_padding_statement): Likewise. (insert_pad): Now takes a "fill_type *" arg. (size_input_section): Likewise. (lang_size_sections_1): Likewise. (lang_size_sections): Likewise. (lang_do_assignments): Likewise. (lang_add_fill): Likewise. (lang_leave_output_section_statement): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. Adjust all callers of the above function. * ldlex.l: Include ldgram.h after ldexp.h. Allow hex numbers starting with "0X" as well as "0x". Return bigint.str for hex numbers starting with "0x" or "0X", zero bigint.str otherwise. Always use base 16 for numbers starting with "$". * ldmain.c: Include ldgram.h after ldexp.h. * ldwrite.c (build_link_order): Use bfd_data_link_order in place of bfd_fill_link_order. * pe-dll.c: Adjust lang_do_assignments calls. * emultempl/elf32.em: Likewise. * emultempl/hppaelf.em: Likewise. * emultempl/ppc64elf.em: Likewise. * emultempl/beos.em: Include ldgram.h after ldexp.h, adjust lang_add_assignment call. * emultempl/pe.em: Likewise.
2002-02-15 02:11:05 +00:00
{
++s;
ibase = 16;
}
yylval.integer = bfd_scan_vma (s, 0, ibase);
2003-06-28 05:28:54 +00:00
yylval.bigint.str = NULL;
if (yytext[yyleng - 1] == 'M'
|| yytext[yyleng - 1] == 'm')
Support arbitrary length fill patterns. * ldexp.h (etree_value_type): Add "str" field. (union etree_union): Add "str" to "value" struct. (exp_bigintop): Declare. (exp_get_fill): Declare. * ldexp.c: Include "safe-ctype.h". (exp_intop): Set value.str to NULL. (exp_bigintop): New function. (new_rel): Pass in "str", and set new.str from it. (new_rel_from_section): Set new.str to NULL. (fold_name): Adjust calls to new_rel. (exp_fold_tree): Likewise. (exp_get_fill): New function. * ldgram.y (struct big_int bigint, fill_type *fill): New. (INT): Returns a "bigint". Adjust all code handling INTs. (fill_opt): Returns a "fill". (fill_exp): Split out of fill_opt, use for FILL. * ldlang.h (struct _fill_type): New. (fill_type): Move typedef to ldexp.h. (lang_output_section_statement_type): "fill" is now a pointer. (lang_fill_statement_type): Likewise. (lang_padding_statement_type): Likewise. (lang_add_fill): Now takes a "fill_type *" param. (lang_leave_output_section_statement): Likewise. (lang_do_assignments): Likewise. (lang_size_sections): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. * ldlang.c: Include ldgram.h after ldexp.h. (lang_output_section_statement_lookup): Adjust for fill_type change. (print_fill_statement): Likewise. (print_padding_statement): Likewise. (insert_pad): Now takes a "fill_type *" arg. (size_input_section): Likewise. (lang_size_sections_1): Likewise. (lang_size_sections): Likewise. (lang_do_assignments): Likewise. (lang_add_fill): Likewise. (lang_leave_output_section_statement): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. Adjust all callers of the above function. * ldlex.l: Include ldgram.h after ldexp.h. Allow hex numbers starting with "0X" as well as "0x". Return bigint.str for hex numbers starting with "0x" or "0X", zero bigint.str otherwise. Always use base 16 for numbers starting with "$". * ldmain.c: Include ldgram.h after ldexp.h. * ldwrite.c (build_link_order): Use bfd_data_link_order in place of bfd_fill_link_order. * pe-dll.c: Adjust lang_do_assignments calls. * emultempl/elf32.em: Likewise. * emultempl/hppaelf.em: Likewise. * emultempl/ppc64elf.em: Likewise. * emultempl/beos.em: Include ldgram.h after ldexp.h, adjust lang_add_assignment call. * emultempl/pe.em: Likewise.
2002-02-15 02:11:05 +00:00
{
yylval.integer *= 1024 * 1024;
}
2003-06-28 05:28:54 +00:00
else if (yytext[yyleng - 1] == 'K'
|| yytext[yyleng - 1]=='k')
Support arbitrary length fill patterns. * ldexp.h (etree_value_type): Add "str" field. (union etree_union): Add "str" to "value" struct. (exp_bigintop): Declare. (exp_get_fill): Declare. * ldexp.c: Include "safe-ctype.h". (exp_intop): Set value.str to NULL. (exp_bigintop): New function. (new_rel): Pass in "str", and set new.str from it. (new_rel_from_section): Set new.str to NULL. (fold_name): Adjust calls to new_rel. (exp_fold_tree): Likewise. (exp_get_fill): New function. * ldgram.y (struct big_int bigint, fill_type *fill): New. (INT): Returns a "bigint". Adjust all code handling INTs. (fill_opt): Returns a "fill". (fill_exp): Split out of fill_opt, use for FILL. * ldlang.h (struct _fill_type): New. (fill_type): Move typedef to ldexp.h. (lang_output_section_statement_type): "fill" is now a pointer. (lang_fill_statement_type): Likewise. (lang_padding_statement_type): Likewise. (lang_add_fill): Now takes a "fill_type *" param. (lang_leave_output_section_statement): Likewise. (lang_do_assignments): Likewise. (lang_size_sections): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. * ldlang.c: Include ldgram.h after ldexp.h. (lang_output_section_statement_lookup): Adjust for fill_type change. (print_fill_statement): Likewise. (print_padding_statement): Likewise. (insert_pad): Now takes a "fill_type *" arg. (size_input_section): Likewise. (lang_size_sections_1): Likewise. (lang_size_sections): Likewise. (lang_do_assignments): Likewise. (lang_add_fill): Likewise. (lang_leave_output_section_statement): Likewise. (lang_leave_overlay_section): Likewise. (lang_leave_overlay): Likewise. Adjust all callers of the above function. * ldlex.l: Include ldgram.h after ldexp.h. Allow hex numbers starting with "0X" as well as "0x". Return bigint.str for hex numbers starting with "0x" or "0X", zero bigint.str otherwise. Always use base 16 for numbers starting with "$". * ldmain.c: Include ldgram.h after ldexp.h. * ldwrite.c (build_link_order): Use bfd_data_link_order in place of bfd_fill_link_order. * pe-dll.c: Adjust lang_do_assignments calls. * emultempl/elf32.em: Likewise. * emultempl/hppaelf.em: Likewise. * emultempl/ppc64elf.em: Likewise. * emultempl/beos.em: Include ldgram.h after ldexp.h, adjust lang_add_assignment call. * emultempl/pe.em: Likewise.
2002-02-15 02:11:05 +00:00
{
yylval.integer *= 1024;
}
else if (yytext[0] == '0'
&& (yytext[1] == 'x'
|| yytext[1] == 'X'))
{
yylval.bigint.str = xstrdup (yytext + 2);
}
1999-05-03 07:29:11 +00:00
return INT;
}
<BOTH,SCRIPT,EXPRESSION,MRI>"]" { RTOKEN(']');}
<BOTH,SCRIPT,EXPRESSION,MRI>"[" { RTOKEN('[');}
<BOTH,SCRIPT,EXPRESSION,MRI>"<<=" { RTOKEN(LSHIFTEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>">>=" { RTOKEN(RSHIFTEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"||" { RTOKEN(OROR);}
<BOTH,SCRIPT,EXPRESSION,MRI>"==" { RTOKEN(EQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"!=" { RTOKEN(NE);}
<BOTH,SCRIPT,EXPRESSION,MRI>">=" { RTOKEN(GE);}
<BOTH,SCRIPT,EXPRESSION,MRI>"<=" { RTOKEN(LE);}
<BOTH,SCRIPT,EXPRESSION,MRI>"<<" { RTOKEN(LSHIFT);}
<BOTH,SCRIPT,EXPRESSION,MRI>">>" { RTOKEN(RSHIFT);}
<BOTH,SCRIPT,EXPRESSION,MRI>"+=" { RTOKEN(PLUSEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"-=" { RTOKEN(MINUSEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"*=" { RTOKEN(MULTEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"/=" { RTOKEN(DIVEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"&=" { RTOKEN(ANDEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"|=" { RTOKEN(OREQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"&&" { RTOKEN(ANDAND);}
<BOTH,SCRIPT,EXPRESSION,MRI>">" { RTOKEN('>');}
<BOTH,SCRIPT,EXPRESSION,MRI>"," { RTOKEN(',');}
<BOTH,SCRIPT,EXPRESSION,MRI>"&" { RTOKEN('&');}
<BOTH,SCRIPT,EXPRESSION,MRI>"|" { RTOKEN('|');}
<BOTH,SCRIPT,EXPRESSION,MRI>"~" { RTOKEN('~');}
<BOTH,SCRIPT,EXPRESSION,MRI>"!" { RTOKEN('!');}
<BOTH,SCRIPT,EXPRESSION,MRI>"?" { RTOKEN('?');}
<BOTH,SCRIPT,EXPRESSION,MRI>"*" { RTOKEN('*');}
<BOTH,SCRIPT,EXPRESSION,MRI>"+" { RTOKEN('+');}
<BOTH,SCRIPT,EXPRESSION,MRI>"-" { RTOKEN('-');}
<BOTH,SCRIPT,EXPRESSION,MRI>"/" { RTOKEN('/');}
<BOTH,SCRIPT,EXPRESSION,MRI>"%" { RTOKEN('%');}
<BOTH,SCRIPT,EXPRESSION,MRI>"<" { RTOKEN('<');}
<BOTH,SCRIPT,EXPRESSION,MRI>"=" { RTOKEN('=');}
<BOTH,SCRIPT,EXPRESSION,MRI>"}" { RTOKEN('}') ; }
<BOTH,SCRIPT,EXPRESSION,MRI>"{" { RTOKEN('{'); }
<BOTH,SCRIPT,EXPRESSION,MRI>")" { RTOKEN(')');}
<BOTH,SCRIPT,EXPRESSION,MRI>"(" { RTOKEN('(');}
1999-05-03 07:29:11 +00:00
<BOTH,SCRIPT,EXPRESSION,MRI>":" { RTOKEN(':'); }
<BOTH,SCRIPT,EXPRESSION,MRI>";" { RTOKEN(';');}
<BOTH,SCRIPT>"MEMORY" { RTOKEN(MEMORY);}
<BOTH,SCRIPT,EXPRESSION>"ORIGIN" { RTOKEN(ORIGIN);}
<BOTH,SCRIPT>"VERSION" { RTOKEN(VERSIONK);}
1999-05-03 07:29:11 +00:00
<EXPRESSION,BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
<EXPRESSION,BOTH,SCRIPT>"BIND" { RTOKEN(BIND);}
<BOTH,SCRIPT,EXPRESSION>"LENGTH" { RTOKEN(LENGTH);}
<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_ALIGN" { RTOKEN(DATA_SEGMENT_ALIGN);}
bfd/ * elflink.c (elf_bfd_final_link): Don't output STT_SECTION symbol into .dynsym if elf_section_data (sec)->dynindx <= 0. Adjust counting of last_local. (_bfd_elf_link_renumber_dynsyms): Don't assign dynindx to sections other than SHT_PROGBITS/SHT_NOBITS and neither for .got/.got.plt/.plt created by the linker nor !SHF_ALLOC. * elf32-i386.c (elf_i386_finish_dynamic_sections): Point DT_PLTGOT to the start of the .got.plt section instead of the .got output section. Set sh_entsize for .got section in addition to .got.plt. (elf_i386_relocate_section): Don't assume _GLOBAL_OFFSET_TABLE_ is at sgot->output_section->vma. * elf64-x86-64.c (elf64_x86_64_finish_dynamic_sections): Point DT_PLTGOT to the start of the .got.plt section instead of the .got output section. (elf64_x86_64_relocate_section): Don't assume _GLOBAL_OFFSET_TABLE_ is at sgot->output_section->vma. Set sh_entsize for .got section in addition to .got.plt. * elf.c (_bfd_elf_print_private_bfd_data): Handle PT_GNU_RELRO. (bfd_section_from_phdr): Likewise. (map_sections_to_segments): Likewise. (assign_file_positions_for_segments): Likewise. (get_program_header_size): Likewise. * elflink.c (bfd_elf_size_dynamic_sections): Set elf_tdata (output_bfd)->relro from info->relro. * elf-bfd.h (struct elf_obj_tdata): Add relro field. include/ * bfdlink.h (struct bfd_link_info): Add relro, relro_start and relro_end fields. * elf/common.h (PT_GNU_EH_FRAME, PT_GNU_STACK): Add comments. (PT_GNU_RELRO): Define. binutils/ * readelf.c (get_segment_type): Handle PT_GNU_RELRO. ld/ * genscripts.sh: Generate -z combreloc -z now -z relro scripts for binaries, -shared and -pie. * emulparams/elf_i386.sh (SEPARATE_GOTPLT): Set. * emulparams/elf_x86_64.sh (SEPARATE_GOTPLT): Set. * emulparams/elf32ppc.sh (OTHER_READWRITE_SECTIONS): Rename to... (OTHER_RELRO_SECTIONS): ... this. * ldlex.l (DATA_SEGMENT_RELRO_END): Add. * emultempl/elf32.em (gld${EMULATION_NAME}_handle_option): Handle -z relro and -z norelro. (gld${EMULATION_NAME}_list_options): Add it to usage. (gld${EMULATION_NAME}_get_script): Return -z combreloc -z now -z relro scripts when appropriate. * scripttempl/elf.sc: Unset SEPARATE_GOTPLT if RELRO_NOW is set. Create separate .got.plt section if SEPARATE_GOTPLT. Move sections which are only written during relocation handling to the beginning of RW segment. If NO_SMALL_DATA, move .got before .data. Add DATA_SEGMENT_RELRO_END directive. Include OTHER_RELRO_SECTIONS. * ldgram.y (DATA_SEGMENT_RELRO_END): Add. * ldexp.c (exp_print_token): Handle DATA_SEGMENT_RELRO_END. (fold_unary): Likewise. (fold_binary): Handle -z relro. * ldexp.h (struct exp_data_seg): Add exp_dataseg_relro_seen and exp_dataseg_relro_adjust phases. Add relro_end field. * ldmain.c (main): Initialize link_info.relro to FALSE. * ldlang.c (lang_size_sections): Handle -z relro. ld/testsuite/ * ld-i386/tlspic.rd: Adjust for section reordering changes and removal of unneeded STT_SECTION symbols from .dynsym. * ld-i386/tlspic.dd: Likewise. * ld-i386/tlspic.sd: Likewise. * ld-i386/tlsbin.rd: Likewise. * ld-i386/tlsbinpic.s: Likewise. * ld-i386/tlsbin.dd: Likewise. * ld-i386/tlsbin.sd: Likewise. * ld-i386/tlsnopic.rd: Likewise. * ld-i386/tlsnopic1.s: Likewise. * ld-i386/combreloc.d: Likewise. * ld-i386/tlsnopic.dd: Likewise. * ld-i386/tlsnopic.sd: Likewise. * ld-x86-64/tlspic.rd: Likewise. * ld-x86-64/tlspic.dd: Likewise. * ld-x86-64/tlsbin.dd: Likewise. * ld-x86-64/tlspic.sd: Likewise. * ld-x86-64/tlsbin.sd: Likewise. * ld-x86-64/tlspic.td: Likewise. * ld-x86-64/tlsbin.td: Likewise. * ld-x86-64/tlsbin.rd: Likewise. * ld-s390/tlspic1.s: Likewise. * ld-s390/tlsbinpic.s: Likewise. * ld-s390/tlspic.rd: Likewise. * ld-s390/tlsbin.rd: Likewise. * ld-s390/tlspic.dd: Likewise. * ld-s390/tlsbin.dd: Likewise. * ld-s390/tlsbin.sd: Likewise. * ld-s390/tlsbin.td: Likewise. * ld-s390/tlspic.sd: Likewise. * ld-s390/tlspic.td: Likewise. * ld-s390/tlspic1_64.s: Likewise. * ld-s390/tlsbinpic_64.s: Likewise. * ld-s390/tlspic_64.rd: Likewise. * ld-s390/tlsbin_64.rd: Likewise. * ld-s390/tlspic_64.dd: Likewise. * ld-s390/tlsbin_64.dd: Likewise. * ld-s390/tlspic_64.sd: Likewise. * ld-s390/tlspic_64.td: Likewise. * ld-s390/tlsbin_64.td: Likewise. * ld-s390/tlsbin_64.sd: Likewise. * ld-powerpc/tlsexe32.r: Likewise. * ld-powerpc/tlsso32.r: Likewise. * ld-powerpc/tlsso32.d: Likewise. * ld-powerpc/tlsso32.g: Likewise. * ld-powerpc/tlsso32.t: Likewise. * ld-powerpc/tlsexe.r: Likewise. * ld-powerpc/tlsso.r: Likewise. * ld-powerpc/tlsso.g: Likewise. * ld-powerpc/tlsexetoc.r: Likewise. * ld-powerpc/tlstocso.r: Likewise. * ld-powerpc/tlstocso.g: Likewise. * ld-ia64/tlspic.rd: Likewise. * ld-ia64/tlspic.dd: Likewise. * ld-ia64/tlspic.sd: Likewise. * ld-ia64/tlspic.td: Likewise. * ld-ia64/tlsbin.rd: Likewise. * ld-ia64/tlsbin.sd: Likewise. * ld-ia64/tlsbin.td: Likewise. * ld-elfvsb/elfvsb.exp: XFAIL non-PIC load offset tests on s390x. * ld-shared/shared.exp: Likewise.
2004-05-11 17:08:38 +00:00
<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_RELRO_END" { RTOKEN(DATA_SEGMENT_RELRO_END);}
<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_END" { RTOKEN(DATA_SEGMENT_END);}
<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
<EXPRESSION,BOTH,SCRIPT>"LOADADDR" { RTOKEN(LOADADDR);}
1999-05-03 07:29:11 +00:00
<EXPRESSION,BOTH>"MAX" { RTOKEN(MAX_K); }
<EXPRESSION,BOTH>"MIN" { RTOKEN(MIN_K); }
<EXPRESSION,BOTH>"ASSERT" { RTOKEN(ASSERT_K); }
<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
<BOTH,SCRIPT,MRI>"EXTERN" { RTOKEN(EXTERN);}
<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
1999-05-03 07:29:11 +00:00
<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
<EXPRESSION,BOTH,SCRIPT>"SEGMENT_START" { RTOKEN(SEGMENT_START);}
1999-05-03 07:29:11 +00:00
<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
1999-05-03 07:29:11 +00:00
<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
1999-05-03 07:29:11 +00:00
<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
<EXPRESSION,BOTH,SCRIPT>"GROUP" { RTOKEN(GROUP);}
<EXPRESSION,BOTH,SCRIPT>"AS_NEEDED" { RTOKEN(AS_NEEDED);}
<EXPRESSION,BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
1999-05-03 07:29:11 +00:00
<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
<BOTH,SCRIPT>"INHIBIT_COMMON_ALLOCATION" { RTOKEN(INHIBIT_COMMON_ALLOCATION);}
<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
1999-05-03 07:29:11 +00:00
<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
1999-05-03 07:29:11 +00:00
<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
1999-05-03 07:29:11 +00:00
<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
<BOTH,SCRIPT>"QUAD" { RTOKEN( QUAD);}
<BOTH,SCRIPT>"SQUAD" { RTOKEN( SQUAD);}
<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
1999-05-03 07:29:11 +00:00
<EXPRESSION,BOTH,SCRIPT>"NOCROSSREFS" { RTOKEN(NOCROSSREFS);}
<BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY); }
ld/ 2004-10-04 H.J. Lu <hongjiu.lu@intel.com> * NEWS: Mention SORT_BY_NAME, SORT_BY_ALIGNMENT and --sort-section name|alignment. * ld.texinfo: Document SORT_BY_NAME, SORT_BY_ALIGNMENT and --sort-section name|alignment. * ld.h (sort_type): New enum. (wildcard_spec): Change the type of `sorted' to sort_type. * ldgram.y (SORT): Removed. (SORT_BY_NAME): Added. (SORT_BY_ALIGNMENT): Added. (wildcard_spec): Updated `sorted'. Handle SORT_BY_NAME and SORT_BY_ALIGNMENT. (input_section_spec_no_keep): Updated `sorted'. (statement): Replace SORT with SORT_BY_NAME. * ldlang.c (compare_section): New function to compare 2 sections with different sorting schemes. (wild_sort): Updated. Use compare_section. (update_wild_statements): New function. (lang_process): Call update_wild_statements before map_input_to_output_sections. * ldlex.l (SORT_BY_NAME): New. (SORT_BY_ALIGNMENT): New. (SORT): Return SORT_BY_NAME. * ldmain.c (sort_section): New. Defined. (main): Initialize it to none. * lexsup.c (option_values): Add OPTION_SORT_SECTION. (ld_options): Add an entry for OPTION_SORT_SECTION. (parse_args): Handle OPTION_SORT_SECTION. * mri.c (mri_draw_tree): Updated `sorted'. ld/testsuite/ 2004-10-04 H.J. Lu <hongjiu.lu@intel.com> * ld-scripts/sort.exp: New file for section sorting tests. * ld-scripts/sort_b_a.d: Likewise * ld-scripts/sort_b_a.s: Likewise * ld-scripts/sort_b_a.t: Likewise * ld-scripts/sort_b_a_a-1.d: Likewise * ld-scripts/sort_b_a_a-2.d: Likewise * ld-scripts/sort_b_a_a-3.d: Likewise * ld-scripts/sort_b_a_a.t: Likewise * ld-scripts/sort_b_a_n-1.d: Likewise * ld-scripts/sort_b_a_n-2.d: Likewise * ld-scripts/sort_b_a_n-3.d: Likewise * ld-scripts/sort_b_a_n.t: Likewise * ld-scripts/sort_b_n.d: Likewise * ld-scripts/sort_b_n.s: Likewise * ld-scripts/sort_b_n.t: Likewise * ld-scripts/sort_b_n_a-1.d: Likewise * ld-scripts/sort_b_n_a-2.d: Likewise * ld-scripts/sort_b_n_a-3.d: Likewise * ld-scripts/sort_b_n_a.t: Likewise * ld-scripts/sort_b_n_n-1.d: Likewise * ld-scripts/sort_b_n_n-2.d: Likewise * ld-scripts/sort_b_n_n-3.d: Likewise * ld-scripts/sort_b_n_n.t: Likewise * ld-scripts/sort_n_a-a.s: Likewise * ld-scripts/sort_n_a-b.s: Likewise * ld-scripts/sort_no-1.d: Likewise * ld-scripts/sort_no-2.d: Likewise * ld-scripts/sort_no.t: Likewise
2004-10-04 16:45:51 +00:00
<BOTH,SCRIPT>"SORT_BY_NAME" { RTOKEN(SORT_BY_NAME); }
<BOTH,SCRIPT>"SORT_BY_ALIGNMENT" { RTOKEN(SORT_BY_ALIGNMENT); }
<BOTH,SCRIPT>"SORT" { RTOKEN(SORT_BY_NAME); }
1999-05-03 07:29:11 +00:00
<EXPRESSION,BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
<EXPRESSION,BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
<EXPRESSION,BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
<EXPRESSION,BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
<EXPRESSION,BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
* ldgram.y (sect_constraint): New. (ONLY_IF_RO, ONLY_IF_RW): New tokens. (section): Add sect_constraint. Pass additional argument to lang_enter_output_section_statement. * mri.c (mri_draw_tree): Pass additional argument to lang_enter_output_section_statement. * emultempl/pe.em (place_orphan): Likewise. (output_prev_sec_find): Disregard output section statements with constraint == -1. * emultempl/mmo.em (output_prev_sec_find): Likewise. (mmo_place_orphan): Pass additional argument to lang_enter_output_section_statement. * emultempl/elf32.em (output_prev_sec_find): Disregard output section statements with constraint == -1. (place_orphan): Pass additional argument to lang_enter_output_section_statement. * ldlang.c (lang_enter_overlay_section): Likewise. (lang_output_section_find_1): New. (lang_output_section_find): Use it. (lang_output_section_statement_lookup_1): New. (lang_output_section_statement_lookup): Use it. (check_section_callback, check_input_sections): New. (map_input_to_output_sections): Check if all input sections are readonly if ONLY_IF_RO or ONLY_IF_RW was seen. (strip_excluded_output_sections): Disregard output section statements with constraint == -1. (lang_record_phdrs): Likewise. (lang_enter_output_section_statement): Add constraint argument. Use lang_output_section_statement_lookup_1. * ldlang.h (lang_output_section_statement_type): Add constraint and all_input_readonly fields. (lang_enter_output_section_statement): Adjust prototype. * ldlex.l (ONLY_IF_RO, ONLY_IF_RW): New tokens. * scripttempl/elf.sc (.eh_frame, .gcc_except_table): Move into text segment if all input sections are readonly.
2004-05-19 14:01:14 +00:00
<EXPRESSION,BOTH,SCRIPT>"ONLY_IF_RO" { RTOKEN(ONLY_IF_RO); }
<EXPRESSION,BOTH,SCRIPT>"ONLY_IF_RW" { RTOKEN(ONLY_IF_RW); }
<EXPRESSION,BOTH,SCRIPT>"SPECIAL" { RTOKEN(SPECIAL); }
1999-05-03 07:29:11 +00:00
<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
<BOTH,SCRIPT>"INCLUDE" { RTOKEN(INCLUDE);}
<BOTH,SCRIPT>"PHDRS" { RTOKEN (PHDRS); }
<EXPRESSION,BOTH,SCRIPT>"AT" { RTOKEN(AT);}
<EXPRESSION,BOTH,SCRIPT>"SUBALIGN" { RTOKEN(SUBALIGN);}
<EXPRESSION,BOTH,SCRIPT>"PROVIDE" { RTOKEN(PROVIDE); }
<EXPRESSION,BOTH,SCRIPT>"PROVIDE_HIDDEN" { RTOKEN(PROVIDE_HIDDEN); }
1999-05-03 07:29:11 +00:00
<EXPRESSION,BOTH,SCRIPT>"KEEP" { RTOKEN(KEEP); }
<EXPRESSION,BOTH,SCRIPT>"EXCLUDE_FILE" { RTOKEN(EXCLUDE_FILE); }
bfd/ 2006-05-30 H.J. Lu <hongjiu.lu@intel.com> * bfd.c (bfd_emul_get_maxpagesize): New. (bfd_elf_set_pagesize): Likewise. (bfd_emul_set_maxpagesize): Likewise. (bfd_emul_get_commonpagesize): Likewise. (bfd_emul_set_commonpagesize): Likewise. * bfd-in2.h: Regenerated. * elf-bfd.h (elf_backend_data): Add commonpagesize. (xvec_get_elf_backend_data): New. (get_elf_backend_data): Use xvec_get_elf_backend_data. * elf32-arm.c (elf32_arm_vxworks_bed): Remove const. * elfxx-target.h (elfNN_bed): Likewise. * elf32-arm.c (ELF_COMMONPAGESIZE): Defined. * elf32-mips.c (ELF_COMMONPAGESIZE): Likewise. * elf32-ppc.c (ELF_COMMONPAGESIZE): Likewise. * elf32-sh.c (ELF_COMMONPAGESIZE): Likewise. * elf32-sh64.c (ELF_COMMONPAGESIZE): Likewise. * elf32-sparc.c (ELF_COMMONPAGESIZE): Likewise. * elf64-alpha.c (ELF_COMMONPAGESIZE): Likewise. * elf64-ppc.c (ELF_COMMONPAGESIZE): Likewise. * elf64-sparc.c (ELF_COMMONPAGESIZE): Likewise. * elf64-x86-64.c (ELF_COMMONPAGESIZE): Likewise. * elfn32-mips.c (ELF_COMMONPAGESIZE): Likewise. * elfxx-ia64.c (ELF_COMMONPAGESIZE): Likewise. * elfxx-target.h (ELF_COMMONPAGESIZE): Define if not defined. (elfNN_bed): Initialize commonpagesize with ELF_COMMONPAGESIZE. * targets.c (bfd_find_target): Support NULL abfd. ld/ 2006-05-30 H.J. Lu <hongjiu.lu@intel.com> * emulparams/arcelf.sh (MAXPAGESIZE): Changed to "CONSTANT (MAXPAGESIZE)". * emulparams/armelf_nbsd.sh: Likewise. * emulparams/armelf_vxworks.sh: Likewise. * emulparams/armnto.sh: Likewise. * emulparams/armsymbian.sh: Likewise. * emulparams/crislinux.sh: Likewise. * emulparams/elf32_i860.sh: Likewise. * emulparams/elf32_i960.sh: Likewise. * emulparams/elf32am33lin.sh: Likewise. * emulparams/elf32bfinfd.sh: Likewise. * emulparams/elf32bmipn32-defs.sh: Likewise. * emulparams/elf32frvfd.sh: Likewise. * emulparams/elf32i370.sh: Likewise. * emulparams/elf32lppcnto.sh: Likewise. * emulparams/elf32mcore.sh: Likewise. * emulparams/elf32openrisc.sh: Likewise. * emulparams/elf32ppcnto.sh: Likewise. * emulparams/elf32ppcwindiss.sh: Likewise. * emulparams/elf32vax.sh: Likewise. * emulparams/elf32xc16x.sh: Likewise. * emulparams/elf32xc16xl.sh: Likewise. * emulparams/elf32xc16xs.sh: Likewise. * emulparams/elf64_aix.sh: Likewise. * emulparams/elf64hppa.sh: Likewise. * emulparams/elf64mmix.sh: Likewise. * emulparams/elf_i386_be.sh: Likewise. * emulparams/elf_i386_chaos.sh: Likewise. * emulparams/elf_i386_ldso.sh: Likewise. * emulparams/hppa64linux.sh: Likewise. * emulparams/hppalinux.sh: Likewise. * emulparams/hppaobsd.sh: Likewise. * emulparams/i386lynx.sh: Likewise. * emulparams/i386moss.sh: Likewise. * emulparams/i386nto.sh: Likewise. * emulparams/i386nw.sh: Likewise. * emulparams/m32relf_linux.sh: Likewise. * emulparams/m68kpsos.sh: Likewise. * emulparams/or32elf.sh: Likewise. * emulparams/pjelf.sh: Likewise. * emulparams/pjlelf.sh: Likewise. * emulparams/ppclynx.sh: Likewise. * emulparams/ppcnw.sh: Likewise. * emulparams/shelf32_nbsd.sh : Likewise. * emulparams/shelf_nbsd.sh: Likewise. * emulparams/shelf_nto.sh: Likewise. * emulparams/shlelf_nto.sh: Likewise. * emulparams/xtensa-config.sh: Likewise. * emulparams/armelf_linux.sh (MAXPAGESIZE): Changed to "CONSTANT (MAXPAGESIZE)". (COMMONPAGESIZE): Changed to "CONSTANT (COMMONPAGESIZE)". * emulparams/elf32_sparc.sh: Likewise. * emulparams/elf32bmip.sh: Likewise. * emulparams/elf32ppccommon.sh: Likewise. * emulparams/elf64_ia64.sh: Likewise. * emulparams/elf64_s390.sh: Likewise. * emulparams/elf64_sparc.sh: Likewise. * emulparams/elf64alpha.sh: Likewise. * emulparams/elf64ppc.sh: Likewise. * emulparams/elf_i386.sh: Likewise. * emulparams/elf_i386_vxworks.sh: Likewise. * emulparams/elf_s390.sh: Likewise. * emulparams/elf_x86_64.sh: Likewise. * emulparams/shlelf32_linux.sh: Likewise. * emulparams/shlelf_linux.sh: Likewise. * emulparams/elf32bmipn32.sh (COMMONPAGESIZE): Changed to "CONSTANT (COMMONPAGESIZE)". * emulparams/elf32btsmipn32.sh: Likewise. * emultempl/elf32.em (gld${EMULATION_NAME}_handle_option): Add "-z max-page-size=" and "-z common-page-size=". (gld${EMULATION_NAME}_list_options): Likewise. * ld.h (ld_config_type): Add maxpagesize and commonpagesize. * ld.texinfo: Document "-z max-page-size=" and "-z common-page-size=". * ldexp.c (exp_print_token): Handle CONSTANT. (fold_name): Likewise. * ldgram.y: Likewise. * ldlex.l: Likewise. * ldmain.c (main): Initiliaze config.maxpagesize and config.commonpagesize. Call bfd_emul_set_maxpagesize if config.maxpagesize isn't 0. Call bfd_emul_set_commonpagesize if config.commonpagesize config.maxpagesize isn't 0. ld/testsuite/ 2006-05-30 H.J. Lu <hongjiu.lu@intel.com> * ld-elf/binutils.exp: New file. * ld-elf/commonpage1.d: Likewise. * ld-elf/maxpage1.d: Likewise. * ld-elf/maxpage1.s: Likewise.
2006-05-30 16:45:32 +00:00
<EXPRESSION,BOTH,SCRIPT>"CONSTANT" { RTOKEN(CONSTANT);}
1999-05-03 07:29:11 +00:00
<MRI>"#".*\n? { ++ lineno; }
<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
<MRI>"*".* { /* Mri comment line */ }
<MRI>";".* { /* Mri comment line */ }
<MRI>"END" { RTOKEN(ENDWORD); }
<MRI>"ALIGNMOD" { RTOKEN(ALIGNMOD);}
<MRI>"ALIGN" { RTOKEN(ALIGN_K);}
1999-05-03 07:29:11 +00:00
<MRI>"CHIP" { RTOKEN(CHIP); }
<MRI>"BASE" { RTOKEN(BASE); }
<MRI>"ALIAS" { RTOKEN(ALIAS); }
<MRI>"TRUNCATE" { RTOKEN(TRUNCATE); }
1999-05-03 07:29:11 +00:00
<MRI>"LOAD" { RTOKEN(LOAD); }
<MRI>"PUBLIC" { RTOKEN(PUBLIC); }
<MRI>"ORDER" { RTOKEN(ORDER); }
<MRI>"NAME" { RTOKEN(NAMEWORD); }
<MRI>"FORMAT" { RTOKEN(FORMAT); }
<MRI>"CASE" { RTOKEN(CASE); }
<MRI>"START" { RTOKEN(START); }
<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
<MRI>"SECT" { RTOKEN(SECT); }
<EXPRESSION,BOTH,SCRIPT,MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
<MRI>"end" { RTOKEN(ENDWORD); }
<MRI>"alignmod" { RTOKEN(ALIGNMOD);}
<MRI>"align" { RTOKEN(ALIGN_K);}
1999-05-03 07:29:11 +00:00
<MRI>"chip" { RTOKEN(CHIP); }
<MRI>"base" { RTOKEN(BASE); }
<MRI>"alias" { RTOKEN(ALIAS); }
<MRI>"truncate" { RTOKEN(TRUNCATE); }
1999-05-03 07:29:11 +00:00
<MRI>"load" { RTOKEN(LOAD); }
<MRI>"public" { RTOKEN(PUBLIC); }
<MRI>"order" { RTOKEN(ORDER); }
<MRI>"name" { RTOKEN(NAMEWORD); }
<MRI>"format" { RTOKEN(FORMAT); }
<MRI>"case" { RTOKEN(CASE); }
<MRI>"extern" { RTOKEN(EXTERN); }
<MRI>"start" { RTOKEN(START); }
<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
<MRI>"sect" { RTOKEN(SECT); }
<EXPRESSION,BOTH,SCRIPT,MRI>"absolute" { RTOKEN(ABSOLUTE); }
<MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
/* Filename without commas, needed to parse mri stuff */
2003-06-28 05:28:54 +00:00
yylval.name = xstrdup (yytext);
1999-05-03 07:29:11 +00:00
return NAME;
}
<BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
2003-06-28 05:28:54 +00:00
yylval.name = xstrdup (yytext);
1999-05-03 07:29:11 +00:00
return NAME;
}
<BOTH,EXPRESSION>"-l"{FILENAMECHAR}+ {
yylval.name = xstrdup (yytext + 2);
1999-05-03 07:29:11 +00:00
return LNAME;
}
<SCRIPT>{WILDCHAR}* {
/* Annoyingly, this pattern can match comments, and we have
longest match issues to consider. So if the first two
characters are a comment opening, put the input back and
try again. */
if (yytext[0] == '/' && yytext[1] == '*')
{
2003-06-28 05:28:54 +00:00
yyless (2);
1999-05-03 07:29:11 +00:00
comment ();
}
else
{
2003-06-28 05:28:54 +00:00
yylval.name = xstrdup (yytext);
1999-05-03 07:29:11 +00:00
return NAME;
}
}
<EXPRESSION,BOTH,SCRIPT,VERS_NODE>"\""[^\"]*"\"" {
/* No matter the state, quotes
give what's inside */
2003-06-28 05:28:54 +00:00
yylval.name = xstrdup (yytext + 1);
yylval.name[yyleng - 2] = 0;
1999-05-03 07:29:11 +00:00
return NAME;
}
<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
<MRI,BOTH,SCRIPT,EXPRESSION>[ \t\r]+ { }
<VERS_NODE,VERS_SCRIPT>[:,;] { return *yytext; }
<VERS_NODE>global { RTOKEN(GLOBAL); }
<VERS_NODE>local { RTOKEN(LOCAL); }
<VERS_NODE>extern { RTOKEN(EXTERN); }
<VERS_NODE>{V_IDENTIFIER} { yylval.name = xstrdup (yytext);
1999-05-03 07:29:11 +00:00
return VERS_IDENTIFIER; }
<VERS_SCRIPT>{V_TAG} { yylval.name = xstrdup (yytext);
1999-05-03 07:29:11 +00:00
return VERS_TAG; }
<VERS_START>"{" { BEGIN(VERS_SCRIPT); return *yytext; }
2003-06-28 05:28:54 +00:00
<VERS_SCRIPT>"{" { BEGIN(VERS_NODE);
1999-05-03 07:29:11 +00:00
vers_node_nesting = 0;
return *yytext;
}
<VERS_SCRIPT>"}" { return *yytext; }
<VERS_NODE>"{" { vers_node_nesting++; return *yytext; }
<VERS_NODE>"}" { if (--vers_node_nesting < 0)
BEGIN(VERS_SCRIPT);
return *yytext;
}
<VERS_START,VERS_NODE,VERS_SCRIPT>[\n] { lineno++; }
<VERS_START,VERS_NODE,VERS_SCRIPT>#.* { /* Eat up comments */ }
<VERS_START,VERS_NODE,VERS_SCRIPT>[ \t\r]+ { /* Eat up whitespace */ }
<<EOF>> {
include_stack_ptr--;
2003-06-28 05:28:54 +00:00
if (include_stack_ptr == 0)
1999-05-03 07:29:11 +00:00
{
2003-06-28 05:28:54 +00:00
yyterminate ();
1999-05-03 07:29:11 +00:00
}
2003-06-28 05:28:54 +00:00
else
1999-05-03 07:29:11 +00:00
{
2003-06-28 05:28:54 +00:00
yy_switch_to_buffer (include_stack[include_stack_ptr]);
1999-05-03 07:29:11 +00:00
}
1999-05-03 07:29:11 +00:00
ldfile_input_filename = file_name_stack[include_stack_ptr - 1];
lineno = lineno_stack[include_stack_ptr];
1999-05-03 07:29:11 +00:00
return END;
}
2003-06-28 05:28:54 +00:00
<SCRIPT,MRI,VERS_START,VERS_SCRIPT,VERS_NODE>. lex_warn_invalid (" in script", yytext);
<EXPRESSION,DEFSYMEXP,BOTH>. lex_warn_invalid (" in expression", yytext);
1999-05-03 07:29:11 +00:00
%%
/* Switch flex to reading script file NAME, open on FILE,
saving the current input info on the include stack. */
void
2003-06-28 05:28:54 +00:00
lex_push_file (FILE *file, const char *name)
1999-05-03 07:29:11 +00:00
{
2003-06-28 05:28:54 +00:00
if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
1999-05-03 07:29:11 +00:00
{
2003-06-28 05:28:54 +00:00
einfo ("%F:includes nested too deeply\n");
1999-05-03 07:29:11 +00:00
}
file_name_stack[include_stack_ptr] = name;
lineno_stack[include_stack_ptr] = lineno;
1999-05-03 07:29:11 +00:00
include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
include_stack_ptr++;
lineno = 1;
1999-05-03 07:29:11 +00:00
yyin = file;
2003-06-28 05:28:54 +00:00
yy_switch_to_buffer (yy_create_buffer (yyin, YY_BUF_SIZE));
1999-05-03 07:29:11 +00:00
}
/* Return a newly created flex input buffer containing STRING,
which is SIZE bytes long. */
2003-06-28 05:28:54 +00:00
static YY_BUFFER_STATE
yy_create_string_buffer (const char *string, size_t size)
1999-05-03 07:29:11 +00:00
{
YY_BUFFER_STATE b;
/* Calls to m-alloc get turned by sed into xm-alloc. */
2003-06-28 05:28:54 +00:00
b = malloc (sizeof (struct yy_buffer_state));
1999-05-03 07:29:11 +00:00
b->yy_input_file = 0;
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 characters longer than the size given because
we need to put in 2 end-of-buffer characters. */
2003-06-28 05:28:54 +00:00
b->yy_ch_buf = malloc ((unsigned) (b->yy_buf_size + 3));
1999-05-03 07:29:11 +00:00
b->yy_ch_buf[0] = '\n';
strcpy (b->yy_ch_buf+1, string);
b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
b->yy_n_chars = size+1;
b->yy_buf_pos = &b->yy_ch_buf[1];
b->yy_is_our_buffer = 1;
b->yy_is_interactive = 0;
b->yy_at_bol = 1;
b->yy_fill_buffer = 0;
1999-05-03 07:29:11 +00:00
/* flex 2.4.7 changed the interface. FIXME: We should not be using
a flex internal interface in the first place! */
#ifdef YY_BUFFER_NEW
b->yy_buffer_status = YY_BUFFER_NEW;
#else
b->yy_eof_status = EOF_NOT_SEEN;
#endif
return b;
}
/* Switch flex to reading from STRING, saving the current input info
on the include stack. */
void
2003-06-28 05:28:54 +00:00
lex_redirect (const char *string)
1999-05-03 07:29:11 +00:00
{
YY_BUFFER_STATE tmp;
yy_init = 0;
2003-06-28 05:28:54 +00:00
if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
1999-05-03 07:29:11 +00:00
{
einfo("%F: macros nested too deeply\n");
}
file_name_stack[include_stack_ptr] = "redirect";
lineno_stack[include_stack_ptr] = lineno;
1999-05-03 07:29:11 +00:00
include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
include_stack_ptr++;
lineno = 1;
1999-05-03 07:29:11 +00:00
tmp = yy_create_string_buffer (string, strlen (string));
yy_switch_to_buffer (tmp);
}
/* Functions to switch to a different flex start condition,
saving the current start condition on `state_stack'. */
static int state_stack[MAX_INCLUDE_DEPTH * 2];
static int *state_stack_p = state_stack;
void
2003-06-28 05:28:54 +00:00
ldlex_script (void)
1999-05-03 07:29:11 +00:00
{
*(state_stack_p)++ = yy_start;
BEGIN (SCRIPT);
}
void
2003-06-28 05:28:54 +00:00
ldlex_mri_script (void)
1999-05-03 07:29:11 +00:00
{
*(state_stack_p)++ = yy_start;
BEGIN (MRI);
}
void
2003-06-28 05:28:54 +00:00
ldlex_version_script (void)
1999-05-03 07:29:11 +00:00
{
*(state_stack_p)++ = yy_start;
BEGIN (VERS_START);
}
void
2003-06-28 05:28:54 +00:00
ldlex_version_file (void)
1999-05-03 07:29:11 +00:00
{
*(state_stack_p)++ = yy_start;
BEGIN (VERS_SCRIPT);
}
void
2003-06-28 05:28:54 +00:00
ldlex_defsym (void)
1999-05-03 07:29:11 +00:00
{
*(state_stack_p)++ = yy_start;
BEGIN (DEFSYMEXP);
}
2003-06-28 05:28:54 +00:00
1999-05-03 07:29:11 +00:00
void
2003-06-28 05:28:54 +00:00
ldlex_expression (void)
1999-05-03 07:29:11 +00:00
{
*(state_stack_p)++ = yy_start;
BEGIN (EXPRESSION);
}
void
2003-06-28 05:28:54 +00:00
ldlex_both (void)
1999-05-03 07:29:11 +00:00
{
*(state_stack_p)++ = yy_start;
BEGIN (BOTH);
}
void
2003-06-28 05:28:54 +00:00
ldlex_popstate (void)
1999-05-03 07:29:11 +00:00
{
yy_start = *(--state_stack_p);
}
/* Place up to MAX_SIZE characters in BUF and return in *RESULT
either the number of characters read, or 0 to indicate EOF. */
static void
2003-06-28 05:28:54 +00:00
yy_input (char *buf, int *result, int max_size)
1999-05-03 07:29:11 +00:00
{
2003-06-28 05:28:54 +00:00
*result = 0;
if (YY_CURRENT_BUFFER->yy_input_file)
1999-05-03 07:29:11 +00:00
{
if (yyin)
{
2003-06-28 05:28:54 +00:00
*result = fread (buf, 1, max_size, yyin);
if (*result < max_size && ferror (yyin))
1999-05-03 07:29:11 +00:00
einfo ("%F%P: read in flex scanner failed\n");
}
}
}
/* Eat the rest of a C-style comment. */
static void
2003-06-28 05:28:54 +00:00
comment (void)
1999-05-03 07:29:11 +00:00
{
int c;
while (1)
{
c = input();
2003-06-28 05:28:54 +00:00
while (c != '*' && c != EOF)
1999-05-03 07:29:11 +00:00
{
if (c == '\n')
lineno++;
c = input();
}
if (c == '*')
{
c = input();
while (c == '*')
c = input();
if (c == '/')
break; /* found the end */
}
if (c == '\n')
lineno++;
if (c == EOF)
{
einfo( "%F%P: EOF in comment\n");
break;
}
}
}
/* Warn the user about a garbage character WHAT in the input
in context WHERE. */
static void
2003-06-28 05:28:54 +00:00
lex_warn_invalid (char *where, char *what)
1999-05-03 07:29:11 +00:00
{
char buf[5];
/* If we have found an input file whose format we do not recognize,
and we are therefore treating it as a linker script, and we find
an invalid character, then most likely this is a real object file
of some different format. Treat it as such. */
if (ldfile_assumed_script)
{
bfd_set_error (bfd_error_file_not_recognized);
einfo ("%F%s: file not recognized: %E\n", ldfile_input_filename);
}
if (! ISPRINT (*what))
1999-05-03 07:29:11 +00:00
{
sprintf (buf, "\\%03o", (unsigned int) *what);
what = buf;
}
einfo ("%P:%S: ignoring invalid character `%s'%s\n", what, where);
}