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