1 /* A Bison parser, made by GNU Bison 2.5. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33 /* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36 /* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43 /* Identify Bison output. */ 44 #define YYBISON 1 45 46 /* Bison version. */ 47 #define YYBISON_VERSION "2.5" 48 49 /* Skeleton name. */ 50 #define YYSKELETON_NAME "yacc.c" 51 52 /* Pure parsers. */ 53 #define YYPURE 0 54 55 /* Push parsers. */ 56 #define YYPUSH 0 57 58 /* Pull parsers. */ 59 #define YYPULL 1 60 61 /* Using locations. */ 62 #define YYLSP_NEEDED 0 63 64 /* Substitute the variable and function names. */ 65 #define yyparse ldparse 66 #define yylex ldlex 67 #define yyerror lderror 68 #define yylval ldlval 69 #define yychar ldchar 70 #define yydebug lddebug 71 #define yynerrs ldnerrs 72 73 74 /* Copy the first part of user declarations. */ 75 76 /* Line 268 of yacc.c */ 77 #line 1 "ldscript.y" 78 79 /* Parser for linker scripts. 80 Copyright (C) 2001-2011 Red Hat, Inc. 81 This file is part of Red Hat elfutils. 82 Written by Ulrich Drepper <drepper (at) redhat.com>, 2001. 83 84 Red Hat elfutils is free software; you can redistribute it and/or modify 85 it under the terms of the GNU General Public License as published by the 86 Free Software Foundation; version 2 of the License. 87 88 Red Hat elfutils is distributed in the hope that it will be useful, but 89 WITHOUT ANY WARRANTY; without even the implied warranty of 90 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 91 General Public License for more details. 92 93 You should have received a copy of the GNU General Public License along 94 with Red Hat elfutils; if not, write to the Free Software Foundation, 95 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. 96 97 Red Hat elfutils is an included package of the Open Invention Network. 98 An included package of the Open Invention Network is a package for which 99 Open Invention Network licensees cross-license their patents. No patent 100 license is granted, either expressly or impliedly, by designation as an 101 included package. Should you wish to participate in the Open Invention 102 Network licensing program, please visit www.openinventionnetwork.com 103 <http://www.openinventionnetwork.com>. */ 104 105 #ifdef HAVE_CONFIG_H 106 # include <config.h> 107 #endif 108 109 #include <assert.h> 110 #include <error.h> 111 #include <libintl.h> 112 #include <stdbool.h> 113 #include <stdint.h> 114 #include <stdio.h> 115 #include <stdlib.h> 116 #include <string.h> 117 118 #include <system.h> 119 #include <ld.h> 120 121 /* The error handler. */ 122 static void yyerror (const char *s); 123 124 /* Some helper functions we need to construct the data structures 125 describing information from the file. */ 126 static struct expression *new_expr (int tag); 127 static struct input_section_name *new_input_section_name (const char *name, 128 bool sort_flag); 129 static struct input_rule *new_input_rule (int tag); 130 static struct output_rule *new_output_rule (int tag); 131 static struct assignment *new_assignment (const char *variable, 132 struct expression *expression, 133 bool provide_flag); 134 static void new_segment (int mode, struct output_rule *output_rule); 135 static struct filename_list *new_filename_listelem (const char *string); 136 static void add_inputfiles (struct filename_list *fnames); 137 static struct id_list *new_id_listelem (const char *str); 138 static struct filename_list *mark_as_needed (struct filename_list *listp); 139 static struct version *new_version (struct id_list *local, 140 struct id_list *global); 141 static struct version *merge_versions (struct version *one, 142 struct version *two); 143 static void add_versions (struct version *versions); 144 145 extern int yylex (void); 146 147 148 /* Line 268 of yacc.c */ 149 #line 150 "ldscript.c" 150 151 /* Enabling traces. */ 152 #ifndef YYDEBUG 153 # define YYDEBUG 0 154 #endif 155 156 /* Enabling verbose error messages. */ 157 #ifdef YYERROR_VERBOSE 158 # undef YYERROR_VERBOSE 159 # define YYERROR_VERBOSE 1 160 #else 161 # define YYERROR_VERBOSE 0 162 #endif 163 164 /* Enabling the token table. */ 165 #ifndef YYTOKEN_TABLE 166 # define YYTOKEN_TABLE 0 167 #endif 168 169 170 /* Tokens. */ 171 #ifndef YYTOKENTYPE 172 # define YYTOKENTYPE 173 /* Put the tokens into the symbol table, so that GDB and other debuggers 174 know about them. */ 175 enum yytokentype { 176 kADD_OP = 258, 177 kALIGN = 259, 178 kAS_NEEDED = 260, 179 kENTRY = 261, 180 kEXCLUDE_FILE = 262, 181 kFILENAME = 263, 182 kGLOBAL = 264, 183 kGROUP = 265, 184 kID = 266, 185 kINPUT = 267, 186 kINTERP = 268, 187 kKEEP = 269, 188 kLOCAL = 270, 189 kMODE = 271, 190 kMUL_OP = 272, 191 kNUM = 273, 192 kOUTPUT_FORMAT = 274, 193 kPAGESIZE = 275, 194 kPROVIDE = 276, 195 kSEARCH_DIR = 277, 196 kSEGMENT = 278, 197 kSIZEOF_HEADERS = 279, 198 kSORT = 280, 199 kVERSION = 281, 200 kVERSION_SCRIPT = 282, 201 ADD_OP = 283, 202 MUL_OP = 284 203 }; 204 #endif 205 /* Tokens. */ 206 #define kADD_OP 258 207 #define kALIGN 259 208 #define kAS_NEEDED 260 209 #define kENTRY 261 210 #define kEXCLUDE_FILE 262 211 #define kFILENAME 263 212 #define kGLOBAL 264 213 #define kGROUP 265 214 #define kID 266 215 #define kINPUT 267 216 #define kINTERP 268 217 #define kKEEP 269 218 #define kLOCAL 270 219 #define kMODE 271 220 #define kMUL_OP 272 221 #define kNUM 273 222 #define kOUTPUT_FORMAT 274 223 #define kPAGESIZE 275 224 #define kPROVIDE 276 225 #define kSEARCH_DIR 277 226 #define kSEGMENT 278 227 #define kSIZEOF_HEADERS 279 228 #define kSORT 280 229 #define kVERSION 281 230 #define kVERSION_SCRIPT 282 231 #define ADD_OP 283 232 #define MUL_OP 284 233 234 235 236 237 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 238 typedef union YYSTYPE 239 { 240 241 /* Line 293 of yacc.c */ 242 #line 71 "ldscript.y" 243 244 uintmax_t num; 245 enum expression_tag op; 246 char *str; 247 struct expression *expr; 248 struct input_section_name *sectionname; 249 struct filemask_section_name *filemask_section_name; 250 struct input_rule *input_rule; 251 struct output_rule *output_rule; 252 struct assignment *assignment; 253 struct filename_list *filename_list; 254 struct version *version; 255 struct id_list *id_list; 256 257 258 259 /* Line 293 of yacc.c */ 260 #line 261 "ldscript.c" 261 } YYSTYPE; 262 # define YYSTYPE_IS_TRIVIAL 1 263 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 264 # define YYSTYPE_IS_DECLARED 1 265 #endif 266 267 268 /* Copy the second part of user declarations. */ 269 270 271 /* Line 343 of yacc.c */ 272 #line 273 "ldscript.c" 273 274 #ifdef short 275 # undef short 276 #endif 277 278 #ifdef YYTYPE_UINT8 279 typedef YYTYPE_UINT8 yytype_uint8; 280 #else 281 typedef unsigned char yytype_uint8; 282 #endif 283 284 #ifdef YYTYPE_INT8 285 typedef YYTYPE_INT8 yytype_int8; 286 #elif (defined __STDC__ || defined __C99__FUNC__ \ 287 || defined __cplusplus || defined _MSC_VER) 288 typedef signed char yytype_int8; 289 #else 290 typedef short int yytype_int8; 291 #endif 292 293 #ifdef YYTYPE_UINT16 294 typedef YYTYPE_UINT16 yytype_uint16; 295 #else 296 typedef unsigned short int yytype_uint16; 297 #endif 298 299 #ifdef YYTYPE_INT16 300 typedef YYTYPE_INT16 yytype_int16; 301 #else 302 typedef short int yytype_int16; 303 #endif 304 305 #ifndef YYSIZE_T 306 # ifdef __SIZE_TYPE__ 307 # define YYSIZE_T __SIZE_TYPE__ 308 # elif defined size_t 309 # define YYSIZE_T size_t 310 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 311 || defined __cplusplus || defined _MSC_VER) 312 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 313 # define YYSIZE_T size_t 314 # else 315 # define YYSIZE_T unsigned int 316 # endif 317 #endif 318 319 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 320 321 #ifndef YY_ 322 # if defined YYENABLE_NLS && YYENABLE_NLS 323 # if ENABLE_NLS 324 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 325 # define YY_(msgid) dgettext ("bison-runtime", msgid) 326 # endif 327 # endif 328 # ifndef YY_ 329 # define YY_(msgid) msgid 330 # endif 331 #endif 332 333 /* Suppress unused-variable warnings by "using" E. */ 334 #if ! defined lint || defined __GNUC__ 335 # define YYUSE(e) ((void) (e)) 336 #else 337 # define YYUSE(e) /* empty */ 338 #endif 339 340 /* Identity function, used to suppress warnings about constant conditions. */ 341 #ifndef lint 342 # define YYID(n) (n) 343 #else 344 #if (defined __STDC__ || defined __C99__FUNC__ \ 345 || defined __cplusplus || defined _MSC_VER) 346 static int 347 YYID (int yyi) 348 #else 349 static int 350 YYID (yyi) 351 int yyi; 352 #endif 353 { 354 return yyi; 355 } 356 #endif 357 358 #if ! defined yyoverflow || YYERROR_VERBOSE 359 360 /* The parser invokes alloca or malloc; define the necessary symbols. */ 361 362 # ifdef YYSTACK_USE_ALLOCA 363 # if YYSTACK_USE_ALLOCA 364 # ifdef __GNUC__ 365 # define YYSTACK_ALLOC __builtin_alloca 366 # elif defined __BUILTIN_VA_ARG_INCR 367 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 368 # elif defined _AIX 369 # define YYSTACK_ALLOC __alloca 370 # elif defined _MSC_VER 371 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 372 # define alloca _alloca 373 # else 374 # define YYSTACK_ALLOC alloca 375 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 376 || defined __cplusplus || defined _MSC_VER) 377 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 378 # ifndef EXIT_SUCCESS 379 # define EXIT_SUCCESS 0 380 # endif 381 # endif 382 # endif 383 # endif 384 # endif 385 386 # ifdef YYSTACK_ALLOC 387 /* Pacify GCC's `empty if-body' warning. */ 388 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 389 # ifndef YYSTACK_ALLOC_MAXIMUM 390 /* The OS might guarantee only one guard page at the bottom of the stack, 391 and a page size can be as small as 4096 bytes. So we cannot safely 392 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 393 to allow for a few compiler-allocated temporary stack slots. */ 394 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 395 # endif 396 # else 397 # define YYSTACK_ALLOC YYMALLOC 398 # define YYSTACK_FREE YYFREE 399 # ifndef YYSTACK_ALLOC_MAXIMUM 400 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 401 # endif 402 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 403 && ! ((defined YYMALLOC || defined malloc) \ 404 && (defined YYFREE || defined free))) 405 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 406 # ifndef EXIT_SUCCESS 407 # define EXIT_SUCCESS 0 408 # endif 409 # endif 410 # ifndef YYMALLOC 411 # define YYMALLOC malloc 412 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 413 || defined __cplusplus || defined _MSC_VER) 414 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 415 # endif 416 # endif 417 # ifndef YYFREE 418 # define YYFREE free 419 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 420 || defined __cplusplus || defined _MSC_VER) 421 void free (void *); /* INFRINGES ON USER NAME SPACE */ 422 # endif 423 # endif 424 # endif 425 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 426 427 428 #if (! defined yyoverflow \ 429 && (! defined __cplusplus \ 430 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 431 432 /* A type that is properly aligned for any stack member. */ 433 union yyalloc 434 { 435 yytype_int16 yyss_alloc; 436 YYSTYPE yyvs_alloc; 437 }; 438 439 /* The size of the maximum gap between one aligned stack and the next. */ 440 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 441 442 /* The size of an array large to enough to hold all stacks, each with 443 N elements. */ 444 # define YYSTACK_BYTES(N) \ 445 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 446 + YYSTACK_GAP_MAXIMUM) 447 448 # define YYCOPY_NEEDED 1 449 450 /* Relocate STACK from its old location to the new one. The 451 local variables YYSIZE and YYSTACKSIZE give the old and new number of 452 elements in the stack, and YYPTR gives the new location of the 453 stack. Advance YYPTR to a properly aligned location for the next 454 stack. */ 455 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 456 do \ 457 { \ 458 YYSIZE_T yynewbytes; \ 459 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 460 Stack = &yyptr->Stack_alloc; \ 461 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 462 yyptr += yynewbytes / sizeof (*yyptr); \ 463 } \ 464 while (YYID (0)) 465 466 #endif 467 468 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 469 /* Copy COUNT objects from FROM to TO. The source and destination do 470 not overlap. */ 471 # ifndef YYCOPY 472 # if defined __GNUC__ && 1 < __GNUC__ 473 # define YYCOPY(To, From, Count) \ 474 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 475 # else 476 # define YYCOPY(To, From, Count) \ 477 do \ 478 { \ 479 YYSIZE_T yyi; \ 480 for (yyi = 0; yyi < (Count); yyi++) \ 481 (To)[yyi] = (From)[yyi]; \ 482 } \ 483 while (YYID (0)) 484 # endif 485 # endif 486 #endif /* !YYCOPY_NEEDED */ 487 488 /* YYFINAL -- State number of the termination state. */ 489 #define YYFINAL 32 490 /* YYLAST -- Last index in YYTABLE. */ 491 #define YYLAST 226 492 493 /* YYNTOKENS -- Number of terminals. */ 494 #define YYNTOKENS 40 495 /* YYNNTS -- Number of nonterminals. */ 496 #define YYNNTS 23 497 /* YYNRULES -- Number of rules. */ 498 #define YYNRULES 66 499 /* YYNRULES -- Number of states. */ 500 #define YYNSTATES 159 501 502 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 503 #define YYUNDEFTOK 2 504 #define YYMAXUTOK 284 505 506 #define YYTRANSLATE(YYX) \ 507 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 508 509 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 510 static const yytype_uint8 yytranslate[] = 511 { 512 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 513 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 514 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 515 2, 2, 2, 2, 2, 2, 2, 2, 29, 2, 516 33, 34, 31, 2, 39, 2, 2, 2, 2, 2, 517 2, 2, 2, 2, 2, 2, 2, 2, 2, 35, 518 2, 38, 2, 2, 2, 2, 2, 2, 2, 2, 519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 520 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 521 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 522 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 523 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 524 2, 2, 2, 36, 28, 37, 2, 2, 2, 2, 525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 526 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 527 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 528 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 529 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 530 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 534 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 535 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 536 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 537 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 538 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 539 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 540 25, 26, 27, 30, 32 541 }; 542 543 #if YYDEBUG 544 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 545 YYRHS. */ 546 static const yytype_uint8 yyprhs[] = 547 { 548 0, 0, 3, 5, 8, 11, 13, 19, 25, 31, 549 37, 43, 49, 54, 59, 64, 69, 74, 77, 79, 550 82, 87, 90, 94, 101, 104, 106, 108, 113, 116, 551 122, 124, 129, 134, 135, 140, 144, 148, 152, 156, 552 160, 164, 166, 168, 170, 172, 176, 178, 180, 181, 553 186, 191, 193, 196, 198, 203, 209, 216, 219, 221, 554 224, 227, 231, 234, 236, 238, 240 555 }; 556 557 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 558 static const yytype_int8 yyrhs[] = 559 { 560 41, 0, -1, 42, -1, 27, 56, -1, 42, 43, 561 -1, 43, -1, 6, 33, 11, 34, 35, -1, 22, 562 33, 61, 34, 35, -1, 20, 33, 18, 34, 35, 563 -1, 13, 33, 61, 34, 35, -1, 23, 16, 36, 564 44, 37, -1, 23, 1, 36, 44, 37, -1, 10, 565 33, 53, 34, -1, 12, 33, 53, 34, -1, 5, 566 33, 53, 34, -1, 26, 36, 56, 37, -1, 19, 567 33, 61, 34, -1, 44, 45, -1, 45, -1, 46, 568 35, -1, 11, 36, 47, 37, -1, 11, 35, -1, 569 11, 38, 52, -1, 21, 33, 11, 38, 52, 34, 570 -1, 47, 48, -1, 48, -1, 49, -1, 14, 33, 571 49, 34, -1, 46, 35, -1, 62, 33, 51, 50, 572 34, -1, 11, -1, 25, 33, 11, 34, -1, 7, 573 33, 61, 34, -1, -1, 4, 33, 52, 34, -1, 574 33, 52, 34, -1, 52, 31, 52, -1, 52, 17, 575 52, -1, 52, 3, 52, -1, 52, 29, 52, -1, 576 52, 28, 52, -1, 18, -1, 11, -1, 24, -1, 577 20, -1, 53, 54, 55, -1, 55, -1, 39, -1, 578 -1, 10, 33, 53, 34, -1, 5, 33, 53, 34, 579 -1, 61, -1, 56, 57, -1, 57, -1, 36, 58, 580 37, 35, -1, 61, 36, 58, 37, 35, -1, 61, 581 36, 58, 37, 61, 35, -1, 58, 59, -1, 59, 582 -1, 9, 60, -1, 15, 60, -1, 60, 62, 35, 583 -1, 62, 35, -1, 8, -1, 11, -1, 61, -1, 584 31, -1 585 }; 586 587 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 588 static const yytype_uint16 yyrline[] = 589 { 590 0, 143, 143, 144, 148, 149, 152, 157, 161, 166, 591 172, 176, 182, 193, 195, 197, 199, 203, 208, 212, 592 217, 229, 253, 255, 259, 264, 268, 273, 280, 287, 593 298, 300, 304, 307, 310, 315, 317, 323, 329, 335, 594 341, 347, 352, 357, 359, 363, 368, 372, 373, 376, 595 387, 389, 394, 399, 403, 409, 415, 424, 426, 430, 596 432, 437, 443, 447, 449, 453, 455 597 }; 598 #endif 599 600 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 601 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 602 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 603 static const char *const yytname[] = 604 { 605 "$end", "error", "$undefined", "kADD_OP", "kALIGN", "kAS_NEEDED", 606 "kENTRY", "kEXCLUDE_FILE", "kFILENAME", "kGLOBAL", "kGROUP", "kID", 607 "kINPUT", "kINTERP", "kKEEP", "kLOCAL", "kMODE", "kMUL_OP", "kNUM", 608 "kOUTPUT_FORMAT", "kPAGESIZE", "kPROVIDE", "kSEARCH_DIR", "kSEGMENT", 609 "kSIZEOF_HEADERS", "kSORT", "kVERSION", "kVERSION_SCRIPT", "'|'", "'&'", 610 "ADD_OP", "'*'", "MUL_OP", "'('", "')'", "';'", "'{'", "'}'", "'='", 611 "','", "$accept", "script_or_version", "file", "content", 612 "outputsections", "outputsection", "assignment", "inputsections", 613 "inputsection", "sectionname", "sort_opt_name", "exclude_opt", "expr", 614 "filename_id_list", "comma_opt", "filename_id_listelem", "versionlist", 615 "version", "version_stmt_list", "version_stmt", "filename_id_star_list", 616 "filename_id", "filename_id_star", 0 617 }; 618 #endif 619 620 # ifdef YYPRINT 621 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 622 token YYLEX-NUM. */ 623 static const yytype_uint16 yytoknum[] = 624 { 625 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 626 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 627 275, 276, 277, 278, 279, 280, 281, 282, 124, 38, 628 283, 42, 284, 40, 41, 59, 123, 125, 61, 44 629 }; 630 # endif 631 632 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 633 static const yytype_uint8 yyr1[] = 634 { 635 0, 40, 41, 41, 42, 42, 43, 43, 43, 43, 636 43, 43, 43, 43, 43, 43, 43, 44, 44, 45, 637 45, 45, 46, 46, 47, 47, 48, 48, 48, 49, 638 50, 50, 51, 51, 52, 52, 52, 52, 52, 52, 639 52, 52, 52, 52, 52, 53, 53, 54, 54, 55, 640 55, 55, 56, 56, 57, 57, 57, 58, 58, 59, 641 59, 60, 60, 61, 61, 62, 62 642 }; 643 644 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 645 static const yytype_uint8 yyr2[] = 646 { 647 0, 2, 1, 2, 2, 1, 5, 5, 5, 5, 648 5, 5, 4, 4, 4, 4, 4, 2, 1, 2, 649 4, 2, 3, 6, 2, 1, 1, 4, 2, 5, 650 1, 4, 4, 0, 4, 3, 3, 3, 3, 3, 651 3, 1, 1, 1, 1, 3, 1, 1, 0, 4, 652 4, 1, 2, 1, 4, 5, 6, 2, 1, 2, 653 2, 3, 2, 1, 1, 1, 1 654 }; 655 656 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 657 Performed when YYTABLE doesn't specify something else to do. Zero 658 means the default is an error. */ 659 static const yytype_uint8 yydefact[] = 660 { 661 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 662 0, 0, 0, 2, 5, 0, 0, 0, 0, 0, 663 0, 0, 0, 0, 0, 0, 63, 64, 0, 3, 664 53, 0, 1, 4, 0, 0, 48, 46, 51, 0, 665 48, 48, 0, 0, 0, 0, 0, 0, 0, 0, 666 0, 0, 58, 52, 0, 0, 0, 14, 47, 0, 667 0, 12, 13, 0, 16, 0, 0, 0, 0, 0, 668 18, 0, 0, 15, 66, 59, 65, 0, 60, 0, 669 57, 0, 48, 48, 45, 6, 9, 8, 7, 21, 670 0, 0, 0, 11, 17, 19, 10, 0, 62, 54, 671 0, 50, 49, 64, 0, 0, 0, 25, 26, 0, 672 0, 42, 41, 44, 43, 0, 22, 0, 61, 55, 673 0, 0, 28, 20, 24, 33, 0, 0, 0, 0, 674 0, 0, 0, 0, 56, 0, 0, 0, 0, 35, 675 38, 37, 40, 39, 36, 0, 27, 0, 30, 0, 676 0, 34, 23, 0, 0, 29, 32, 0, 31 677 }; 678 679 /* YYDEFGOTO[NTERM-NUM]. */ 680 static const yytype_int16 yydefgoto[] = 681 { 682 -1, 12, 13, 14, 69, 70, 71, 106, 107, 108, 683 150, 137, 116, 36, 59, 37, 29, 30, 51, 52, 684 75, 76, 109 685 }; 686 687 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 688 STATE-NUM. */ 689 #define YYPACT_NINF -86 690 static const yytype_int16 yypact[] = 691 { 692 111, -18, -14, 23, 45, 70, 75, 85, 92, 97, 693 91, 19, 128, 134, -86, 162, 96, 162, 162, 5, 694 5, 123, 5, 93, 99, 19, -86, -86, 117, 19, 695 -86, 115, -86, -86, 125, 144, 71, -86, -86, 145, 696 116, 135, 147, 148, 149, 150, 101, 101, 14, 83, 697 83, 55, -86, -86, 117, 162, 162, -86, -86, 162, 698 133, -86, -86, 143, -86, 151, 152, 107, 155, 63, 699 -86, 154, 74, -86, -86, 83, -86, 156, 83, 157, 700 -86, 56, 137, 141, -86, -86, -86, -86, -86, -86, 701 88, 48, 174, -86, -86, -86, -86, 158, -86, -86, 702 69, -86, -86, 159, 161, 160, 12, -86, -86, 163, 703 165, -86, -86, -86, -86, 48, 59, 164, -86, -86, 704 166, 83, -86, -86, -86, 183, 48, 0, 48, 48, 705 48, 48, 48, 48, -86, 169, 167, 90, 7, -86, 706 59, 59, 44, 66, 103, 29, -86, 5, -86, 171, 707 172, -86, -86, 173, 188, -86, -86, 175, -86 708 }; 709 710 /* YYPGOTO[NTERM-NUM]. */ 711 static const yytype_int16 yypgoto[] = 712 { 713 -86, -86, -86, 192, 168, 80, -85, -86, 102, 89, 714 -86, -86, 33, -16, -86, 153, 186, 38, 170, -39, 715 176, -11, 4 716 }; 717 718 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 719 positive, shift that token. If negative, reduce the rule which 720 number is the opposite. If YYTABLE_NINF, syntax error. */ 721 #define YYTABLE_NINF -1 722 static const yytype_uint8 yytable[] = 723 { 724 31, 40, 41, 128, 38, 105, 38, 38, 42, 43, 725 128, 45, 80, 26, 31, 15, 27, 129, 31, 16, 726 26, 105, 26, 103, 129, 27, 104, 26, 130, 131, 727 27, 132, 128, 68, 139, 130, 131, 31, 132, 82, 728 83, 151, 80, 74, 38, 38, 129, 128, 38, 123, 729 28, 73, 110, 77, 77, 28, 17, 130, 131, 111, 730 132, 129, 128, 152, 49, 49, 112, 53, 113, 128, 731 50, 50, 114, 131, 67, 132, 129, 26, 18, 97, 732 27, 115, 97, 129, 68, 67, 53, 130, 131, 120, 733 132, 26, 79, 100, 27, 68, 26, 132, 23, 103, 734 93, 148, 104, 19, 119, 57, 128, 39, 20, 68, 735 58, 96, 67, 24, 74, 149, 1, 2, 21, 74, 736 129, 3, 68, 4, 5, 22, 49, 25, 32, 46, 737 6, 7, 50, 8, 9, 47, 153, 10, 11, 1, 738 2, 44, 89, 90, 3, 91, 4, 5, 127, 94, 739 61, 54, 94, 6, 7, 58, 8, 9, 55, 138, 740 10, 140, 141, 142, 143, 144, 145, 34, 85, 62, 741 26, 101, 35, 27, 58, 102, 58, 56, 86, 60, 742 58, 63, 64, 65, 66, 117, 87, 88, 92, 95, 743 136, 98, 99, 118, 121, 122, 125, 91, 126, 157, 744 147, 134, 133, 146, 154, 33, 155, 156, 124, 158, 745 135, 48, 84, 0, 0, 72, 0, 0, 0, 0, 746 0, 0, 0, 0, 81, 0, 78 747 }; 748 749 #define yypact_value_is_default(yystate) \ 750 ((yystate) == (-86)) 751 752 #define yytable_value_is_error(yytable_value) \ 753 YYID (0) 754 755 static const yytype_int16 yycheck[] = 756 { 757 11, 17, 18, 3, 15, 90, 17, 18, 19, 20, 758 3, 22, 51, 8, 25, 33, 11, 17, 29, 33, 759 8, 106, 8, 11, 17, 11, 14, 8, 28, 29, 760 11, 31, 3, 21, 34, 28, 29, 48, 31, 55, 761 56, 34, 81, 31, 55, 56, 17, 3, 59, 37, 762 36, 37, 4, 49, 50, 36, 33, 28, 29, 11, 763 31, 17, 3, 34, 9, 9, 18, 29, 20, 3, 764 15, 15, 24, 29, 11, 31, 17, 8, 33, 75, 765 11, 33, 78, 17, 21, 11, 48, 28, 29, 100, 766 31, 8, 37, 37, 11, 21, 8, 31, 1, 11, 767 37, 11, 14, 33, 35, 34, 3, 11, 33, 21, 768 39, 37, 11, 16, 31, 25, 5, 6, 33, 31, 769 17, 10, 21, 12, 13, 33, 9, 36, 0, 36, 770 19, 20, 15, 22, 23, 36, 147, 26, 27, 5, 771 6, 18, 35, 36, 10, 38, 12, 13, 115, 69, 772 34, 36, 72, 19, 20, 39, 22, 23, 33, 126, 773 26, 128, 129, 130, 131, 132, 133, 5, 35, 34, 774 8, 34, 10, 11, 39, 34, 39, 33, 35, 34, 775 39, 34, 34, 34, 34, 11, 35, 35, 33, 35, 776 7, 35, 35, 35, 33, 35, 33, 38, 33, 11, 777 33, 35, 38, 34, 33, 13, 34, 34, 106, 34, 778 121, 25, 59, -1, -1, 47, -1, -1, -1, -1, 779 -1, -1, -1, -1, 54, -1, 50 780 }; 781 782 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 783 symbol of state STATE-NUM. */ 784 static const yytype_uint8 yystos[] = 785 { 786 0, 5, 6, 10, 12, 13, 19, 20, 22, 23, 787 26, 27, 41, 42, 43, 33, 33, 33, 33, 33, 788 33, 33, 33, 1, 16, 36, 8, 11, 36, 56, 789 57, 61, 0, 43, 5, 10, 53, 55, 61, 11, 790 53, 53, 61, 61, 18, 61, 36, 36, 56, 9, 791 15, 58, 59, 57, 36, 33, 33, 34, 39, 54, 792 34, 34, 34, 34, 34, 34, 34, 11, 21, 44, 793 45, 46, 44, 37, 31, 60, 61, 62, 60, 37, 794 59, 58, 53, 53, 55, 35, 35, 35, 35, 35, 795 36, 38, 33, 37, 45, 35, 37, 62, 35, 35, 796 37, 34, 34, 11, 14, 46, 47, 48, 49, 62, 797 4, 11, 18, 20, 24, 33, 52, 11, 35, 35, 798 61, 33, 35, 37, 48, 33, 33, 52, 3, 17, 799 28, 29, 31, 38, 35, 49, 7, 51, 52, 34, 800 52, 52, 52, 52, 52, 52, 34, 33, 11, 25, 801 50, 34, 34, 61, 33, 34, 34, 11, 34 802 }; 803 804 #define yyerrok (yyerrstatus = 0) 805 #define yyclearin (yychar = YYEMPTY) 806 #define YYEMPTY (-2) 807 #define YYEOF 0 808 809 #define YYACCEPT goto yyacceptlab 810 #define YYABORT goto yyabortlab 811 #define YYERROR goto yyerrorlab 812 813 814 /* Like YYERROR except do call yyerror. This remains here temporarily 815 to ease the transition to the new meaning of YYERROR, for GCC. 816 Once GCC version 2 has supplanted version 1, this can go. However, 817 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 818 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 819 discussed. */ 820 821 #define YYFAIL goto yyerrlab 822 #if defined YYFAIL 823 /* This is here to suppress warnings from the GCC cpp's 824 -Wunused-macros. Normally we don't worry about that warning, but 825 some users do, and we want to make it easy for users to remove 826 YYFAIL uses, which will produce warnings from Bison 2.5. */ 827 #endif 828 829 #define YYRECOVERING() (!!yyerrstatus) 830 831 #define YYBACKUP(Token, Value) \ 832 do \ 833 if (yychar == YYEMPTY && yylen == 1) \ 834 { \ 835 yychar = (Token); \ 836 yylval = (Value); \ 837 YYPOPSTACK (1); \ 838 goto yybackup; \ 839 } \ 840 else \ 841 { \ 842 yyerror (YY_("syntax error: cannot back up")); \ 843 YYERROR; \ 844 } \ 845 while (YYID (0)) 846 847 848 #define YYTERROR 1 849 #define YYERRCODE 256 850 851 852 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 853 If N is 0, then set CURRENT to the empty location which ends 854 the previous symbol: RHS[0] (always defined). */ 855 856 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 857 #ifndef YYLLOC_DEFAULT 858 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 859 do \ 860 if (YYID (N)) \ 861 { \ 862 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 863 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 864 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 865 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 866 } \ 867 else \ 868 { \ 869 (Current).first_line = (Current).last_line = \ 870 YYRHSLOC (Rhs, 0).last_line; \ 871 (Current).first_column = (Current).last_column = \ 872 YYRHSLOC (Rhs, 0).last_column; \ 873 } \ 874 while (YYID (0)) 875 #endif 876 877 878 /* This macro is provided for backward compatibility. */ 879 880 #ifndef YY_LOCATION_PRINT 881 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 882 #endif 883 884 885 /* YYLEX -- calling `yylex' with the right arguments. */ 886 887 #ifdef YYLEX_PARAM 888 # define YYLEX yylex (YYLEX_PARAM) 889 #else 890 # define YYLEX yylex () 891 #endif 892 893 /* Enable debugging if requested. */ 894 #if YYDEBUG 895 896 # ifndef YYFPRINTF 897 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 898 # define YYFPRINTF fprintf 899 # endif 900 901 # define YYDPRINTF(Args) \ 902 do { \ 903 if (yydebug) \ 904 YYFPRINTF Args; \ 905 } while (YYID (0)) 906 907 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 908 do { \ 909 if (yydebug) \ 910 { \ 911 YYFPRINTF (stderr, "%s ", Title); \ 912 yy_symbol_print (stderr, \ 913 Type, Value); \ 914 YYFPRINTF (stderr, "\n"); \ 915 } \ 916 } while (YYID (0)) 917 918 919 /*--------------------------------. 920 | Print this symbol on YYOUTPUT. | 921 `--------------------------------*/ 922 923 /*ARGSUSED*/ 924 #if (defined __STDC__ || defined __C99__FUNC__ \ 925 || defined __cplusplus || defined _MSC_VER) 926 static void 927 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 928 #else 929 static void 930 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 931 FILE *yyoutput; 932 int yytype; 933 YYSTYPE const * const yyvaluep; 934 #endif 935 { 936 if (!yyvaluep) 937 return; 938 # ifdef YYPRINT 939 if (yytype < YYNTOKENS) 940 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 941 # else 942 YYUSE (yyoutput); 943 # endif 944 switch (yytype) 945 { 946 default: 947 break; 948 } 949 } 950 951 952 /*--------------------------------. 953 | Print this symbol on YYOUTPUT. | 954 `--------------------------------*/ 955 956 #if (defined __STDC__ || defined __C99__FUNC__ \ 957 || defined __cplusplus || defined _MSC_VER) 958 static void 959 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 960 #else 961 static void 962 yy_symbol_print (yyoutput, yytype, yyvaluep) 963 FILE *yyoutput; 964 int yytype; 965 YYSTYPE const * const yyvaluep; 966 #endif 967 { 968 if (yytype < YYNTOKENS) 969 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 970 else 971 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 972 973 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 974 YYFPRINTF (yyoutput, ")"); 975 } 976 977 /*------------------------------------------------------------------. 978 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 979 | TOP (included). | 980 `------------------------------------------------------------------*/ 981 982 #if (defined __STDC__ || defined __C99__FUNC__ \ 983 || defined __cplusplus || defined _MSC_VER) 984 static void 985 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 986 #else 987 static void 988 yy_stack_print (yybottom, yytop) 989 yytype_int16 *yybottom; 990 yytype_int16 *yytop; 991 #endif 992 { 993 YYFPRINTF (stderr, "Stack now"); 994 for (; yybottom <= yytop; yybottom++) 995 { 996 int yybot = *yybottom; 997 YYFPRINTF (stderr, " %d", yybot); 998 } 999 YYFPRINTF (stderr, "\n"); 1000 } 1001 1002 # define YY_STACK_PRINT(Bottom, Top) \ 1003 do { \ 1004 if (yydebug) \ 1005 yy_stack_print ((Bottom), (Top)); \ 1006 } while (YYID (0)) 1007 1008 1009 /*------------------------------------------------. 1010 | Report that the YYRULE is going to be reduced. | 1011 `------------------------------------------------*/ 1012 1013 #if (defined __STDC__ || defined __C99__FUNC__ \ 1014 || defined __cplusplus || defined _MSC_VER) 1015 static void 1016 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1017 #else 1018 static void 1019 yy_reduce_print (yyvsp, yyrule) 1020 YYSTYPE *yyvsp; 1021 int yyrule; 1022 #endif 1023 { 1024 int yynrhs = yyr2[yyrule]; 1025 int yyi; 1026 unsigned long int yylno = yyrline[yyrule]; 1027 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1028 yyrule - 1, yylno); 1029 /* The symbols being reduced. */ 1030 for (yyi = 0; yyi < yynrhs; yyi++) 1031 { 1032 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1033 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1034 &(yyvsp[(yyi + 1) - (yynrhs)]) 1035 ); 1036 YYFPRINTF (stderr, "\n"); 1037 } 1038 } 1039 1040 # define YY_REDUCE_PRINT(Rule) \ 1041 do { \ 1042 if (yydebug) \ 1043 yy_reduce_print (yyvsp, Rule); \ 1044 } while (YYID (0)) 1045 1046 /* Nonzero means print parse trace. It is left uninitialized so that 1047 multiple parsers can coexist. */ 1048 int yydebug; 1049 #else /* !YYDEBUG */ 1050 # define YYDPRINTF(Args) 1051 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1052 # define YY_STACK_PRINT(Bottom, Top) 1053 # define YY_REDUCE_PRINT(Rule) 1054 #endif /* !YYDEBUG */ 1055 1056 1057 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1058 #ifndef YYINITDEPTH 1059 # define YYINITDEPTH 200 1060 #endif 1061 1062 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1063 if the built-in stack extension method is used). 1064 1065 Do not make this value too large; the results are undefined if 1066 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1067 evaluated with infinite-precision integer arithmetic. */ 1068 1069 #ifndef YYMAXDEPTH 1070 # define YYMAXDEPTH 10000 1071 #endif 1072 1073 1074 #if YYERROR_VERBOSE 1075 1076 # ifndef yystrlen 1077 # if defined __GLIBC__ && defined _STRING_H 1078 # define yystrlen strlen 1079 # else 1080 /* Return the length of YYSTR. */ 1081 #if (defined __STDC__ || defined __C99__FUNC__ \ 1082 || defined __cplusplus || defined _MSC_VER) 1083 static YYSIZE_T 1084 yystrlen (const char *yystr) 1085 #else 1086 static YYSIZE_T 1087 yystrlen (yystr) 1088 const char *yystr; 1089 #endif 1090 { 1091 YYSIZE_T yylen; 1092 for (yylen = 0; yystr[yylen]; yylen++) 1093 continue; 1094 return yylen; 1095 } 1096 # endif 1097 # endif 1098 1099 # ifndef yystpcpy 1100 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1101 # define yystpcpy stpcpy 1102 # else 1103 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1104 YYDEST. */ 1105 #if (defined __STDC__ || defined __C99__FUNC__ \ 1106 || defined __cplusplus || defined _MSC_VER) 1107 static char * 1108 yystpcpy (char *yydest, const char *yysrc) 1109 #else 1110 static char * 1111 yystpcpy (yydest, yysrc) 1112 char *yydest; 1113 const char *yysrc; 1114 #endif 1115 { 1116 char *yyd = yydest; 1117 const char *yys = yysrc; 1118 1119 while ((*yyd++ = *yys++) != '\0') 1120 continue; 1121 1122 return yyd - 1; 1123 } 1124 # endif 1125 # endif 1126 1127 # ifndef yytnamerr 1128 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1129 quotes and backslashes, so that it's suitable for yyerror. The 1130 heuristic is that double-quoting is unnecessary unless the string 1131 contains an apostrophe, a comma, or backslash (other than 1132 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1133 null, do not copy; instead, return the length of what the result 1134 would have been. */ 1135 static YYSIZE_T 1136 yytnamerr (char *yyres, const char *yystr) 1137 { 1138 if (*yystr == '"') 1139 { 1140 YYSIZE_T yyn = 0; 1141 char const *yyp = yystr; 1142 1143 for (;;) 1144 switch (*++yyp) 1145 { 1146 case '\'': 1147 case ',': 1148 goto do_not_strip_quotes; 1149 1150 case '\\': 1151 if (*++yyp != '\\') 1152 goto do_not_strip_quotes; 1153 /* Fall through. */ 1154 default: 1155 if (yyres) 1156 yyres[yyn] = *yyp; 1157 yyn++; 1158 break; 1159 1160 case '"': 1161 if (yyres) 1162 yyres[yyn] = '\0'; 1163 return yyn; 1164 } 1165 do_not_strip_quotes: ; 1166 } 1167 1168 if (! yyres) 1169 return yystrlen (yystr); 1170 1171 return yystpcpy (yyres, yystr) - yyres; 1172 } 1173 # endif 1174 1175 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1176 about the unexpected token YYTOKEN for the state stack whose top is 1177 YYSSP. 1178 1179 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1180 not large enough to hold the message. In that case, also set 1181 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1182 required number of bytes is too large to store. */ 1183 static int 1184 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1185 yytype_int16 *yyssp, int yytoken) 1186 { 1187 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); 1188 YYSIZE_T yysize = yysize0; 1189 YYSIZE_T yysize1; 1190 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1191 /* Internationalized format string. */ 1192 const char *yyformat = 0; 1193 /* Arguments of yyformat. */ 1194 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1195 /* Number of reported tokens (one for the "unexpected", one per 1196 "expected"). */ 1197 int yycount = 0; 1198 1199 /* There are many possibilities here to consider: 1200 - Assume YYFAIL is not used. It's too flawed to consider. See 1201 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 1202 for details. YYERROR is fine as it does not invoke this 1203 function. 1204 - If this state is a consistent state with a default action, then 1205 the only way this function was invoked is if the default action 1206 is an error action. In that case, don't check for expected 1207 tokens because there are none. 1208 - The only way there can be no lookahead present (in yychar) is if 1209 this state is a consistent state with a default action. Thus, 1210 detecting the absence of a lookahead is sufficient to determine 1211 that there is no unexpected or expected token to report. In that 1212 case, just report a simple "syntax error". 1213 - Don't assume there isn't a lookahead just because this state is a 1214 consistent state with a default action. There might have been a 1215 previous inconsistent state, consistent state with a non-default 1216 action, or user semantic action that manipulated yychar. 1217 - Of course, the expected token list depends on states to have 1218 correct lookahead information, and it depends on the parser not 1219 to perform extra reductions after fetching a lookahead from the 1220 scanner and before detecting a syntax error. Thus, state merging 1221 (from LALR or IELR) and default reductions corrupt the expected 1222 token list. However, the list is correct for canonical LR with 1223 one exception: it will still contain any token that will not be 1224 accepted due to an error action in a later state. 1225 */ 1226 if (yytoken != YYEMPTY) 1227 { 1228 int yyn = yypact[*yyssp]; 1229 yyarg[yycount++] = yytname[yytoken]; 1230 if (!yypact_value_is_default (yyn)) 1231 { 1232 /* Start YYX at -YYN if negative to avoid negative indexes in 1233 YYCHECK. In other words, skip the first -YYN actions for 1234 this state because they are default actions. */ 1235 int yyxbegin = yyn < 0 ? -yyn : 0; 1236 /* Stay within bounds of both yycheck and yytname. */ 1237 int yychecklim = YYLAST - yyn + 1; 1238 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1239 int yyx; 1240 1241 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1242 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1243 && !yytable_value_is_error (yytable[yyx + yyn])) 1244 { 1245 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1246 { 1247 yycount = 1; 1248 yysize = yysize0; 1249 break; 1250 } 1251 yyarg[yycount++] = yytname[yyx]; 1252 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1253 if (! (yysize <= yysize1 1254 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1255 return 2; 1256 yysize = yysize1; 1257 } 1258 } 1259 } 1260 1261 switch (yycount) 1262 { 1263 # define YYCASE_(N, S) \ 1264 case N: \ 1265 yyformat = S; \ 1266 break 1267 YYCASE_(0, YY_("syntax error")); 1268 YYCASE_(1, YY_("syntax error, unexpected %s")); 1269 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1270 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1271 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1272 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1273 # undef YYCASE_ 1274 } 1275 1276 yysize1 = yysize + yystrlen (yyformat); 1277 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1278 return 2; 1279 yysize = yysize1; 1280 1281 if (*yymsg_alloc < yysize) 1282 { 1283 *yymsg_alloc = 2 * yysize; 1284 if (! (yysize <= *yymsg_alloc 1285 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1286 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1287 return 1; 1288 } 1289 1290 /* Avoid sprintf, as that infringes on the user's name space. 1291 Don't have undefined behavior even if the translation 1292 produced a string with the wrong number of "%s"s. */ 1293 { 1294 char *yyp = *yymsg; 1295 int yyi = 0; 1296 while ((*yyp = *yyformat) != '\0') 1297 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1298 { 1299 yyp += yytnamerr (yyp, yyarg[yyi++]); 1300 yyformat += 2; 1301 } 1302 else 1303 { 1304 yyp++; 1305 yyformat++; 1306 } 1307 } 1308 return 0; 1309 } 1310 #endif /* YYERROR_VERBOSE */ 1311 1312 /*-----------------------------------------------. 1313 | Release the memory associated to this symbol. | 1314 `-----------------------------------------------*/ 1315 1316 /*ARGSUSED*/ 1317 #if (defined __STDC__ || defined __C99__FUNC__ \ 1318 || defined __cplusplus || defined _MSC_VER) 1319 static void 1320 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1321 #else 1322 static void 1323 yydestruct (yymsg, yytype, yyvaluep) 1324 const char *yymsg; 1325 int yytype; 1326 YYSTYPE *yyvaluep; 1327 #endif 1328 { 1329 YYUSE (yyvaluep); 1330 1331 if (!yymsg) 1332 yymsg = "Deleting"; 1333 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1334 1335 switch (yytype) 1336 { 1337 1338 default: 1339 break; 1340 } 1341 } 1342 1343 1344 /* Prevent warnings from -Wmissing-prototypes. */ 1345 #ifdef YYPARSE_PARAM 1346 #if defined __STDC__ || defined __cplusplus 1347 int yyparse (void *YYPARSE_PARAM); 1348 #else 1349 int yyparse (); 1350 #endif 1351 #else /* ! YYPARSE_PARAM */ 1352 #if defined __STDC__ || defined __cplusplus 1353 int yyparse (void); 1354 #else 1355 int yyparse (); 1356 #endif 1357 #endif /* ! YYPARSE_PARAM */ 1358 1359 1360 /* The lookahead symbol. */ 1361 int yychar; 1362 1363 /* The semantic value of the lookahead symbol. */ 1364 YYSTYPE yylval; 1365 1366 /* Number of syntax errors so far. */ 1367 int yynerrs; 1368 1369 1370 /*----------. 1371 | yyparse. | 1372 `----------*/ 1373 1374 #ifdef YYPARSE_PARAM 1375 #if (defined __STDC__ || defined __C99__FUNC__ \ 1376 || defined __cplusplus || defined _MSC_VER) 1377 int 1378 yyparse (void *YYPARSE_PARAM) 1379 #else 1380 int 1381 yyparse (YYPARSE_PARAM) 1382 void *YYPARSE_PARAM; 1383 #endif 1384 #else /* ! YYPARSE_PARAM */ 1385 #if (defined __STDC__ || defined __C99__FUNC__ \ 1386 || defined __cplusplus || defined _MSC_VER) 1387 int 1388 yyparse (void) 1389 #else 1390 int 1391 yyparse () 1392 1393 #endif 1394 #endif 1395 { 1396 int yystate; 1397 /* Number of tokens to shift before error messages enabled. */ 1398 int yyerrstatus; 1399 1400 /* The stacks and their tools: 1401 `yyss': related to states. 1402 `yyvs': related to semantic values. 1403 1404 Refer to the stacks thru separate pointers, to allow yyoverflow 1405 to reallocate them elsewhere. */ 1406 1407 /* The state stack. */ 1408 yytype_int16 yyssa[YYINITDEPTH]; 1409 yytype_int16 *yyss; 1410 yytype_int16 *yyssp; 1411 1412 /* The semantic value stack. */ 1413 YYSTYPE yyvsa[YYINITDEPTH]; 1414 YYSTYPE *yyvs; 1415 YYSTYPE *yyvsp; 1416 1417 YYSIZE_T yystacksize; 1418 1419 int yyn; 1420 int yyresult; 1421 /* Lookahead token as an internal (translated) token number. */ 1422 int yytoken; 1423 /* The variables used to return semantic value and location from the 1424 action routines. */ 1425 YYSTYPE yyval; 1426 1427 #if YYERROR_VERBOSE 1428 /* Buffer for error messages, and its allocated size. */ 1429 char yymsgbuf[128]; 1430 char *yymsg = yymsgbuf; 1431 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1432 #endif 1433 1434 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1435 1436 /* The number of symbols on the RHS of the reduced rule. 1437 Keep to zero when no symbol should be popped. */ 1438 int yylen = 0; 1439 1440 yytoken = 0; 1441 yyss = yyssa; 1442 yyvs = yyvsa; 1443 yystacksize = YYINITDEPTH; 1444 1445 YYDPRINTF ((stderr, "Starting parse\n")); 1446 1447 yystate = 0; 1448 yyerrstatus = 0; 1449 yynerrs = 0; 1450 yychar = YYEMPTY; /* Cause a token to be read. */ 1451 1452 /* Initialize stack pointers. 1453 Waste one element of value and location stack 1454 so that they stay on the same level as the state stack. 1455 The wasted elements are never initialized. */ 1456 yyssp = yyss; 1457 yyvsp = yyvs; 1458 1459 goto yysetstate; 1460 1461 /*------------------------------------------------------------. 1462 | yynewstate -- Push a new state, which is found in yystate. | 1463 `------------------------------------------------------------*/ 1464 yynewstate: 1465 /* In all cases, when you get here, the value and location stacks 1466 have just been pushed. So pushing a state here evens the stacks. */ 1467 yyssp++; 1468 1469 yysetstate: 1470 *yyssp = yystate; 1471 1472 if (yyss + yystacksize - 1 <= yyssp) 1473 { 1474 /* Get the current used size of the three stacks, in elements. */ 1475 YYSIZE_T yysize = yyssp - yyss + 1; 1476 1477 #ifdef yyoverflow 1478 { 1479 /* Give user a chance to reallocate the stack. Use copies of 1480 these so that the &'s don't force the real ones into 1481 memory. */ 1482 YYSTYPE *yyvs1 = yyvs; 1483 yytype_int16 *yyss1 = yyss; 1484 1485 /* Each stack pointer address is followed by the size of the 1486 data in use in that stack, in bytes. This used to be a 1487 conditional around just the two extra args, but that might 1488 be undefined if yyoverflow is a macro. */ 1489 yyoverflow (YY_("memory exhausted"), 1490 &yyss1, yysize * sizeof (*yyssp), 1491 &yyvs1, yysize * sizeof (*yyvsp), 1492 &yystacksize); 1493 1494 yyss = yyss1; 1495 yyvs = yyvs1; 1496 } 1497 #else /* no yyoverflow */ 1498 # ifndef YYSTACK_RELOCATE 1499 goto yyexhaustedlab; 1500 # else 1501 /* Extend the stack our own way. */ 1502 if (YYMAXDEPTH <= yystacksize) 1503 goto yyexhaustedlab; 1504 yystacksize *= 2; 1505 if (YYMAXDEPTH < yystacksize) 1506 yystacksize = YYMAXDEPTH; 1507 1508 { 1509 yytype_int16 *yyss1 = yyss; 1510 union yyalloc *yyptr = 1511 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1512 if (! yyptr) 1513 goto yyexhaustedlab; 1514 YYSTACK_RELOCATE (yyss_alloc, yyss); 1515 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1516 # undef YYSTACK_RELOCATE 1517 if (yyss1 != yyssa) 1518 YYSTACK_FREE (yyss1); 1519 } 1520 # endif 1521 #endif /* no yyoverflow */ 1522 1523 yyssp = yyss + yysize - 1; 1524 yyvsp = yyvs + yysize - 1; 1525 1526 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1527 (unsigned long int) yystacksize)); 1528 1529 if (yyss + yystacksize - 1 <= yyssp) 1530 YYABORT; 1531 } 1532 1533 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1534 1535 if (yystate == YYFINAL) 1536 YYACCEPT; 1537 1538 goto yybackup; 1539 1540 /*-----------. 1541 | yybackup. | 1542 `-----------*/ 1543 yybackup: 1544 1545 /* Do appropriate processing given the current state. Read a 1546 lookahead token if we need one and don't already have one. */ 1547 1548 /* First try to decide what to do without reference to lookahead token. */ 1549 yyn = yypact[yystate]; 1550 if (yypact_value_is_default (yyn)) 1551 goto yydefault; 1552 1553 /* Not known => get a lookahead token if don't already have one. */ 1554 1555 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1556 if (yychar == YYEMPTY) 1557 { 1558 YYDPRINTF ((stderr, "Reading a token: ")); 1559 yychar = YYLEX; 1560 } 1561 1562 if (yychar <= YYEOF) 1563 { 1564 yychar = yytoken = YYEOF; 1565 YYDPRINTF ((stderr, "Now at end of input.\n")); 1566 } 1567 else 1568 { 1569 yytoken = YYTRANSLATE (yychar); 1570 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1571 } 1572 1573 /* If the proper action on seeing token YYTOKEN is to reduce or to 1574 detect an error, take that action. */ 1575 yyn += yytoken; 1576 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1577 goto yydefault; 1578 yyn = yytable[yyn]; 1579 if (yyn <= 0) 1580 { 1581 if (yytable_value_is_error (yyn)) 1582 goto yyerrlab; 1583 yyn = -yyn; 1584 goto yyreduce; 1585 } 1586 1587 /* Count tokens shifted since error; after three, turn off error 1588 status. */ 1589 if (yyerrstatus) 1590 yyerrstatus--; 1591 1592 /* Shift the lookahead token. */ 1593 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1594 1595 /* Discard the shifted token. */ 1596 yychar = YYEMPTY; 1597 1598 yystate = yyn; 1599 *++yyvsp = yylval; 1600 1601 goto yynewstate; 1602 1603 1604 /*-----------------------------------------------------------. 1605 | yydefault -- do the default action for the current state. | 1606 `-----------------------------------------------------------*/ 1607 yydefault: 1608 yyn = yydefact[yystate]; 1609 if (yyn == 0) 1610 goto yyerrlab; 1611 goto yyreduce; 1612 1613 1614 /*-----------------------------. 1615 | yyreduce -- Do a reduction. | 1616 `-----------------------------*/ 1617 yyreduce: 1618 /* yyn is the number of a rule to reduce with. */ 1619 yylen = yyr2[yyn]; 1620 1621 /* If YYLEN is nonzero, implement the default value of the action: 1622 `$$ = $1'. 1623 1624 Otherwise, the following line sets YYVAL to garbage. 1625 This behavior is undocumented and Bison 1626 users should not rely upon it. Assigning to YYVAL 1627 unconditionally makes the parser a bit smaller, and it avoids a 1628 GCC warning that YYVAL may be used uninitialized. */ 1629 yyval = yyvsp[1-yylen]; 1630 1631 1632 YY_REDUCE_PRINT (yyn); 1633 switch (yyn) 1634 { 1635 case 3: 1636 1637 /* Line 1806 of yacc.c */ 1638 #line 145 "ldscript.y" 1639 { add_versions ((yyvsp[(2) - (2)].version)); } 1640 break; 1641 1642 case 6: 1643 1644 /* Line 1806 of yacc.c */ 1645 #line 153 "ldscript.y" 1646 { 1647 if (likely (ld_state.entry == NULL)) 1648 ld_state.entry = (yyvsp[(3) - (5)].str); 1649 } 1650 break; 1651 1652 case 7: 1653 1654 /* Line 1806 of yacc.c */ 1655 #line 158 "ldscript.y" 1656 { 1657 ld_new_searchdir ((yyvsp[(3) - (5)].str)); 1658 } 1659 break; 1660 1661 case 8: 1662 1663 /* Line 1806 of yacc.c */ 1664 #line 162 "ldscript.y" 1665 { 1666 if (likely (ld_state.pagesize == 0)) 1667 ld_state.pagesize = (yyvsp[(3) - (5)].num); 1668 } 1669 break; 1670 1671 case 9: 1672 1673 /* Line 1806 of yacc.c */ 1674 #line 167 "ldscript.y" 1675 { 1676 if (likely (ld_state.interp == NULL) 1677 && ld_state.file_type != dso_file_type) 1678 ld_state.interp = (yyvsp[(3) - (5)].str); 1679 } 1680 break; 1681 1682 case 10: 1683 1684 /* Line 1806 of yacc.c */ 1685 #line 173 "ldscript.y" 1686 { 1687 new_segment ((yyvsp[(2) - (5)].num), (yyvsp[(4) - (5)].output_rule)); 1688 } 1689 break; 1690 1691 case 11: 1692 1693 /* Line 1806 of yacc.c */ 1694 #line 177 "ldscript.y" 1695 { 1696 fputs_unlocked (gettext ("mode for segment invalid\n"), 1697 stderr); 1698 new_segment (0, (yyvsp[(4) - (5)].output_rule)); 1699 } 1700 break; 1701 1702 case 12: 1703 1704 /* Line 1806 of yacc.c */ 1705 #line 183 "ldscript.y" 1706 { 1707 /* First little optimization. If there is only one 1708 file in the group don't do anything. */ 1709 if ((yyvsp[(3) - (4)].filename_list) != (yyvsp[(3) - (4)].filename_list)->next) 1710 { 1711 (yyvsp[(3) - (4)].filename_list)->next->group_start = 1; 1712 (yyvsp[(3) - (4)].filename_list)->group_end = 1; 1713 } 1714 add_inputfiles ((yyvsp[(3) - (4)].filename_list)); 1715 } 1716 break; 1717 1718 case 13: 1719 1720 /* Line 1806 of yacc.c */ 1721 #line 194 "ldscript.y" 1722 { add_inputfiles ((yyvsp[(3) - (4)].filename_list)); } 1723 break; 1724 1725 case 14: 1726 1727 /* Line 1806 of yacc.c */ 1728 #line 196 "ldscript.y" 1729 { add_inputfiles (mark_as_needed ((yyvsp[(3) - (4)].filename_list))); } 1730 break; 1731 1732 case 15: 1733 1734 /* Line 1806 of yacc.c */ 1735 #line 198 "ldscript.y" 1736 { add_versions ((yyvsp[(3) - (4)].version)); } 1737 break; 1738 1739 case 16: 1740 1741 /* Line 1806 of yacc.c */ 1742 #line 200 "ldscript.y" 1743 { /* XXX TODO */ } 1744 break; 1745 1746 case 17: 1747 1748 /* Line 1806 of yacc.c */ 1749 #line 204 "ldscript.y" 1750 { 1751 (yyvsp[(2) - (2)].output_rule)->next = (yyvsp[(1) - (2)].output_rule)->next; 1752 (yyval.output_rule) = (yyvsp[(1) - (2)].output_rule)->next = (yyvsp[(2) - (2)].output_rule); 1753 } 1754 break; 1755 1756 case 18: 1757 1758 /* Line 1806 of yacc.c */ 1759 #line 209 "ldscript.y" 1760 { (yyval.output_rule) = (yyvsp[(1) - (1)].output_rule); } 1761 break; 1762 1763 case 19: 1764 1765 /* Line 1806 of yacc.c */ 1766 #line 213 "ldscript.y" 1767 { 1768 (yyval.output_rule) = new_output_rule (output_assignment); 1769 (yyval.output_rule)->val.assignment = (yyvsp[(1) - (2)].assignment); 1770 } 1771 break; 1772 1773 case 20: 1774 1775 /* Line 1806 of yacc.c */ 1776 #line 218 "ldscript.y" 1777 { 1778 (yyval.output_rule) = new_output_rule (output_section); 1779 (yyval.output_rule)->val.section.name = (yyvsp[(1) - (4)].str); 1780 (yyval.output_rule)->val.section.input = (yyvsp[(3) - (4)].input_rule)->next; 1781 if (ld_state.strip == strip_debug 1782 && ebl_debugscn_p (ld_state.ebl, (yyvsp[(1) - (4)].str))) 1783 (yyval.output_rule)->val.section.ignored = true; 1784 else 1785 (yyval.output_rule)->val.section.ignored = false; 1786 (yyvsp[(3) - (4)].input_rule)->next = NULL; 1787 } 1788 break; 1789 1790 case 21: 1791 1792 /* Line 1806 of yacc.c */ 1793 #line 230 "ldscript.y" 1794 { 1795 /* This is a short cut for "ID { *(ID) }". */ 1796 (yyval.output_rule) = new_output_rule (output_section); 1797 (yyval.output_rule)->val.section.name = (yyvsp[(1) - (2)].str); 1798 (yyval.output_rule)->val.section.input = new_input_rule (input_section); 1799 (yyval.output_rule)->val.section.input->next = NULL; 1800 (yyval.output_rule)->val.section.input->val.section = 1801 (struct filemask_section_name *) 1802 obstack_alloc (&ld_state.smem, 1803 sizeof (struct filemask_section_name)); 1804 (yyval.output_rule)->val.section.input->val.section->filemask = NULL; 1805 (yyval.output_rule)->val.section.input->val.section->excludemask = NULL; 1806 (yyval.output_rule)->val.section.input->val.section->section_name = 1807 new_input_section_name ((yyvsp[(1) - (2)].str), false); 1808 (yyval.output_rule)->val.section.input->val.section->keep_flag = false; 1809 if (ld_state.strip == strip_debug 1810 && ebl_debugscn_p (ld_state.ebl, (yyvsp[(1) - (2)].str))) 1811 (yyval.output_rule)->val.section.ignored = true; 1812 else 1813 (yyval.output_rule)->val.section.ignored = false; 1814 } 1815 break; 1816 1817 case 22: 1818 1819 /* Line 1806 of yacc.c */ 1820 #line 254 "ldscript.y" 1821 { (yyval.assignment) = new_assignment ((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].expr), false); } 1822 break; 1823 1824 case 23: 1825 1826 /* Line 1806 of yacc.c */ 1827 #line 256 "ldscript.y" 1828 { (yyval.assignment) = new_assignment ((yyvsp[(3) - (6)].str), (yyvsp[(5) - (6)].expr), true); } 1829 break; 1830 1831 case 24: 1832 1833 /* Line 1806 of yacc.c */ 1834 #line 260 "ldscript.y" 1835 { 1836 (yyvsp[(2) - (2)].input_rule)->next = (yyvsp[(1) - (2)].input_rule)->next; 1837 (yyval.input_rule) = (yyvsp[(1) - (2)].input_rule)->next = (yyvsp[(2) - (2)].input_rule); 1838 } 1839 break; 1840 1841 case 25: 1842 1843 /* Line 1806 of yacc.c */ 1844 #line 265 "ldscript.y" 1845 { (yyval.input_rule) = (yyvsp[(1) - (1)].input_rule); } 1846 break; 1847 1848 case 26: 1849 1850 /* Line 1806 of yacc.c */ 1851 #line 269 "ldscript.y" 1852 { 1853 (yyval.input_rule) = new_input_rule (input_section); 1854 (yyval.input_rule)->val.section = (yyvsp[(1) - (1)].filemask_section_name); 1855 } 1856 break; 1857 1858 case 27: 1859 1860 /* Line 1806 of yacc.c */ 1861 #line 274 "ldscript.y" 1862 { 1863 (yyvsp[(3) - (4)].filemask_section_name)->keep_flag = true; 1864 1865 (yyval.input_rule) = new_input_rule (input_section); 1866 (yyval.input_rule)->val.section = (yyvsp[(3) - (4)].filemask_section_name); 1867 } 1868 break; 1869 1870 case 28: 1871 1872 /* Line 1806 of yacc.c */ 1873 #line 281 "ldscript.y" 1874 { 1875 (yyval.input_rule) = new_input_rule (input_assignment); 1876 (yyval.input_rule)->val.assignment = (yyvsp[(1) - (2)].assignment); 1877 } 1878 break; 1879 1880 case 29: 1881 1882 /* Line 1806 of yacc.c */ 1883 #line 288 "ldscript.y" 1884 { 1885 (yyval.filemask_section_name) = (struct filemask_section_name *) 1886 obstack_alloc (&ld_state.smem, sizeof (*(yyval.filemask_section_name))); 1887 (yyval.filemask_section_name)->filemask = (yyvsp[(1) - (5)].str); 1888 (yyval.filemask_section_name)->excludemask = (yyvsp[(3) - (5)].str); 1889 (yyval.filemask_section_name)->section_name = (yyvsp[(4) - (5)].sectionname); 1890 (yyval.filemask_section_name)->keep_flag = false; 1891 } 1892 break; 1893 1894 case 30: 1895 1896 /* Line 1806 of yacc.c */ 1897 #line 299 "ldscript.y" 1898 { (yyval.sectionname) = new_input_section_name ((yyvsp[(1) - (1)].str), false); } 1899 break; 1900 1901 case 31: 1902 1903 /* Line 1806 of yacc.c */ 1904 #line 301 "ldscript.y" 1905 { (yyval.sectionname) = new_input_section_name ((yyvsp[(3) - (4)].str), true); } 1906 break; 1907 1908 case 32: 1909 1910 /* Line 1806 of yacc.c */ 1911 #line 305 "ldscript.y" 1912 { (yyval.str) = (yyvsp[(3) - (4)].str); } 1913 break; 1914 1915 case 33: 1916 1917 /* Line 1806 of yacc.c */ 1918 #line 307 "ldscript.y" 1919 { (yyval.str) = NULL; } 1920 break; 1921 1922 case 34: 1923 1924 /* Line 1806 of yacc.c */ 1925 #line 311 "ldscript.y" 1926 { 1927 (yyval.expr) = new_expr (exp_align); 1928 (yyval.expr)->val.child = (yyvsp[(3) - (4)].expr); 1929 } 1930 break; 1931 1932 case 35: 1933 1934 /* Line 1806 of yacc.c */ 1935 #line 316 "ldscript.y" 1936 { (yyval.expr) = (yyvsp[(2) - (3)].expr); } 1937 break; 1938 1939 case 36: 1940 1941 /* Line 1806 of yacc.c */ 1942 #line 318 "ldscript.y" 1943 { 1944 (yyval.expr) = new_expr (exp_mult); 1945 (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr); 1946 (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr); 1947 } 1948 break; 1949 1950 case 37: 1951 1952 /* Line 1806 of yacc.c */ 1953 #line 324 "ldscript.y" 1954 { 1955 (yyval.expr) = new_expr ((yyvsp[(2) - (3)].op)); 1956 (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr); 1957 (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr); 1958 } 1959 break; 1960 1961 case 38: 1962 1963 /* Line 1806 of yacc.c */ 1964 #line 330 "ldscript.y" 1965 { 1966 (yyval.expr) = new_expr ((yyvsp[(2) - (3)].op)); 1967 (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr); 1968 (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr); 1969 } 1970 break; 1971 1972 case 39: 1973 1974 /* Line 1806 of yacc.c */ 1975 #line 336 "ldscript.y" 1976 { 1977 (yyval.expr) = new_expr (exp_and); 1978 (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr); 1979 (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr); 1980 } 1981 break; 1982 1983 case 40: 1984 1985 /* Line 1806 of yacc.c */ 1986 #line 342 "ldscript.y" 1987 { 1988 (yyval.expr) = new_expr (exp_or); 1989 (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr); 1990 (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr); 1991 } 1992 break; 1993 1994 case 41: 1995 1996 /* Line 1806 of yacc.c */ 1997 #line 348 "ldscript.y" 1998 { 1999 (yyval.expr) = new_expr (exp_num); 2000 (yyval.expr)->val.num = (yyvsp[(1) - (1)].num); 2001 } 2002 break; 2003 2004 case 42: 2005 2006 /* Line 1806 of yacc.c */ 2007 #line 353 "ldscript.y" 2008 { 2009 (yyval.expr) = new_expr (exp_id); 2010 (yyval.expr)->val.str = (yyvsp[(1) - (1)].str); 2011 } 2012 break; 2013 2014 case 43: 2015 2016 /* Line 1806 of yacc.c */ 2017 #line 358 "ldscript.y" 2018 { (yyval.expr) = new_expr (exp_sizeof_headers); } 2019 break; 2020 2021 case 44: 2022 2023 /* Line 1806 of yacc.c */ 2024 #line 360 "ldscript.y" 2025 { (yyval.expr) = new_expr (exp_pagesize); } 2026 break; 2027 2028 case 45: 2029 2030 /* Line 1806 of yacc.c */ 2031 #line 364 "ldscript.y" 2032 { 2033 (yyvsp[(3) - (3)].filename_list)->next = (yyvsp[(1) - (3)].filename_list)->next; 2034 (yyval.filename_list) = (yyvsp[(1) - (3)].filename_list)->next = (yyvsp[(3) - (3)].filename_list); 2035 } 2036 break; 2037 2038 case 46: 2039 2040 /* Line 1806 of yacc.c */ 2041 #line 369 "ldscript.y" 2042 { (yyval.filename_list) = (yyvsp[(1) - (1)].filename_list); } 2043 break; 2044 2045 case 49: 2046 2047 /* Line 1806 of yacc.c */ 2048 #line 377 "ldscript.y" 2049 { 2050 /* First little optimization. If there is only one 2051 file in the group don't do anything. */ 2052 if ((yyvsp[(3) - (4)].filename_list) != (yyvsp[(3) - (4)].filename_list)->next) 2053 { 2054 (yyvsp[(3) - (4)].filename_list)->next->group_start = 1; 2055 (yyvsp[(3) - (4)].filename_list)->group_end = 1; 2056 } 2057 (yyval.filename_list) = (yyvsp[(3) - (4)].filename_list); 2058 } 2059 break; 2060 2061 case 50: 2062 2063 /* Line 1806 of yacc.c */ 2064 #line 388 "ldscript.y" 2065 { (yyval.filename_list) = mark_as_needed ((yyvsp[(3) - (4)].filename_list)); } 2066 break; 2067 2068 case 51: 2069 2070 /* Line 1806 of yacc.c */ 2071 #line 390 "ldscript.y" 2072 { (yyval.filename_list) = new_filename_listelem ((yyvsp[(1) - (1)].str)); } 2073 break; 2074 2075 case 52: 2076 2077 /* Line 1806 of yacc.c */ 2078 #line 395 "ldscript.y" 2079 { 2080 (yyvsp[(2) - (2)].version)->next = (yyvsp[(1) - (2)].version)->next; 2081 (yyval.version) = (yyvsp[(1) - (2)].version)->next = (yyvsp[(2) - (2)].version); 2082 } 2083 break; 2084 2085 case 53: 2086 2087 /* Line 1806 of yacc.c */ 2088 #line 400 "ldscript.y" 2089 { (yyval.version) = (yyvsp[(1) - (1)].version); } 2090 break; 2091 2092 case 54: 2093 2094 /* Line 1806 of yacc.c */ 2095 #line 404 "ldscript.y" 2096 { 2097 (yyvsp[(2) - (4)].version)->versionname = ""; 2098 (yyvsp[(2) - (4)].version)->parentname = NULL; 2099 (yyval.version) = (yyvsp[(2) - (4)].version); 2100 } 2101 break; 2102 2103 case 55: 2104 2105 /* Line 1806 of yacc.c */ 2106 #line 410 "ldscript.y" 2107 { 2108 (yyvsp[(3) - (5)].version)->versionname = (yyvsp[(1) - (5)].str); 2109 (yyvsp[(3) - (5)].version)->parentname = NULL; 2110 (yyval.version) = (yyvsp[(3) - (5)].version); 2111 } 2112 break; 2113 2114 case 56: 2115 2116 /* Line 1806 of yacc.c */ 2117 #line 416 "ldscript.y" 2118 { 2119 (yyvsp[(3) - (6)].version)->versionname = (yyvsp[(1) - (6)].str); 2120 (yyvsp[(3) - (6)].version)->parentname = (yyvsp[(5) - (6)].str); 2121 (yyval.version) = (yyvsp[(3) - (6)].version); 2122 } 2123 break; 2124 2125 case 57: 2126 2127 /* Line 1806 of yacc.c */ 2128 #line 425 "ldscript.y" 2129 { (yyval.version) = merge_versions ((yyvsp[(1) - (2)].version), (yyvsp[(2) - (2)].version)); } 2130 break; 2131 2132 case 58: 2133 2134 /* Line 1806 of yacc.c */ 2135 #line 427 "ldscript.y" 2136 { (yyval.version) = (yyvsp[(1) - (1)].version); } 2137 break; 2138 2139 case 59: 2140 2141 /* Line 1806 of yacc.c */ 2142 #line 431 "ldscript.y" 2143 { (yyval.version) = new_version (NULL, (yyvsp[(2) - (2)].id_list)); } 2144 break; 2145 2146 case 60: 2147 2148 /* Line 1806 of yacc.c */ 2149 #line 433 "ldscript.y" 2150 { (yyval.version) = new_version ((yyvsp[(2) - (2)].id_list), NULL); } 2151 break; 2152 2153 case 61: 2154 2155 /* Line 1806 of yacc.c */ 2156 #line 438 "ldscript.y" 2157 { 2158 struct id_list *newp = new_id_listelem ((yyvsp[(2) - (3)].str)); 2159 newp->next = (yyvsp[(1) - (3)].id_list)->next; 2160 (yyval.id_list) = (yyvsp[(1) - (3)].id_list)->next = newp; 2161 } 2162 break; 2163 2164 case 62: 2165 2166 /* Line 1806 of yacc.c */ 2167 #line 444 "ldscript.y" 2168 { (yyval.id_list) = new_id_listelem ((yyvsp[(1) - (2)].str)); } 2169 break; 2170 2171 case 63: 2172 2173 /* Line 1806 of yacc.c */ 2174 #line 448 "ldscript.y" 2175 { (yyval.str) = (yyvsp[(1) - (1)].str); } 2176 break; 2177 2178 case 64: 2179 2180 /* Line 1806 of yacc.c */ 2181 #line 450 "ldscript.y" 2182 { (yyval.str) = (yyvsp[(1) - (1)].str); } 2183 break; 2184 2185 case 65: 2186 2187 /* Line 1806 of yacc.c */ 2188 #line 454 "ldscript.y" 2189 { (yyval.str) = (yyvsp[(1) - (1)].str); } 2190 break; 2191 2192 case 66: 2193 2194 /* Line 1806 of yacc.c */ 2195 #line 456 "ldscript.y" 2196 { (yyval.str) = NULL; } 2197 break; 2198 2199 2200 2201 /* Line 1806 of yacc.c */ 2202 #line 2203 "ldscript.c" 2203 default: break; 2204 } 2205 /* User semantic actions sometimes alter yychar, and that requires 2206 that yytoken be updated with the new translation. We take the 2207 approach of translating immediately before every use of yytoken. 2208 One alternative is translating here after every semantic action, 2209 but that translation would be missed if the semantic action invokes 2210 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2211 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2212 incorrect destructor might then be invoked immediately. In the 2213 case of YYERROR or YYBACKUP, subsequent parser actions might lead 2214 to an incorrect destructor call or verbose syntax error message 2215 before the lookahead is translated. */ 2216 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2217 2218 YYPOPSTACK (yylen); 2219 yylen = 0; 2220 YY_STACK_PRINT (yyss, yyssp); 2221 2222 *++yyvsp = yyval; 2223 2224 /* Now `shift' the result of the reduction. Determine what state 2225 that goes to, based on the state we popped back to and the rule 2226 number reduced by. */ 2227 2228 yyn = yyr1[yyn]; 2229 2230 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2231 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2232 yystate = yytable[yystate]; 2233 else 2234 yystate = yydefgoto[yyn - YYNTOKENS]; 2235 2236 goto yynewstate; 2237 2238 2239 /*------------------------------------. 2240 | yyerrlab -- here on detecting error | 2241 `------------------------------------*/ 2242 yyerrlab: 2243 /* Make sure we have latest lookahead translation. See comments at 2244 user semantic actions for why this is necessary. */ 2245 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 2246 2247 /* If not already recovering from an error, report this error. */ 2248 if (!yyerrstatus) 2249 { 2250 ++yynerrs; 2251 #if ! YYERROR_VERBOSE 2252 yyerror (YY_("syntax error")); 2253 #else 2254 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2255 yyssp, yytoken) 2256 { 2257 char const *yymsgp = YY_("syntax error"); 2258 int yysyntax_error_status; 2259 yysyntax_error_status = YYSYNTAX_ERROR; 2260 if (yysyntax_error_status == 0) 2261 yymsgp = yymsg; 2262 else if (yysyntax_error_status == 1) 2263 { 2264 if (yymsg != yymsgbuf) 2265 YYSTACK_FREE (yymsg); 2266 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 2267 if (!yymsg) 2268 { 2269 yymsg = yymsgbuf; 2270 yymsg_alloc = sizeof yymsgbuf; 2271 yysyntax_error_status = 2; 2272 } 2273 else 2274 { 2275 yysyntax_error_status = YYSYNTAX_ERROR; 2276 yymsgp = yymsg; 2277 } 2278 } 2279 yyerror (yymsgp); 2280 if (yysyntax_error_status == 2) 2281 goto yyexhaustedlab; 2282 } 2283 # undef YYSYNTAX_ERROR 2284 #endif 2285 } 2286 2287 2288 2289 if (yyerrstatus == 3) 2290 { 2291 /* If just tried and failed to reuse lookahead token after an 2292 error, discard it. */ 2293 2294 if (yychar <= YYEOF) 2295 { 2296 /* Return failure if at end of input. */ 2297 if (yychar == YYEOF) 2298 YYABORT; 2299 } 2300 else 2301 { 2302 yydestruct ("Error: discarding", 2303 yytoken, &yylval); 2304 yychar = YYEMPTY; 2305 } 2306 } 2307 2308 /* Else will try to reuse lookahead token after shifting the error 2309 token. */ 2310 goto yyerrlab1; 2311 2312 2313 /*---------------------------------------------------. 2314 | yyerrorlab -- error raised explicitly by YYERROR. | 2315 `---------------------------------------------------*/ 2316 yyerrorlab: 2317 2318 /* Pacify compilers like GCC when the user code never invokes 2319 YYERROR and the label yyerrorlab therefore never appears in user 2320 code. */ 2321 if (/*CONSTCOND*/ 0) 2322 goto yyerrorlab; 2323 2324 /* Do not reclaim the symbols of the rule which action triggered 2325 this YYERROR. */ 2326 YYPOPSTACK (yylen); 2327 yylen = 0; 2328 YY_STACK_PRINT (yyss, yyssp); 2329 yystate = *yyssp; 2330 goto yyerrlab1; 2331 2332 2333 /*-------------------------------------------------------------. 2334 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2335 `-------------------------------------------------------------*/ 2336 yyerrlab1: 2337 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2338 2339 for (;;) 2340 { 2341 yyn = yypact[yystate]; 2342 if (!yypact_value_is_default (yyn)) 2343 { 2344 yyn += YYTERROR; 2345 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2346 { 2347 yyn = yytable[yyn]; 2348 if (0 < yyn) 2349 break; 2350 } 2351 } 2352 2353 /* Pop the current state because it cannot handle the error token. */ 2354 if (yyssp == yyss) 2355 YYABORT; 2356 2357 2358 yydestruct ("Error: popping", 2359 yystos[yystate], yyvsp); 2360 YYPOPSTACK (1); 2361 yystate = *yyssp; 2362 YY_STACK_PRINT (yyss, yyssp); 2363 } 2364 2365 *++yyvsp = yylval; 2366 2367 2368 /* Shift the error token. */ 2369 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2370 2371 yystate = yyn; 2372 goto yynewstate; 2373 2374 2375 /*-------------------------------------. 2376 | yyacceptlab -- YYACCEPT comes here. | 2377 `-------------------------------------*/ 2378 yyacceptlab: 2379 yyresult = 0; 2380 goto yyreturn; 2381 2382 /*-----------------------------------. 2383 | yyabortlab -- YYABORT comes here. | 2384 `-----------------------------------*/ 2385 yyabortlab: 2386 yyresult = 1; 2387 goto yyreturn; 2388 2389 #if !defined(yyoverflow) || YYERROR_VERBOSE 2390 /*-------------------------------------------------. 2391 | yyexhaustedlab -- memory exhaustion comes here. | 2392 `-------------------------------------------------*/ 2393 yyexhaustedlab: 2394 yyerror (YY_("memory exhausted")); 2395 yyresult = 2; 2396 /* Fall through. */ 2397 #endif 2398 2399 yyreturn: 2400 if (yychar != YYEMPTY) 2401 { 2402 /* Make sure we have latest lookahead translation. See comments at 2403 user semantic actions for why this is necessary. */ 2404 yytoken = YYTRANSLATE (yychar); 2405 yydestruct ("Cleanup: discarding lookahead", 2406 yytoken, &yylval); 2407 } 2408 /* Do not reclaim the symbols of the rule which action triggered 2409 this YYABORT or YYACCEPT. */ 2410 YYPOPSTACK (yylen); 2411 YY_STACK_PRINT (yyss, yyssp); 2412 while (yyssp != yyss) 2413 { 2414 yydestruct ("Cleanup: popping", 2415 yystos[*yyssp], yyvsp); 2416 YYPOPSTACK (1); 2417 } 2418 #ifndef yyoverflow 2419 if (yyss != yyssa) 2420 YYSTACK_FREE (yyss); 2421 #endif 2422 #if YYERROR_VERBOSE 2423 if (yymsg != yymsgbuf) 2424 YYSTACK_FREE (yymsg); 2425 #endif 2426 /* Make sure YYID is used. */ 2427 return YYID (yyresult); 2428 } 2429 2430 2431 2432 /* Line 2067 of yacc.c */ 2433 #line 459 "ldscript.y" 2434 2435 2436 static void 2437 yyerror (const char *s) 2438 { 2439 error (0, 0, (ld_scan_version_script 2440 ? gettext ("while reading version script '%s': %s at line %d") 2441 : gettext ("while reading linker script '%s': %s at line %d")), 2442 ldin_fname, gettext (s), ldlineno); 2443 } 2444 2445 2446 static struct expression * 2447 new_expr (int tag) 2448 { 2449 struct expression *newp = (struct expression *) 2450 obstack_alloc (&ld_state.smem, sizeof (*newp)); 2451 2452 newp->tag = tag; 2453 return newp; 2454 } 2455 2456 2457 static struct input_section_name * 2458 new_input_section_name (const char *name, bool sort_flag) 2459 { 2460 struct input_section_name *newp = (struct input_section_name *) 2461 obstack_alloc (&ld_state.smem, sizeof (*newp)); 2462 2463 newp->name = name; 2464 newp->sort_flag = sort_flag; 2465 return newp; 2466 } 2467 2468 2469 static struct input_rule * 2470 new_input_rule (int tag) 2471 { 2472 struct input_rule *newp = (struct input_rule *) 2473 obstack_alloc (&ld_state.smem, sizeof (*newp)); 2474 2475 newp->tag = tag; 2476 newp->next = newp; 2477 return newp; 2478 } 2479 2480 2481 static struct output_rule * 2482 new_output_rule (int tag) 2483 { 2484 struct output_rule *newp = (struct output_rule *) 2485 memset (obstack_alloc (&ld_state.smem, sizeof (*newp)), 2486 '\0', sizeof (*newp)); 2487 2488 newp->tag = tag; 2489 newp->next = newp; 2490 return newp; 2491 } 2492 2493 2494 static struct assignment * 2495 new_assignment (const char *variable, struct expression *expression, 2496 bool provide_flag) 2497 { 2498 struct assignment *newp = (struct assignment *) 2499 obstack_alloc (&ld_state.smem, sizeof (*newp)); 2500 2501 newp->variable = variable; 2502 newp->expression = expression; 2503 newp->sym = NULL; 2504 newp->provide_flag = provide_flag; 2505 2506 /* Insert the symbol into a hash table. We will later have to matc*/ 2507 return newp; 2508 } 2509 2510 2511 static void 2512 new_segment (int mode, struct output_rule *output_rule) 2513 { 2514 struct output_segment *newp; 2515 2516 newp 2517 = (struct output_segment *) obstack_alloc (&ld_state.smem, sizeof (*newp)); 2518 newp->mode = mode; 2519 newp->next = newp; 2520 2521 newp->output_rules = output_rule->next; 2522 output_rule->next = NULL; 2523 2524 /* Enqueue the output segment description. */ 2525 if (ld_state.output_segments == NULL) 2526 ld_state.output_segments = newp; 2527 else 2528 { 2529 newp->next = ld_state.output_segments->next; 2530 ld_state.output_segments = ld_state.output_segments->next = newp; 2531 } 2532 2533 /* If the output file should be stripped of all symbol set the flag 2534 in the structures of all output sections. */ 2535 if (mode == 0 && ld_state.strip == strip_all) 2536 { 2537 struct output_rule *runp; 2538 2539 for (runp = newp->output_rules; runp != NULL; runp = runp->next) 2540 if (runp->tag == output_section) 2541 runp->val.section.ignored = true; 2542 } 2543 } 2544 2545 2546 static struct filename_list * 2547 new_filename_listelem (const char *string) 2548 { 2549 struct filename_list *newp; 2550 2551 /* We use calloc and not the obstack since this object can be freed soon. */ 2552 newp = (struct filename_list *) xcalloc (1, sizeof (*newp)); 2553 newp->name = string; 2554 newp->next = newp; 2555 return newp; 2556 } 2557 2558 2559 static struct filename_list * 2560 mark_as_needed (struct filename_list *listp) 2561 { 2562 struct filename_list *runp = listp; 2563 do 2564 { 2565 runp->as_needed = true; 2566 runp = runp->next; 2567 } 2568 while (runp != listp); 2569 2570 return listp; 2571 } 2572 2573 2574 static void 2575 add_inputfiles (struct filename_list *fnames) 2576 { 2577 assert (fnames != NULL); 2578 2579 if (ld_state.srcfiles == NULL) 2580 ld_state.srcfiles = fnames; 2581 else 2582 { 2583 struct filename_list *first = ld_state.srcfiles->next; 2584 2585 ld_state.srcfiles->next = fnames->next; 2586 fnames->next = first; 2587 ld_state.srcfiles->next = fnames; 2588 } 2589 } 2590 2591 2592 static _Bool 2593 special_char_p (const char *str) 2594 { 2595 while (*str != '\0') 2596 { 2597 if (__builtin_expect (*str == '*', 0) 2598 || __builtin_expect (*str == '?', 0) 2599 || __builtin_expect (*str == '[', 0)) 2600 return true; 2601 2602 ++str; 2603 } 2604 2605 return false; 2606 } 2607 2608 2609 static struct id_list * 2610 new_id_listelem (const char *str) 2611 { 2612 struct id_list *newp; 2613 2614 newp = (struct id_list *) obstack_alloc (&ld_state.smem, sizeof (*newp)); 2615 if (str == NULL) 2616 newp->u.id_type = id_all; 2617 else if (__builtin_expect (special_char_p (str), false)) 2618 newp->u.id_type = id_wild; 2619 else 2620 newp->u.id_type = id_str; 2621 newp->id = str; 2622 newp->next = newp; 2623 2624 return newp; 2625 } 2626 2627 2628 static struct version * 2629 new_version (struct id_list *local, struct id_list *global) 2630 { 2631 struct version *newp; 2632 2633 newp = (struct version *) obstack_alloc (&ld_state.smem, sizeof (*newp)); 2634 newp->next = newp; 2635 newp->local_names = local; 2636 newp->global_names = global; 2637 newp->versionname = NULL; 2638 newp->parentname = NULL; 2639 2640 return newp; 2641 } 2642 2643 2644 static struct version * 2645 merge_versions (struct version *one, struct version *two) 2646 { 2647 assert (two->local_names == NULL || two->global_names == NULL); 2648 2649 if (two->local_names != NULL) 2650 { 2651 if (one->local_names == NULL) 2652 one->local_names = two->local_names; 2653 else 2654 { 2655 two->local_names->next = one->local_names->next; 2656 one->local_names = one->local_names->next = two->local_names; 2657 } 2658 } 2659 else 2660 { 2661 if (one->global_names == NULL) 2662 one->global_names = two->global_names; 2663 else 2664 { 2665 two->global_names->next = one->global_names->next; 2666 one->global_names = one->global_names->next = two->global_names; 2667 } 2668 } 2669 2670 return one; 2671 } 2672 2673 2674 static void 2675 add_id_list (const char *versionname, struct id_list *runp, _Bool local) 2676 { 2677 struct id_list *lastp = runp; 2678 2679 if (runp == NULL) 2680 /* Nothing to do. */ 2681 return; 2682 2683 /* Convert into a simple single-linked list. */ 2684 runp = runp->next; 2685 assert (runp != NULL); 2686 lastp->next = NULL; 2687 2688 do 2689 if (runp->u.id_type == id_str) 2690 { 2691 struct id_list *curp; 2692 struct id_list *defp; 2693 unsigned long int hval = elf_hash (runp->id); 2694 2695 curp = runp; 2696 runp = runp->next; 2697 2698 defp = ld_version_str_tab_find (&ld_state.version_str_tab, hval, curp); 2699 if (defp != NULL) 2700 { 2701 /* There is already a version definition for this symbol. */ 2702 while (strcmp (defp->u.s.versionname, versionname) != 0) 2703 { 2704 if (defp->next == NULL) 2705 { 2706 /* No version like this so far. */ 2707 defp->next = curp; 2708 curp->u.s.local = local; 2709 curp->u.s.versionname = versionname; 2710 curp->next = NULL; 2711 defp = NULL; 2712 break; 2713 } 2714 2715 defp = defp->next; 2716 } 2717 2718 if (defp != NULL && defp->u.s.local != local) 2719 error (EXIT_FAILURE, 0, versionname[0] == '\0' 2720 ? gettext ("\ 2721 symbol '%s' is declared both local and global for unnamed version") 2722 : gettext ("\ 2723 symbol '%s' is declared both local and global for version '%s'"), 2724 runp->id, versionname); 2725 } 2726 else 2727 { 2728 /* This is the first version definition for this symbol. */ 2729 ld_version_str_tab_insert (&ld_state.version_str_tab, hval, curp); 2730 2731 curp->u.s.local = local; 2732 curp->u.s.versionname = versionname; 2733 curp->next = NULL; 2734 } 2735 } 2736 else if (runp->u.id_type == id_all) 2737 { 2738 if (local) 2739 { 2740 if (ld_state.default_bind_global) 2741 error (EXIT_FAILURE, 0, 2742 gettext ("default visibility set as local and global")); 2743 ld_state.default_bind_local = true; 2744 } 2745 else 2746 { 2747 if (ld_state.default_bind_local) 2748 error (EXIT_FAILURE, 0, 2749 gettext ("default visibility set as local and global")); 2750 ld_state.default_bind_global = true; 2751 } 2752 2753 runp = runp->next; 2754 } 2755 else 2756 { 2757 assert (runp->u.id_type == id_wild); 2758 /* XXX TBI */ 2759 abort (); 2760 } 2761 while (runp != NULL); 2762 } 2763 2764 2765 static void 2766 add_versions (struct version *versions) 2767 { 2768 struct version *lastp = versions; 2769 2770 if (versions == NULL) 2771 return; 2772 2773 /* Convert into a simple single-linked list. */ 2774 versions = versions->next; 2775 assert (versions != NULL); 2776 lastp->next = NULL; 2777 2778 do 2779 { 2780 add_id_list (versions->versionname, versions->local_names, true); 2781 add_id_list (versions->versionname, versions->global_names, false); 2782 2783 versions = versions->next; 2784 } 2785 while (versions != NULL); 2786 } 2787 2788
