1 %{ /* deffilep.y - parser for .def files */ 2 3 /* Copyright (C) 1995-2020 Free Software Foundation, Inc. 4 5 This file is part of GNU Binutils. 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, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include "libiberty.h" 24 #include "safe-ctype.h" 25 #include "bfd.h" 26 #include "bfdlink.h" 27 #include "ld.h" 28 #include "ldmisc.h" 29 #include "deffile.h" 30 31 #define TRACE 0 32 33 #define ROUND_UP(a, b) (((a)+((b)-1))&~((b)-1)) 34 35 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 36 as well as gratuitiously global symbol names, so we can have multiple 37 yacc generated parsers in ld. Note that these are only the variables 38 produced by yacc. If other parser generators (bison, byacc, etc) produce 39 additional global names that conflict at link time, then those parser 40 generators need to be fixed instead of adding those names to this list. */ 41 42 #define yymaxdepth def_maxdepth 43 #define yyparse def_parse 44 #define yylex def_lex 45 #define yyerror def_error 46 #define yylval def_lval 47 #define yychar def_char 48 #define yydebug def_debug 49 #define yypact def_pact 50 #define yyr1 def_r1 51 #define yyr2 def_r2 52 #define yydef def_def 53 #define yychk def_chk 54 #define yypgo def_pgo 55 #define yyact def_act 56 #define yyexca def_exca 57 #define yyerrflag def_errflag 58 #define yynerrs def_nerrs 59 #define yyps def_ps 60 #define yypv def_pv 61 #define yys def_s 62 #define yy_yys def_yys 63 #define yystate def_state 64 #define yytmp def_tmp 65 #define yyv def_v 66 #define yy_yyv def_yyv 67 #define yyval def_val 68 #define yylloc def_lloc 69 #define yyreds def_reds /* With YYDEBUG defined. */ 70 #define yytoks def_toks /* With YYDEBUG defined. */ 71 #define yylhs def_yylhs 72 #define yylen def_yylen 73 #define yydefred def_yydefred 74 #define yydgoto def_yydgoto 75 #define yysindex def_yysindex 76 #define yyrindex def_yyrindex 77 #define yygindex def_yygindex 78 #define yytable def_yytable 79 #define yycheck def_yycheck 80 81 typedef struct def_pool_str { 82 struct def_pool_str *next; 83 char data[1]; 84 } def_pool_str; 85 86 static def_pool_str *pool_strs = NULL; 87 88 static char *def_pool_alloc (size_t sz); 89 static char *def_pool_strdup (const char *str); 90 static void def_pool_free (void); 91 92 static void def_description (const char *); 93 static void def_exports (const char *, const char *, int, int, const char *); 94 static void def_heapsize (int, int); 95 static void def_import (const char *, const char *, const char *, const char *, 96 int, const char *); 97 static void def_image_name (const char *, bfd_vma, int); 98 static void def_section (const char *, int); 99 static void def_section_alt (const char *, const char *); 100 static void def_stacksize (int, int); 101 static void def_version (int, int); 102 static void def_directive (char *); 103 static void def_aligncomm (char *str, int align); 104 static int def_parse (void); 105 static int def_error (const char *); 106 static int def_lex (void); 107 108 static int lex_forced_token = 0; 109 static const char *lex_parse_string = 0; 110 static const char *lex_parse_string_end = 0; 111 112 %} 113 114 %union { 115 char *id; 116 const char *id_const; 117 int number; 118 bfd_vma vma; 119 char *digits; 120 }; 121 122 %token NAME LIBRARY DESCRIPTION STACKSIZE_K HEAPSIZE CODE DATAU DATAL 123 %token SECTIONS EXPORTS IMPORTS VERSIONK BASE CONSTANTU CONSTANTL 124 %token PRIVATEU PRIVATEL ALIGNCOMM 125 %token READ WRITE EXECUTE SHARED NONAMEU NONAMEL DIRECTIVE EQUAL 126 %token <id> ID 127 %token <digits> DIGITS 128 %type <number> NUMBER 129 %type <vma> VMA opt_base 130 %type <digits> opt_digits 131 %type <number> opt_ordinal 132 %type <number> attr attr_list opt_number exp_opt_list exp_opt 133 %type <id> opt_name opt_name2 opt_equal_name anylang_id opt_id 134 %type <id> opt_equalequal_name 135 %type <id_const> keyword_as_name 136 137 %% 138 139 start: start command 140 | command 141 ; 142 143 command: 144 NAME opt_name opt_base { def_image_name ($2, $3, 0); } 145 | LIBRARY opt_name opt_base { def_image_name ($2, $3, 1); } 146 | DESCRIPTION ID { def_description ($2);} 147 | STACKSIZE_K NUMBER opt_number { def_stacksize ($2, $3);} 148 | HEAPSIZE NUMBER opt_number { def_heapsize ($2, $3);} 149 | CODE attr_list { def_section ("CODE", $2);} 150 | DATAU attr_list { def_section ("DATA", $2);} 151 | SECTIONS seclist 152 | EXPORTS explist 153 | IMPORTS implist 154 | VERSIONK NUMBER { def_version ($2, 0);} 155 | VERSIONK NUMBER '.' NUMBER { def_version ($2, $4);} 156 | DIRECTIVE ID { def_directive ($2);} 157 | ALIGNCOMM anylang_id ',' NUMBER { def_aligncomm ($2, $4);} 158 ; 159 160 161 explist: 162 /* EMPTY */ 163 | expline 164 | explist expline 165 ; 166 167 expline: 168 /* The opt_comma is necessary to support both the usual 169 DEF file syntax as well as .drectve syntax which 170 mandates <expsym>,<expoptlist>. */ 171 opt_name2 opt_equal_name opt_ordinal opt_comma exp_opt_list opt_comma opt_equalequal_name 172 { def_exports ($1, $2, $3, $5, $7); } 173 ; 174 exp_opt_list: 175 /* The opt_comma is necessary to support both the usual 176 DEF file syntax as well as .drectve syntax which 177 allows for comma separated opt list. */ 178 exp_opt opt_comma exp_opt_list { $$ = $1 | $3; } 179 | { $$ = 0; } 180 ; 181 exp_opt: 182 NONAMEU { $$ = 1; } 183 | NONAMEL { $$ = 1; } 184 | CONSTANTU { $$ = 2; } 185 | CONSTANTL { $$ = 2; } 186 | DATAU { $$ = 4; } 187 | DATAL { $$ = 4; } 188 | PRIVATEU { $$ = 8; } 189 | PRIVATEL { $$ = 8; } 190 ; 191 implist: 192 implist impline 193 | impline 194 ; 195 196 impline: 197 ID '=' ID '.' ID '.' ID opt_equalequal_name 198 { def_import ($1, $3, $5, $7, -1, $8); } 199 | ID '=' ID '.' ID '.' NUMBER opt_equalequal_name 200 { def_import ($1, $3, $5, 0, $7, $8); } 201 | ID '=' ID '.' ID opt_equalequal_name 202 { def_import ($1, $3, 0, $5, -1, $6); } 203 | ID '=' ID '.' NUMBER opt_equalequal_name 204 { def_import ($1, $3, 0, 0, $5, $6); } 205 | ID '.' ID '.' ID opt_equalequal_name 206 { def_import( 0, $1, $3, $5, -1, $6); } 207 | ID '.' ID opt_equalequal_name 208 { def_import ( 0, $1, 0, $3, -1, $4); } 209 ; 210 211 seclist: 212 seclist secline 213 | secline 214 ; 215 216 secline: 217 ID attr_list { def_section ($1, $2);} 218 | ID ID { def_section_alt ($1, $2);} 219 ; 220 221 attr_list: 222 attr_list opt_comma attr { $$ = $1 | $3; } 223 | attr { $$ = $1; } 224 ; 225 226 opt_comma: 227 ',' 228 | 229 ; 230 opt_number: ',' NUMBER { $$=$2;} 231 | { $$=-1;} 232 ; 233 234 attr: 235 READ { $$ = 1;} 236 | WRITE { $$ = 2;} 237 | EXECUTE { $$=4;} 238 | SHARED { $$=8;} 239 ; 240 241 242 keyword_as_name: BASE { $$ = "BASE"; } 243 | CODE { $$ = "CODE"; } 244 | CONSTANTU { $$ = "CONSTANT"; } 245 | CONSTANTL { $$ = "constant"; } 246 | DATAU { $$ = "DATA"; } 247 | DATAL { $$ = "data"; } 248 | DESCRIPTION { $$ = "DESCRIPTION"; } 249 | DIRECTIVE { $$ = "DIRECTIVE"; } 250 | EXECUTE { $$ = "EXECUTE"; } 251 | EXPORTS { $$ = "EXPORTS"; } 252 | HEAPSIZE { $$ = "HEAPSIZE"; } 253 | IMPORTS { $$ = "IMPORTS"; } 254 /* Disable LIBRARY keyword as valid symbol-name. This is necessary 255 for libtool, which places this command after EXPORTS command. 256 This behavior is illegal by specification, but sadly required by 257 by compatibility reasons. 258 See PR binutils/13710 259 | LIBRARY { $$ = "LIBRARY"; } */ 260 | NAME { $$ = "NAME"; } 261 | NONAMEU { $$ = "NONAME"; } 262 | NONAMEL { $$ = "noname"; } 263 | PRIVATEU { $$ = "PRIVATE"; } 264 | PRIVATEL { $$ = "private"; } 265 | READ { $$ = "READ"; } 266 | SHARED { $$ = "SHARED"; } 267 | STACKSIZE_K { $$ = "STACKSIZE"; } 268 | VERSIONK { $$ = "VERSION"; } 269 | WRITE { $$ = "WRITE"; } 270 ; 271 272 opt_name2: ID { $$ = $1; } 273 | '.' keyword_as_name 274 { 275 char *name = xmalloc (strlen ($2) + 2); 276 sprintf (name, ".%s", $2); 277 $$ = name; 278 } 279 | '.' opt_name2 280 { 281 char *name = def_pool_alloc (strlen ($2) + 2); 282 sprintf (name, ".%s", $2); 283 $$ = name; 284 } 285 | keyword_as_name '.' opt_name2 286 { 287 char *name = def_pool_alloc (strlen ($1) + 1 + strlen ($3) + 1); 288 sprintf (name, "%s.%s", $1, $3); 289 $$ = name; 290 } 291 | ID '.' opt_name2 292 { 293 char *name = def_pool_alloc (strlen ($1) + 1 + strlen ($3) + 1); 294 sprintf (name, "%s.%s", $1, $3); 295 $$ = name; 296 } 297 ; 298 299 opt_name: opt_name2 { $$ = $1; } 300 | { $$ = ""; } 301 ; 302 303 opt_equalequal_name: EQUAL ID { $$ = $2; } 304 | { $$ = 0; } 305 ; 306 307 opt_ordinal: 308 '@' NUMBER { $$ = $2;} 309 | { $$ = -1;} 310 ; 311 312 opt_equal_name: 313 '=' opt_name2 { $$ = $2; } 314 | { $$ = 0; } 315 ; 316 317 opt_base: BASE '=' VMA { $$ = $3;} 318 | { $$ = (bfd_vma) -1;} 319 ; 320 321 anylang_id: ID { $$ = $1; } 322 | '.' ID 323 { 324 char *id = def_pool_alloc (strlen ($2) + 2); 325 sprintf (id, ".%s", $2); 326 $$ = id; 327 } 328 | anylang_id '.' opt_digits opt_id 329 { 330 char *id = def_pool_alloc (strlen ($1) + 1 + strlen ($3) + strlen ($4) + 1); 331 sprintf (id, "%s.%s%s", $1, $3, $4); 332 $$ = id; 333 } 334 ; 335 336 opt_digits: DIGITS { $$ = $1; } 337 | { $$ = ""; } 338 ; 339 340 opt_id: ID { $$ = $1; } 341 | { $$ = ""; } 342 ; 343 344 NUMBER: DIGITS { $$ = strtoul ($1, 0, 0); } 345 ; 346 VMA: DIGITS { $$ = (bfd_vma) strtoull ($1, 0, 0); } 347 348 %% 349 350 /***************************************************************************** 351 API 352 *****************************************************************************/ 353 354 static FILE *the_file; 355 static const char *def_filename; 356 static int linenumber; 357 static def_file *def; 358 static int saw_newline; 359 360 struct directive 361 { 362 struct directive *next; 363 char *name; 364 int len; 365 }; 366 367 static struct directive *directives = 0; 368 369 def_file * 370 def_file_empty (void) 371 { 372 def_file *rv = xmalloc (sizeof (def_file)); 373 memset (rv, 0, sizeof (def_file)); 374 rv->is_dll = -1; 375 rv->base_address = (bfd_vma) -1; 376 rv->stack_reserve = rv->stack_commit = -1; 377 rv->heap_reserve = rv->heap_commit = -1; 378 rv->version_major = rv->version_minor = -1; 379 return rv; 380 } 381 382 def_file * 383 def_file_parse (const char *filename, def_file *add_to) 384 { 385 struct directive *d; 386 387 the_file = fopen (filename, "r"); 388 def_filename = filename; 389 linenumber = 1; 390 if (!the_file) 391 { 392 perror (filename); 393 return 0; 394 } 395 if (add_to) 396 { 397 def = add_to; 398 } 399 else 400 { 401 def = def_file_empty (); 402 } 403 404 saw_newline = 1; 405 if (def_parse ()) 406 { 407 def_file_free (def); 408 fclose (the_file); 409 def_pool_free (); 410 return 0; 411 } 412 413 fclose (the_file); 414 415 while ((d = directives) != NULL) 416 { 417 #if TRACE 418 printf ("Adding directive %08x `%s'\n", d->name, d->name); 419 #endif 420 def_file_add_directive (def, d->name, d->len); 421 directives = d->next; 422 free (d->name); 423 free (d); 424 } 425 def_pool_free (); 426 427 return def; 428 } 429 430 void 431 def_file_free (def_file *fdef) 432 { 433 int i; 434 435 if (!fdef) 436 return; 437 if (fdef->name) 438 free (fdef->name); 439 if (fdef->description) 440 free (fdef->description); 441 442 if (fdef->section_defs) 443 { 444 for (i = 0; i < fdef->num_section_defs; i++) 445 { 446 if (fdef->section_defs[i].name) 447 free (fdef->section_defs[i].name); 448 if (fdef->section_defs[i].class) 449 free (fdef->section_defs[i].class); 450 } 451 free (fdef->section_defs); 452 } 453 454 if (fdef->exports) 455 { 456 for (i = 0; i < fdef->num_exports; i++) 457 { 458 if (fdef->exports[i].internal_name 459 && fdef->exports[i].internal_name != fdef->exports[i].name) 460 free (fdef->exports[i].internal_name); 461 if (fdef->exports[i].name) 462 free (fdef->exports[i].name); 463 if (fdef->exports[i].its_name) 464 free (fdef->exports[i].its_name); 465 } 466 free (fdef->exports); 467 } 468 469 if (fdef->imports) 470 { 471 for (i = 0; i < fdef->num_imports; i++) 472 { 473 if (fdef->imports[i].internal_name 474 && fdef->imports[i].internal_name != fdef->imports[i].name) 475 free (fdef->imports[i].internal_name); 476 if (fdef->imports[i].name) 477 free (fdef->imports[i].name); 478 if (fdef->imports[i].its_name) 479 free (fdef->imports[i].its_name); 480 } 481 free (fdef->imports); 482 } 483 484 while (fdef->modules) 485 { 486 def_file_module *m = fdef->modules; 487 488 fdef->modules = fdef->modules->next; 489 free (m); 490 } 491 492 while (fdef->aligncomms) 493 { 494 def_file_aligncomm *c = fdef->aligncomms; 495 496 fdef->aligncomms = fdef->aligncomms->next; 497 free (c->symbol_name); 498 free (c); 499 } 500 501 free (fdef); 502 } 503 504 #ifdef DEF_FILE_PRINT 505 void 506 def_file_print (FILE *file, def_file *fdef) 507 { 508 int i; 509 510 fprintf (file, ">>>> def_file at 0x%08x\n", fdef); 511 if (fdef->name) 512 fprintf (file, " name: %s\n", fdef->name ? fdef->name : "(unspecified)"); 513 if (fdef->is_dll != -1) 514 fprintf (file, " is dll: %s\n", fdef->is_dll ? "yes" : "no"); 515 if (fdef->base_address != (bfd_vma) -1) 516 { 517 fprintf (file, " base address: 0x"); 518 fprintf_vma (file, fdef->base_address); 519 fprintf (file, "\n"); 520 } 521 if (fdef->description) 522 fprintf (file, " description: `%s'\n", fdef->description); 523 if (fdef->stack_reserve != -1) 524 fprintf (file, " stack reserve: 0x%08x\n", fdef->stack_reserve); 525 if (fdef->stack_commit != -1) 526 fprintf (file, " stack commit: 0x%08x\n", fdef->stack_commit); 527 if (fdef->heap_reserve != -1) 528 fprintf (file, " heap reserve: 0x%08x\n", fdef->heap_reserve); 529 if (fdef->heap_commit != -1) 530 fprintf (file, " heap commit: 0x%08x\n", fdef->heap_commit); 531 532 if (fdef->num_section_defs > 0) 533 { 534 fprintf (file, " section defs:\n"); 535 536 for (i = 0; i < fdef->num_section_defs; i++) 537 { 538 fprintf (file, " name: `%s', class: `%s', flags:", 539 fdef->section_defs[i].name, fdef->section_defs[i].class); 540 if (fdef->section_defs[i].flag_read) 541 fprintf (file, " R"); 542 if (fdef->section_defs[i].flag_write) 543 fprintf (file, " W"); 544 if (fdef->section_defs[i].flag_execute) 545 fprintf (file, " X"); 546 if (fdef->section_defs[i].flag_shared) 547 fprintf (file, " S"); 548 fprintf (file, "\n"); 549 } 550 } 551 552 if (fdef->num_exports > 0) 553 { 554 fprintf (file, " exports:\n"); 555 556 for (i = 0; i < fdef->num_exports; i++) 557 { 558 fprintf (file, " name: `%s', int: `%s', ordinal: %d, flags:", 559 fdef->exports[i].name, fdef->exports[i].internal_name, 560 fdef->exports[i].ordinal); 561 if (fdef->exports[i].flag_private) 562 fprintf (file, " P"); 563 if (fdef->exports[i].flag_constant) 564 fprintf (file, " C"); 565 if (fdef->exports[i].flag_noname) 566 fprintf (file, " N"); 567 if (fdef->exports[i].flag_data) 568 fprintf (file, " D"); 569 fprintf (file, "\n"); 570 } 571 } 572 573 if (fdef->num_imports > 0) 574 { 575 fprintf (file, " imports:\n"); 576 577 for (i = 0; i < fdef->num_imports; i++) 578 { 579 fprintf (file, " int: %s, from: `%s', name: `%s', ordinal: %d\n", 580 fdef->imports[i].internal_name, 581 fdef->imports[i].module, 582 fdef->imports[i].name, 583 fdef->imports[i].ordinal); 584 } 585 } 586 587 if (fdef->version_major != -1) 588 fprintf (file, " version: %d.%d\n", fdef->version_major, fdef->version_minor); 589 590 fprintf (file, "<<<< def_file at 0x%08x\n", fdef); 591 } 592 #endif 593 594 /* Helper routine to check for identity of string pointers, 595 which might be NULL. */ 596 597 static int 598 are_names_equal (const char *s1, const char *s2) 599 { 600 if (!s1 && !s2) 601 return 0; 602 if (!s1 || !s2) 603 return (!s1 ? -1 : 1); 604 return strcmp (s1, s2); 605 } 606 607 static int 608 cmp_export_elem (const def_file_export *e, const char *ex_name, 609 const char *in_name, const char *its_name, 610 int ord) 611 { 612 int r; 613 614 if ((r = are_names_equal (ex_name, e->name)) != 0) 615 return r; 616 if ((r = are_names_equal (in_name, e->internal_name)) != 0) 617 return r; 618 if ((r = are_names_equal (its_name, e->its_name)) != 0) 619 return r; 620 return (ord - e->ordinal); 621 } 622 623 /* Search the position of the identical element, or returns the position 624 of the next higher element. If last valid element is smaller, then MAX 625 is returned. */ 626 627 static int 628 find_export_in_list (def_file_export *b, int max, 629 const char *ex_name, const char *in_name, 630 const char *its_name, int ord, int *is_ident) 631 { 632 int e, l, r, p; 633 634 *is_ident = 0; 635 if (!max) 636 return 0; 637 if ((e = cmp_export_elem (b, ex_name, in_name, its_name, ord)) <= 0) 638 { 639 if (!e) 640 *is_ident = 1; 641 return 0; 642 } 643 if (max == 1) 644 return 1; 645 if ((e = cmp_export_elem (b + (max - 1), ex_name, in_name, its_name, ord)) > 0) 646 return max; 647 else if (!e || max == 2) 648 { 649 if (!e) 650 *is_ident = 1; 651 return max - 1; 652 } 653 l = 0; r = max - 1; 654 while (l < r) 655 { 656 p = (l + r) / 2; 657 e = cmp_export_elem (b + p, ex_name, in_name, its_name, ord); 658 if (!e) 659 { 660 *is_ident = 1; 661 return p; 662 } 663 else if (e < 0) 664 r = p - 1; 665 else if (e > 0) 666 l = p + 1; 667 } 668 if ((e = cmp_export_elem (b + l, ex_name, in_name, its_name, ord)) > 0) 669 ++l; 670 else if (!e) 671 *is_ident = 1; 672 return l; 673 } 674 675 def_file_export * 676 def_file_add_export (def_file *fdef, 677 const char *external_name, 678 const char *internal_name, 679 int ordinal, 680 const char *its_name, 681 int *is_dup) 682 { 683 def_file_export *e; 684 int pos; 685 int max_exports = ROUND_UP(fdef->num_exports, 32); 686 687 if (internal_name && !external_name) 688 external_name = internal_name; 689 if (external_name && !internal_name) 690 internal_name = external_name; 691 692 /* We need to avoid duplicates. */ 693 *is_dup = 0; 694 pos = find_export_in_list (fdef->exports, fdef->num_exports, 695 external_name, internal_name, 696 its_name, ordinal, is_dup); 697 698 if (*is_dup != 0) 699 return (fdef->exports + pos); 700 701 if (fdef->num_exports >= max_exports) 702 { 703 max_exports = ROUND_UP(fdef->num_exports + 1, 32); 704 if (fdef->exports) 705 fdef->exports = xrealloc (fdef->exports, 706 max_exports * sizeof (def_file_export)); 707 else 708 fdef->exports = xmalloc (max_exports * sizeof (def_file_export)); 709 } 710 711 e = fdef->exports + pos; 712 if (pos != fdef->num_exports) 713 memmove (&e[1], e, (sizeof (def_file_export) * (fdef->num_exports - pos))); 714 memset (e, 0, sizeof (def_file_export)); 715 e->name = xstrdup (external_name); 716 e->internal_name = xstrdup (internal_name); 717 e->its_name = (its_name ? xstrdup (its_name) : NULL); 718 e->ordinal = ordinal; 719 fdef->num_exports++; 720 return e; 721 } 722 723 def_file_module * 724 def_get_module (def_file *fdef, const char *name) 725 { 726 def_file_module *s; 727 728 for (s = fdef->modules; s; s = s->next) 729 if (strcmp (s->name, name) == 0) 730 return s; 731 732 return NULL; 733 } 734 735 static def_file_module * 736 def_stash_module (def_file *fdef, const char *name) 737 { 738 def_file_module *s; 739 740 if ((s = def_get_module (fdef, name)) != NULL) 741 return s; 742 s = xmalloc (sizeof (def_file_module) + strlen (name)); 743 s->next = fdef->modules; 744 fdef->modules = s; 745 s->user_data = 0; 746 strcpy (s->name, name); 747 return s; 748 } 749 750 static int 751 cmp_import_elem (const def_file_import *e, const char *ex_name, 752 const char *in_name, const char *module, 753 int ord) 754 { 755 int r; 756 757 if ((r = are_names_equal (module, (e->module ? e->module->name : NULL)))) 758 return r; 759 if ((r = are_names_equal (ex_name, e->name)) != 0) 760 return r; 761 if ((r = are_names_equal (in_name, e->internal_name)) != 0) 762 return r; 763 if (ord != e->ordinal) 764 return (ord < e->ordinal ? -1 : 1); 765 return 0; 766 } 767 768 /* Search the position of the identical element, or returns the position 769 of the next higher element. If last valid element is smaller, then MAX 770 is returned. */ 771 772 static int 773 find_import_in_list (def_file_import *b, int max, 774 const char *ex_name, const char *in_name, 775 const char *module, int ord, int *is_ident) 776 { 777 int e, l, r, p; 778 779 *is_ident = 0; 780 if (!max) 781 return 0; 782 if ((e = cmp_import_elem (b, ex_name, in_name, module, ord)) <= 0) 783 { 784 if (!e) 785 *is_ident = 1; 786 return 0; 787 } 788 if (max == 1) 789 return 1; 790 if ((e = cmp_import_elem (b + (max - 1), ex_name, in_name, module, ord)) > 0) 791 return max; 792 else if (!e || max == 2) 793 { 794 if (!e) 795 *is_ident = 1; 796 return max - 1; 797 } 798 l = 0; r = max - 1; 799 while (l < r) 800 { 801 p = (l + r) / 2; 802 e = cmp_import_elem (b + p, ex_name, in_name, module, ord); 803 if (!e) 804 { 805 *is_ident = 1; 806 return p; 807 } 808 else if (e < 0) 809 r = p - 1; 810 else if (e > 0) 811 l = p + 1; 812 } 813 if ((e = cmp_import_elem (b + l, ex_name, in_name, module, ord)) > 0) 814 ++l; 815 else if (!e) 816 *is_ident = 1; 817 return l; 818 } 819 820 static void 821 fill_in_import (def_file_import *i, 822 const char *name, 823 def_file_module *module, 824 int ordinal, 825 const char *internal_name, 826 const char *its_name) 827 { 828 memset (i, 0, sizeof (def_file_import)); 829 if (name) 830 i->name = xstrdup (name); 831 i->module = module; 832 i->ordinal = ordinal; 833 if (internal_name) 834 i->internal_name = xstrdup (internal_name); 835 else 836 i->internal_name = i->name; 837 i->its_name = (its_name ? xstrdup (its_name) : NULL); 838 } 839 840 def_file_import * 841 def_file_add_import (def_file *fdef, 842 const char *name, 843 const char *module, 844 int ordinal, 845 const char *internal_name, 846 const char *its_name, 847 int *is_dup) 848 { 849 def_file_import *i; 850 int pos; 851 int max_imports = ROUND_UP (fdef->num_imports, 16); 852 853 /* We need to avoid here duplicates. */ 854 *is_dup = 0; 855 pos = find_import_in_list (fdef->imports, fdef->num_imports, 856 name, 857 (!internal_name ? name : internal_name), 858 module, ordinal, is_dup); 859 if (*is_dup != 0) 860 return fdef->imports + pos; 861 862 if (fdef->num_imports >= max_imports) 863 { 864 max_imports = ROUND_UP (fdef->num_imports+1, 16); 865 866 if (fdef->imports) 867 fdef->imports = xrealloc (fdef->imports, 868 max_imports * sizeof (def_file_import)); 869 else 870 fdef->imports = xmalloc (max_imports * sizeof (def_file_import)); 871 } 872 i = fdef->imports + pos; 873 if (pos != fdef->num_imports) 874 memmove (i + 1, i, sizeof (def_file_import) * (fdef->num_imports - pos)); 875 876 fill_in_import (i, name, def_stash_module (fdef, module), ordinal, 877 internal_name, its_name); 878 fdef->num_imports++; 879 880 return i; 881 } 882 883 int 884 def_file_add_import_from (def_file *fdef, 885 int num_imports, 886 const char *name, 887 const char *module, 888 int ordinal, 889 const char *internal_name, 890 const char *its_name ATTRIBUTE_UNUSED) 891 { 892 def_file_import *i; 893 int is_dup; 894 int pos; 895 int max_imports = ROUND_UP (fdef->num_imports, 16); 896 897 /* We need to avoid here duplicates. */ 898 is_dup = 0; 899 pos = find_import_in_list (fdef->imports, fdef->num_imports, 900 name, internal_name ? internal_name : name, 901 module, ordinal, &is_dup); 902 if (is_dup != 0) 903 return -1; 904 if (fdef->imports && pos != fdef->num_imports) 905 { 906 i = fdef->imports + pos; 907 if (i->module && strcmp (i->module->name, module) == 0) 908 return -1; 909 } 910 911 if (fdef->num_imports + num_imports - 1 >= max_imports) 912 { 913 max_imports = ROUND_UP (fdef->num_imports + num_imports, 16); 914 915 if (fdef->imports) 916 fdef->imports = xrealloc (fdef->imports, 917 max_imports * sizeof (def_file_import)); 918 else 919 fdef->imports = xmalloc (max_imports * sizeof (def_file_import)); 920 } 921 i = fdef->imports + pos; 922 if (pos != fdef->num_imports) 923 memmove (i + num_imports, i, 924 sizeof (def_file_import) * (fdef->num_imports - pos)); 925 926 return pos; 927 } 928 929 def_file_import * 930 def_file_add_import_at (def_file *fdef, 931 int pos, 932 const char *name, 933 const char *module, 934 int ordinal, 935 const char *internal_name, 936 const char *its_name) 937 { 938 def_file_import *i = fdef->imports + pos; 939 940 fill_in_import (i, name, def_stash_module (fdef, module), ordinal, 941 internal_name, its_name); 942 fdef->num_imports++; 943 944 return i; 945 } 946 947 struct 948 { 949 char *param; 950 int token; 951 } 952 diropts[] = 953 { 954 { "-heap", HEAPSIZE }, 955 { "-stack", STACKSIZE_K }, 956 { "-attr", SECTIONS }, 957 { "-export", EXPORTS }, 958 { "-aligncomm", ALIGNCOMM }, 959 { 0, 0 } 960 }; 961 962 void 963 def_file_add_directive (def_file *my_def, const char *param, int len) 964 { 965 def_file *save_def = def; 966 const char *pend = param + len; 967 char * tend = (char *) param; 968 int i; 969 970 def = my_def; 971 972 while (param < pend) 973 { 974 while (param < pend 975 && (ISSPACE (*param) || *param == '\n' || *param == 0)) 976 param++; 977 978 if (param == pend) 979 break; 980 981 /* Scan forward until we encounter any of: 982 - the end of the buffer 983 - the start of a new option 984 - a newline separating options 985 - a NUL separating options. */ 986 for (tend = (char *) (param + 1); 987 (tend < pend 988 && !(ISSPACE (tend[-1]) && *tend == '-') 989 && *tend != '\n' && *tend != 0); 990 tend++) 991 ; 992 993 for (i = 0; diropts[i].param; i++) 994 { 995 len = strlen (diropts[i].param); 996 997 if (tend - param >= len 998 && strncmp (param, diropts[i].param, len) == 0 999 && (param[len] == ':' || param[len] == ' ')) 1000 { 1001 lex_parse_string_end = tend; 1002 lex_parse_string = param + len + 1; 1003 lex_forced_token = diropts[i].token; 1004 saw_newline = 0; 1005 if (def_parse ()) 1006 continue; 1007 break; 1008 } 1009 } 1010 1011 if (!diropts[i].param) 1012 { 1013 if (tend < pend) 1014 { 1015 char saved; 1016 1017 saved = * tend; 1018 * tend = 0; 1019 /* xgettext:c-format */ 1020 einfo (_("Warning: .drectve `%s' unrecognized\n"), param); 1021 * tend = saved; 1022 } 1023 else 1024 { 1025 einfo (_("Warning: corrupt .drectve at end of def file\n")); 1026 } 1027 } 1028 1029 lex_parse_string = 0; 1030 param = tend; 1031 } 1032 1033 def = save_def; 1034 def_pool_free (); 1035 } 1036 1037 /* Parser Callbacks. */ 1038 1039 static void 1040 def_image_name (const char *name, bfd_vma base, int is_dll) 1041 { 1042 /* If a LIBRARY or NAME statement is specified without a name, there is nothing 1043 to do here. We retain the output filename specified on command line. */ 1044 if (*name) 1045 { 1046 const char* image_name = lbasename (name); 1047 1048 if (image_name != name) 1049 einfo ("%s:%d: Warning: path components stripped from %s, '%s'\n", 1050 def_filename, linenumber, is_dll ? "LIBRARY" : "NAME", 1051 name); 1052 if (def->name) 1053 free (def->name); 1054 /* Append the default suffix, if none specified. */ 1055 if (strchr (image_name, '.') == 0) 1056 { 1057 const char * suffix = is_dll ? ".dll" : ".exe"; 1058 1059 def->name = xmalloc (strlen (image_name) + strlen (suffix) + 1); 1060 sprintf (def->name, "%s%s", image_name, suffix); 1061 } 1062 else 1063 def->name = xstrdup (image_name); 1064 } 1065 1066 /* Honor a BASE address statement, even if LIBRARY string is empty. */ 1067 def->base_address = base; 1068 def->is_dll = is_dll; 1069 } 1070 1071 static void 1072 def_description (const char *text) 1073 { 1074 int len = def->description ? strlen (def->description) : 0; 1075 1076 len += strlen (text) + 1; 1077 if (def->description) 1078 { 1079 def->description = xrealloc (def->description, len); 1080 strcat (def->description, text); 1081 } 1082 else 1083 { 1084 def->description = xmalloc (len); 1085 strcpy (def->description, text); 1086 } 1087 } 1088 1089 static void 1090 def_stacksize (int reserve, int commit) 1091 { 1092 def->stack_reserve = reserve; 1093 def->stack_commit = commit; 1094 } 1095 1096 static void 1097 def_heapsize (int reserve, int commit) 1098 { 1099 def->heap_reserve = reserve; 1100 def->heap_commit = commit; 1101 } 1102 1103 static void 1104 def_section (const char *name, int attr) 1105 { 1106 def_file_section *s; 1107 int max_sections = ROUND_UP (def->num_section_defs, 4); 1108 1109 if (def->num_section_defs >= max_sections) 1110 { 1111 max_sections = ROUND_UP (def->num_section_defs+1, 4); 1112 1113 if (def->section_defs) 1114 def->section_defs = xrealloc (def->section_defs, 1115 max_sections * sizeof (def_file_import)); 1116 else 1117 def->section_defs = xmalloc (max_sections * sizeof (def_file_import)); 1118 } 1119 s = def->section_defs + def->num_section_defs; 1120 memset (s, 0, sizeof (def_file_section)); 1121 s->name = xstrdup (name); 1122 if (attr & 1) 1123 s->flag_read = 1; 1124 if (attr & 2) 1125 s->flag_write = 1; 1126 if (attr & 4) 1127 s->flag_execute = 1; 1128 if (attr & 8) 1129 s->flag_shared = 1; 1130 1131 def->num_section_defs++; 1132 } 1133 1134 static void 1135 def_section_alt (const char *name, const char *attr) 1136 { 1137 int aval = 0; 1138 1139 for (; *attr; attr++) 1140 { 1141 switch (*attr) 1142 { 1143 case 'R': 1144 case 'r': 1145 aval |= 1; 1146 break; 1147 case 'W': 1148 case 'w': 1149 aval |= 2; 1150 break; 1151 case 'X': 1152 case 'x': 1153 aval |= 4; 1154 break; 1155 case 'S': 1156 case 's': 1157 aval |= 8; 1158 break; 1159 } 1160 } 1161 def_section (name, aval); 1162 } 1163 1164 static void 1165 def_exports (const char *external_name, 1166 const char *internal_name, 1167 int ordinal, 1168 int flags, 1169 const char *its_name) 1170 { 1171 def_file_export *dfe; 1172 int is_dup = 0; 1173 1174 if (!internal_name && external_name) 1175 internal_name = external_name; 1176 #if TRACE 1177 printf ("def_exports, ext=%s int=%s\n", external_name, internal_name); 1178 #endif 1179 1180 dfe = def_file_add_export (def, external_name, internal_name, ordinal, 1181 its_name, &is_dup); 1182 1183 /* We might check here for flag redefinition and warn. For now we 1184 ignore duplicates silently. */ 1185 if (is_dup) 1186 return; 1187 1188 if (flags & 1) 1189 dfe->flag_noname = 1; 1190 if (flags & 2) 1191 dfe->flag_constant = 1; 1192 if (flags & 4) 1193 dfe->flag_data = 1; 1194 if (flags & 8) 1195 dfe->flag_private = 1; 1196 } 1197 1198 static void 1199 def_import (const char *internal_name, 1200 const char *module, 1201 const char *dllext, 1202 const char *name, 1203 int ordinal, 1204 const char *its_name) 1205 { 1206 char *buf = 0; 1207 const char *ext = dllext ? dllext : "dll"; 1208 int is_dup = 0; 1209 1210 buf = xmalloc (strlen (module) + strlen (ext) + 2); 1211 sprintf (buf, "%s.%s", module, ext); 1212 module = buf; 1213 1214 def_file_add_import (def, name, module, ordinal, internal_name, its_name, 1215 &is_dup); 1216 free (buf); 1217 } 1218 1219 static void 1220 def_version (int major, int minor) 1221 { 1222 def->version_major = major; 1223 def->version_minor = minor; 1224 } 1225 1226 static void 1227 def_directive (char *str) 1228 { 1229 struct directive *d = xmalloc (sizeof (struct directive)); 1230 1231 d->next = directives; 1232 directives = d; 1233 d->name = xstrdup (str); 1234 d->len = strlen (str); 1235 } 1236 1237 static void 1238 def_aligncomm (char *str, int align) 1239 { 1240 def_file_aligncomm *c, *p; 1241 1242 p = NULL; 1243 c = def->aligncomms; 1244 while (c != NULL) 1245 { 1246 int e = strcmp (c->symbol_name, str); 1247 if (!e) 1248 { 1249 /* Not sure if we want to allow here duplicates with 1250 different alignments, but for now we keep them. */ 1251 e = (int) c->alignment - align; 1252 if (!e) 1253 return; 1254 } 1255 if (e > 0) 1256 break; 1257 c = (p = c)->next; 1258 } 1259 1260 c = xmalloc (sizeof (def_file_aligncomm)); 1261 c->symbol_name = xstrdup (str); 1262 c->alignment = (unsigned int) align; 1263 if (!p) 1264 { 1265 c->next = def->aligncomms; 1266 def->aligncomms = c; 1267 } 1268 else 1269 { 1270 c->next = p->next; 1271 p->next = c; 1272 } 1273 } 1274 1275 static int 1276 def_error (const char *err) 1277 { 1278 einfo ("%P: %s:%d: %s\n", 1279 def_filename ? def_filename : "<unknown-file>", linenumber, err); 1280 return 0; 1281 } 1282 1283 1284 /* Lexical Scanner. */ 1285 1286 #undef TRACE 1287 #define TRACE 0 1288 1289 /* Never freed, but always reused as needed, so no real leak. */ 1290 static char *buffer = 0; 1291 static int buflen = 0; 1292 static int bufptr = 0; 1293 1294 static void 1295 put_buf (char c) 1296 { 1297 if (bufptr == buflen) 1298 { 1299 buflen += 50; /* overly reasonable, eh? */ 1300 if (buffer) 1301 buffer = xrealloc (buffer, buflen + 1); 1302 else 1303 buffer = xmalloc (buflen + 1); 1304 } 1305 buffer[bufptr++] = c; 1306 buffer[bufptr] = 0; /* not optimal, but very convenient. */ 1307 } 1308 1309 static struct 1310 { 1311 char *name; 1312 int token; 1313 } 1314 tokens[] = 1315 { 1316 { "BASE", BASE }, 1317 { "CODE", CODE }, 1318 { "CONSTANT", CONSTANTU }, 1319 { "constant", CONSTANTL }, 1320 { "DATA", DATAU }, 1321 { "data", DATAL }, 1322 { "DESCRIPTION", DESCRIPTION }, 1323 { "DIRECTIVE", DIRECTIVE }, 1324 { "EXECUTE", EXECUTE }, 1325 { "EXPORTS", EXPORTS }, 1326 { "HEAPSIZE", HEAPSIZE }, 1327 { "IMPORTS", IMPORTS }, 1328 { "LIBRARY", LIBRARY }, 1329 { "NAME", NAME }, 1330 { "NONAME", NONAMEU }, 1331 { "noname", NONAMEL }, 1332 { "PRIVATE", PRIVATEU }, 1333 { "private", PRIVATEL }, 1334 { "READ", READ }, 1335 { "SECTIONS", SECTIONS }, 1336 { "SEGMENTS", SECTIONS }, 1337 { "SHARED", SHARED }, 1338 { "STACKSIZE", STACKSIZE_K }, 1339 { "VERSION", VERSIONK }, 1340 { "WRITE", WRITE }, 1341 { 0, 0 } 1342 }; 1343 1344 static int 1345 def_getc (void) 1346 { 1347 int rv; 1348 1349 if (lex_parse_string) 1350 { 1351 if (lex_parse_string >= lex_parse_string_end) 1352 rv = EOF; 1353 else 1354 rv = *lex_parse_string++; 1355 } 1356 else 1357 { 1358 rv = fgetc (the_file); 1359 } 1360 if (rv == '\n') 1361 saw_newline = 1; 1362 return rv; 1363 } 1364 1365 static int 1366 def_ungetc (int c) 1367 { 1368 if (lex_parse_string) 1369 { 1370 lex_parse_string--; 1371 return c; 1372 } 1373 else 1374 return ungetc (c, the_file); 1375 } 1376 1377 static int 1378 def_lex (void) 1379 { 1380 int c, i, q; 1381 1382 if (lex_forced_token) 1383 { 1384 i = lex_forced_token; 1385 lex_forced_token = 0; 1386 #if TRACE 1387 printf ("lex: forcing token %d\n", i); 1388 #endif 1389 return i; 1390 } 1391 1392 c = def_getc (); 1393 1394 /* Trim leading whitespace. */ 1395 while (c != EOF && (c == ' ' || c == '\t') && saw_newline) 1396 c = def_getc (); 1397 1398 if (c == EOF) 1399 { 1400 #if TRACE 1401 printf ("lex: EOF\n"); 1402 #endif 1403 return 0; 1404 } 1405 1406 if (saw_newline && c == ';') 1407 { 1408 do 1409 { 1410 c = def_getc (); 1411 } 1412 while (c != EOF && c != '\n'); 1413 if (c == '\n') 1414 return def_lex (); 1415 return 0; 1416 } 1417 1418 /* Must be something else. */ 1419 saw_newline = 0; 1420 1421 if (ISDIGIT (c)) 1422 { 1423 bufptr = 0; 1424 while (c != EOF && (ISXDIGIT (c) || (c == 'x'))) 1425 { 1426 put_buf (c); 1427 c = def_getc (); 1428 } 1429 if (c != EOF) 1430 def_ungetc (c); 1431 yylval.digits = def_pool_strdup (buffer); 1432 #if TRACE 1433 printf ("lex: `%s' returns DIGITS\n", buffer); 1434 #endif 1435 return DIGITS; 1436 } 1437 1438 if (ISALPHA (c) || strchr ("$:-_?@", c)) 1439 { 1440 bufptr = 0; 1441 q = c; 1442 put_buf (c); 1443 c = def_getc (); 1444 1445 if (q == '@') 1446 { 1447 if (ISBLANK (c) ) /* '@' followed by whitespace. */ 1448 return (q); 1449 else if (ISDIGIT (c)) /* '@' followed by digit. */ 1450 { 1451 def_ungetc (c); 1452 return (q); 1453 } 1454 #if TRACE 1455 printf ("lex: @ returns itself\n"); 1456 #endif 1457 } 1458 1459 while (c != EOF && (ISALNUM (c) || strchr ("$:-_?/@<>", c))) 1460 { 1461 put_buf (c); 1462 c = def_getc (); 1463 } 1464 if (c != EOF) 1465 def_ungetc (c); 1466 if (ISALPHA (q)) /* Check for tokens. */ 1467 { 1468 for (i = 0; tokens[i].name; i++) 1469 if (strcmp (tokens[i].name, buffer) == 0) 1470 { 1471 #if TRACE 1472 printf ("lex: `%s' is a string token\n", buffer); 1473 #endif 1474 return tokens[i].token; 1475 } 1476 } 1477 #if TRACE 1478 printf ("lex: `%s' returns ID\n", buffer); 1479 #endif 1480 yylval.id = def_pool_strdup (buffer); 1481 return ID; 1482 } 1483 1484 if (c == '\'' || c == '"') 1485 { 1486 q = c; 1487 c = def_getc (); 1488 bufptr = 0; 1489 1490 while (c != EOF && c != q) 1491 { 1492 put_buf (c); 1493 c = def_getc (); 1494 } 1495 yylval.id = def_pool_strdup (buffer); 1496 #if TRACE 1497 printf ("lex: `%s' returns ID\n", buffer); 1498 #endif 1499 return ID; 1500 } 1501 1502 if ( c == '=') 1503 { 1504 c = def_getc (); 1505 if (c == '=') 1506 { 1507 #if TRACE 1508 printf ("lex: `==' returns EQUAL\n"); 1509 #endif 1510 return EQUAL; 1511 } 1512 def_ungetc (c); 1513 #if TRACE 1514 printf ("lex: `=' returns itself\n"); 1515 #endif 1516 return '='; 1517 } 1518 if (c == '.' || c == ',') 1519 { 1520 #if TRACE 1521 printf ("lex: `%c' returns itself\n", c); 1522 #endif 1523 return c; 1524 } 1525 1526 if (c == '\n') 1527 { 1528 linenumber++; 1529 saw_newline = 1; 1530 } 1531 1532 /*printf ("lex: 0x%02x ignored\n", c); */ 1533 return def_lex (); 1534 } 1535 1536 static char * 1537 def_pool_alloc (size_t sz) 1538 { 1539 def_pool_str *e; 1540 1541 e = (def_pool_str *) xmalloc (sizeof (def_pool_str) + sz); 1542 e->next = pool_strs; 1543 pool_strs = e; 1544 return e->data; 1545 } 1546 1547 static char * 1548 def_pool_strdup (const char *str) 1549 { 1550 char *s; 1551 size_t len; 1552 if (!str) 1553 return NULL; 1554 len = strlen (str) + 1; 1555 s = def_pool_alloc (len); 1556 memcpy (s, str, len); 1557 return s; 1558 } 1559 1560 static void 1561 def_pool_free (void) 1562 { 1563 def_pool_str *p; 1564 while ((p = pool_strs) != NULL) 1565 { 1566 pool_strs = p->next; 1567 free (p); 1568 } 1569 } 1570