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@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
YYID(int yyi)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
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)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
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)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
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)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
yy_reduce_print(YYSTYPE * yyvsp,int yyrule)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
yystrlen(const char * yystr)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 *
yystpcpy(char * yydest,const char * yysrc)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
yytnamerr(char * yyres,const char * yystr)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
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)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
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)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
yyparse(void * YYPARSE_PARAM)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
yyerror(const char * s)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 *
new_expr(int tag)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 *
new_input_section_name(const char * name,bool sort_flag)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 *
new_input_rule(int tag)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 *
new_output_rule(int tag)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 *
new_assignment(const char * variable,struct expression * expression,bool provide_flag)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
new_segment(int mode,struct output_rule * output_rule)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 *
new_filename_listelem(const char * string)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 *
mark_as_needed(struct filename_list * listp)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
add_inputfiles(struct filename_list * fnames)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
special_char_p(const char * str)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 *
new_id_listelem(const char * str)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 *
new_version(struct id_list * local,struct id_list * global)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 *
merge_versions(struct version * one,struct version * two)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
add_id_list(const char * versionname,struct id_list * runp,_Bool local)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
add_versions(struct version * versions)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