Subversion Repositories openrisc_me

/* A Bison parser, made by GNU Bison 2.3.  */

/* Skeleton implementation for Bison's Yacc-like parsers in C

   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006

   Free Software Foundation, Inc.

   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 2, 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.  */

/* As a special exception, you may create a larger work that contains

   part or all of the Bison parser skeleton and distribute that work

   under terms of your choice, so long as that work isn't itself a

   parser generator using the skeleton or a modified version thereof

   as a parser skeleton.  Alternatively, if you modify or redistribute

   the parser skeleton itself, you may (at your option) remove this

   special exception, which will cause the skeleton and the resulting

   Bison output files to be licensed under the GNU General Public

   License without this special exception.

   This special exception was added by the Free Software Foundation in

   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by

   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with yy or YY, to avoid

   infringing on user name space.  This should be done even for local

   variables, as they might otherwise be expanded by user macros.

   There are some unavoidable exceptions within include files to

   define necessary library symbols; they are noted "INFRINGES ON

   USER NAME SPACE" below.  */

/* Identify Bison output.  */

#define YYBISON 1

/* Bison version.  */

#define YYBISON_VERSION "2.3"

/* Skeleton name.  */

#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */

#define YYPURE 0

/* Using locations.  */

#define YYLSP_NEEDED 0

/* Tokens.  */

#ifndef YYTOKENTYPE

# define YYTOKENTYPE

   /* Put the tokens into the symbol table, so that GDB and other debuggers

      know about them.  */

   enum yytokentype {

     INT = 258,

     NAME = 259,

     LNAME = 260,

     OREQ = 261,

     ANDEQ = 262,

     RSHIFTEQ = 263,

     LSHIFTEQ = 264,

     DIVEQ = 265,

     MULTEQ = 266,

     MINUSEQ = 267,

     PLUSEQ = 268,

     OROR = 269,

     ANDAND = 270,

     NE = 271,

     EQ = 272,

     GE = 273,

     LE = 274,

     RSHIFT = 275,

     LSHIFT = 276,

     UNARY = 277,

     END = 278,

     ALIGN_K = 279,

     BLOCK = 280,

     BIND = 281,

     QUAD = 282,

     SQUAD = 283,

     LONG = 284,

     SHORT = 285,

     BYTE = 286,

     SECTIONS = 287,

     PHDRS = 288,

     INSERT_K = 289,

     AFTER = 290,

     BEFORE = 291,

     DATA_SEGMENT_ALIGN = 292,

     DATA_SEGMENT_RELRO_END = 293,

     DATA_SEGMENT_END = 294,

     SORT_BY_NAME = 295,

     SORT_BY_ALIGNMENT = 296,

     SIZEOF_HEADERS = 297,

     OUTPUT_FORMAT = 298,

     FORCE_COMMON_ALLOCATION = 299,

     OUTPUT_ARCH = 300,

     INHIBIT_COMMON_ALLOCATION = 301,

     SEGMENT_START = 302,

     INCLUDE = 303,

     MEMORY = 304,

     REGION_ALIAS = 305,

     NOLOAD = 306,

     DSECT = 307,

     COPY = 308,

     INFO = 309,

     OVERLAY = 310,

     DEFINED = 311,

     TARGET_K = 312,

     SEARCH_DIR = 313,

     MAP = 314,

     ENTRY = 315,

     NEXT = 316,

     SIZEOF = 317,

     ALIGNOF = 318,

     ADDR = 319,

     LOADADDR = 320,

     MAX_K = 321,

     MIN_K = 322,

     STARTUP = 323,

     HLL = 324,

     SYSLIB = 325,

     FLOAT = 326,

     NOFLOAT = 327,

     NOCROSSREFS = 328,

     ORIGIN = 329,

     FILL = 330,

     LENGTH = 331,

     CREATE_OBJECT_SYMBOLS = 332,

     INPUT = 333,

     GROUP = 334,

     OUTPUT = 335,

     CONSTRUCTORS = 336,

     ALIGNMOD = 337,

     AT = 338,

     SUBALIGN = 339,

     PROVIDE = 340,

     PROVIDE_HIDDEN = 341,

     AS_NEEDED = 342,

     CHIP = 343,

     LIST = 344,

     SECT = 345,

     ABSOLUTE = 346,

     LOAD = 347,

     NEWLINE = 348,

     ENDWORD = 349,

     ORDER = 350,

     NAMEWORD = 351,

     ASSERT_K = 352,

     FORMAT = 353,

     PUBLIC = 354,

     DEFSYMEND = 355,

     BASE = 356,

     ALIAS = 357,

     TRUNCATE = 358,

     REL = 359,

     INPUT_SCRIPT = 360,

     INPUT_MRI_SCRIPT = 361,

     INPUT_DEFSYM = 362,

     CASE = 363,

     EXTERN = 364,

     START = 365,

     VERS_TAG = 366,

     VERS_IDENTIFIER = 367,

     GLOBAL = 368,

     LOCAL = 369,

     VERSIONK = 370,

     INPUT_VERSION_SCRIPT = 371,

     KEEP = 372,

     ONLY_IF_RO = 373,

     ONLY_IF_RW = 374,

     SPECIAL = 375,

     EXCLUDE_FILE = 376,

     CONSTANT = 377,

     INPUT_DYNAMIC_LIST = 378

   };

#endif

/* Tokens.  */

#define INT 258

#define NAME 259

#define LNAME 260

#define OREQ 261

#define ANDEQ 262

#define RSHIFTEQ 263

#define LSHIFTEQ 264

#define DIVEQ 265

#define MULTEQ 266

#define MINUSEQ 267

#define PLUSEQ 268

#define OROR 269

#define ANDAND 270

#define NE 271

#define EQ 272

#define GE 273

#define LE 274

#define RSHIFT 275

#define LSHIFT 276

#define UNARY 277

#define END 278

#define ALIGN_K 279

#define BLOCK 280

#define BIND 281

#define QUAD 282

#define SQUAD 283

#define LONG 284

#define SHORT 285

#define BYTE 286

#define SECTIONS 287

#define PHDRS 288

#define INSERT_K 289

#define AFTER 290

#define BEFORE 291

#define DATA_SEGMENT_ALIGN 292

#define DATA_SEGMENT_RELRO_END 293

#define DATA_SEGMENT_END 294

#define SORT_BY_NAME 295

#define SORT_BY_ALIGNMENT 296

#define SIZEOF_HEADERS 297

#define OUTPUT_FORMAT 298

#define FORCE_COMMON_ALLOCATION 299

#define OUTPUT_ARCH 300

#define INHIBIT_COMMON_ALLOCATION 301

#define SEGMENT_START 302

#define INCLUDE 303

#define MEMORY 304

#define REGION_ALIAS 305

#define NOLOAD 306

#define DSECT 307

#define COPY 308

#define INFO 309

#define OVERLAY 310

#define DEFINED 311

#define TARGET_K 312

#define SEARCH_DIR 313

#define MAP 314

#define ENTRY 315

#define NEXT 316

#define SIZEOF 317

#define ALIGNOF 318

#define ADDR 319

#define LOADADDR 320

#define MAX_K 321

#define MIN_K 322

#define STARTUP 323

#define HLL 324

#define SYSLIB 325

#define FLOAT 326

#define NOFLOAT 327

#define NOCROSSREFS 328

#define ORIGIN 329

#define FILL 330

#define LENGTH 331

#define CREATE_OBJECT_SYMBOLS 332

#define INPUT 333

#define GROUP 334

#define OUTPUT 335

#define CONSTRUCTORS 336

#define ALIGNMOD 337

#define AT 338

#define SUBALIGN 339

#define PROVIDE 340

#define PROVIDE_HIDDEN 341

#define AS_NEEDED 342

#define CHIP 343

#define LIST 344

#define SECT 345

#define ABSOLUTE 346

#define LOAD 347

#define NEWLINE 348

#define ENDWORD 349

#define ORDER 350

#define NAMEWORD 351

#define ASSERT_K 352

#define FORMAT 353

#define PUBLIC 354

#define DEFSYMEND 355

#define BASE 356

#define ALIAS 357

#define TRUNCATE 358

#define REL 359

#define INPUT_SCRIPT 360

#define INPUT_MRI_SCRIPT 361

#define INPUT_DEFSYM 362

#define CASE 363

#define EXTERN 364

#define START 365

#define VERS_TAG 366

#define VERS_IDENTIFIER 367

#define GLOBAL 368

#define LOCAL 369

#define VERSIONK 370

#define INPUT_VERSION_SCRIPT 371

#define KEEP 372

#define ONLY_IF_RO 373

#define ONLY_IF_RW 374

#define SPECIAL 375

#define EXCLUDE_FILE 376

#define CONSTANT 377

#define INPUT_DYNAMIC_LIST 378

/* Copy the first part of user declarations.  */

#line 24 "ldgram.y"

/*

 */

#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--;

/* Enabling traces.  */

#ifndef YYDEBUG

# define YYDEBUG 0

#endif

/* Enabling verbose error messages.  */

#ifdef YYERROR_VERBOSE

# undef YYERROR_VERBOSE

# define YYERROR_VERBOSE 1

#else

# define YYERROR_VERBOSE 0

#endif

/* Enabling the token table.  */

#ifndef YYTOKEN_TABLE

# define YYTOKEN_TABLE 0

#endif

#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED

typedef union YYSTYPE

#line 62 "ldgram.y"

{

  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;

  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;

}

/* Line 193 of yacc.c.  */

#line 410 "ldgram.c"

        YYSTYPE;

# define yystype YYSTYPE /* obsolescent; will be withdrawn */

# define YYSTYPE_IS_DECLARED 1

# define YYSTYPE_IS_TRIVIAL 1

#endif

/* Copy the second part of user declarations.  */

/* Line 216 of yacc.c.  */

#line 423 "ldgram.c"

#ifdef short

# undef short

#endif

#ifdef YYTYPE_UINT8

typedef YYTYPE_UINT8 yytype_uint8;

#else

typedef unsigned char yytype_uint8;

#endif

#ifdef YYTYPE_INT8

typedef YYTYPE_INT8 yytype_int8;

#elif (defined __STDC__ || defined __C99__FUNC__ \

     || defined __cplusplus || defined _MSC_VER)

typedef signed char yytype_int8;

#else

typedef short int yytype_int8;

#endif

#ifdef YYTYPE_UINT16

typedef YYTYPE_UINT16 yytype_uint16;

#else

typedef unsigned short int yytype_uint16;

#endif

#ifdef YYTYPE_INT16

typedef YYTYPE_INT16 yytype_int16;

#else

typedef short int yytype_int16;

#endif

#ifndef YYSIZE_T

# ifdef __SIZE_TYPE__

#  define YYSIZE_T __SIZE_TYPE__

# elif defined size_t

#  define YYSIZE_T size_t

# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \

     || defined __cplusplus || defined _MSC_VER)

#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */

#  define YYSIZE_T size_t

# else

#  define YYSIZE_T unsigned int

# endif

#endif

#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)

#ifndef YY_

# if defined YYENABLE_NLS && YYENABLE_NLS

#  if ENABLE_NLS

#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */

#   define YY_(msgid) dgettext ("bison-runtime", msgid)

#  endif

# endif

# ifndef YY_

#  define YY_(msgid) msgid

# endif

#endif

/* Suppress unused-variable warnings by "using" E.  */

#if ! defined lint || defined __GNUC__

# define YYUSE(e) ((void) (e))

#else

# define YYUSE(e) /* empty */

#endif

/* Identity function, used to suppress warnings about constant conditions.  */

#ifndef lint

# define YYID(n) (n)

#else

#if (defined __STDC__ || defined __C99__FUNC__ \

     || defined __cplusplus || defined _MSC_VER)

static int

YYID (int i)

#else

static int

YYID (i)

    int i;

#endif

{

  return i;

}

#endif

#if ! defined yyoverflow || YYERROR_VERBOSE

/* The parser invokes alloca or malloc; define the necessary symbols.  */

# ifdef YYSTACK_USE_ALLOCA

#  if YYSTACK_USE_ALLOCA

#   ifdef __GNUC__

#    define YYSTACK_ALLOC __builtin_alloca

#   elif defined __BUILTIN_VA_ARG_INCR

#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */

#   elif defined _AIX

#    define YYSTACK_ALLOC __alloca

#   elif defined _MSC_VER

#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */

#    define alloca _alloca

#   else

#    define YYSTACK_ALLOC alloca

#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \

     || defined __cplusplus || defined _MSC_VER)

#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

#     ifndef _STDLIB_H

#      define _STDLIB_H 1

#     endif

#    endif

#   endif

#  endif

# endif

# ifdef YYSTACK_ALLOC

   /* Pacify GCC's `empty if-body' warning.  */

#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))

#  ifndef YYSTACK_ALLOC_MAXIMUM

    /* The OS might guarantee only one guard page at the bottom of the stack,

       and a page size can be as small as 4096 bytes.  So we cannot safely

       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number

       to allow for a few compiler-allocated temporary stack slots.  */

#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */

#  endif

# else

#  define YYSTACK_ALLOC YYMALLOC

#  define YYSTACK_FREE YYFREE

#  ifndef YYSTACK_ALLOC_MAXIMUM

#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM

#  endif

#  if (defined __cplusplus && ! defined _STDLIB_H \

       && ! ((defined YYMALLOC || defined malloc) \

             && (defined YYFREE || defined free)))

#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

#   ifndef _STDLIB_H

#    define _STDLIB_H 1

#   endif

#  endif

#  ifndef YYMALLOC

#   define YYMALLOC malloc

#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \

     || defined __cplusplus || defined _MSC_VER)

void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */

#   endif

#  endif

#  ifndef YYFREE

#   define YYFREE free

#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \

     || defined __cplusplus || defined _MSC_VER)

void free (void *); /* INFRINGES ON USER NAME SPACE */

#   endif

#  endif

# endif

#endif /* ! defined yyoverflow || YYERROR_VERBOSE */

#if (! defined yyoverflow \

     && (! defined __cplusplus \

         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member.  */

union yyalloc

{

  yytype_int16 yyss;

  YYSTYPE yyvs;

  };

/* The size of the maximum gap between one aligned stack and the next.  */

# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

/* The size of an array large to enough to hold all stacks, each with

   N elements.  */

# define YYSTACK_BYTES(N) \

     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \

      + YYSTACK_GAP_MAXIMUM)

/* Copy COUNT objects from FROM to TO.  The source and destination do

   not overlap.  */

# ifndef YYCOPY

#  if defined __GNUC__ && 1 < __GNUC__

#   define YYCOPY(To, From, Count) \

      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))

#  else

#   define YYCOPY(To, From, Count)              \

      do                                        \

        {                                       \

          YYSIZE_T yyi;                         \

          for (yyi = 0; yyi < (Count); yyi++)    \

            (To)[yyi] = (From)[yyi];            \

        }                                       \

      while (YYID (0))

#  endif

# endif

/* Relocate STACK from its old location to the new one.  The

   local variables YYSIZE and YYSTACKSIZE give the old and new number of

   elements in the stack, and YYPTR gives the new location of the

   stack.  Advance YYPTR to a properly aligned location for the next

   stack.  */

# define YYSTACK_RELOCATE(Stack)                                        \

    do                                                                  \

      {                                                                 \

        YYSIZE_T yynewbytes;                                            \

        YYCOPY (&yyptr->Stack, Stack, yysize);                          \

        Stack = &yyptr->Stack;                                          \

        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \

        yyptr += yynewbytes / sizeof (*yyptr);                          \

      }                                                                 \

    while (YYID (0))

#endif

/* YYFINAL -- State number of the termination state.  */

#define YYFINAL  17

/* YYLAST -- Last index in YYTABLE.  */

#define YYLAST   1838

/* YYNTOKENS -- Number of terminals.  */

#define YYNTOKENS  147

/* YYNNTS -- Number of nonterminals.  */

#define YYNNTS  126

/* YYNRULES -- Number of rules.  */

#define YYNRULES  356

/* YYNRULES -- Number of states.  */

#define YYNSTATES  763

/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */

#define YYUNDEFTOK  2

#define YYMAXUTOK   378

#define YYTRANSLATE(YYX)                                                \

  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */

static const yytype_uint8 yytranslate[] =

{

       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,   145,     2,     2,     2,    34,    21,     2,

      37,   142,    32,    30,   140,    31,     2,    33,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,    16,   141,

      24,     6,    25,    15,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,   143,     2,   144,    20,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,    56,    19,    57,   146,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,

       5,     7,     8,     9,    10,    11,    12,    13,    14,    17,

      18,    22,    23,    26,    27,    28,    29,    35,    36,    38,

      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,

      49,    50,    51,    52,    53,    54,    55,    58,    59,    60,

      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,

      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,

      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,

      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,

     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,

     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,