1 /* Linker command language support. 2 Copyright (C) 1991-2016 Free Software Foundation, Inc. 3 4 This file is part of the GNU Binutils. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "libiberty.h" 24 #include "filenames.h" 25 #include "safe-ctype.h" 26 #include "obstack.h" 27 #include "bfdlink.h" 28 29 #include "ld.h" 30 #include "ldmain.h" 31 #include "ldexp.h" 32 #include "ldlang.h" 33 #include <ldgram.h> 34 #include "ldlex.h" 35 #include "ldmisc.h" 36 #include "ldctor.h" 37 #include "ldfile.h" 38 #include "ldemul.h" 39 #include "fnmatch.h" 40 #include "demangle.h" 41 #include "hashtab.h" 42 #include "libbfd.h" 43 #include "elf-bfd.h" 44 #ifdef ENABLE_PLUGINS 45 #include "plugin.h" 46 #endif /* ENABLE_PLUGINS */ 47 48 #ifndef offsetof 49 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER)) 50 #endif 51 52 /* Convert between addresses in bytes and sizes in octets. 53 For currently supported targets, octets_per_byte is always a power 54 of two, so we can use shifts. */ 55 #define TO_ADDR(X) ((X) >> opb_shift) 56 #define TO_SIZE(X) ((X) << opb_shift) 57 58 /* Local variables. */ 59 static struct obstack stat_obstack; 60 static struct obstack map_obstack; 61 62 #define obstack_chunk_alloc xmalloc 63 #define obstack_chunk_free free 64 static const char *entry_symbol_default = "start"; 65 static bfd_boolean placed_commons = FALSE; 66 static bfd_boolean map_head_is_link_order = FALSE; 67 static lang_output_section_statement_type *default_common_section; 68 static bfd_boolean map_option_f; 69 static bfd_vma print_dot; 70 static lang_input_statement_type *first_file; 71 static const char *current_target; 72 static lang_statement_list_type statement_list; 73 static lang_statement_list_type *stat_save[10]; 74 static lang_statement_list_type **stat_save_ptr = &stat_save[0]; 75 static struct unique_sections *unique_section_list; 76 static struct asneeded_minfo *asneeded_list_head; 77 static unsigned int opb_shift = 0; 78 79 /* Forward declarations. */ 80 static void exp_init_os (etree_type *); 81 static lang_input_statement_type *lookup_name (const char *); 82 static void insert_undefined (const char *); 83 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *); 84 static void print_statement (lang_statement_union_type *, 85 lang_output_section_statement_type *); 86 static void print_statement_list (lang_statement_union_type *, 87 lang_output_section_statement_type *); 88 static void print_statements (void); 89 static void print_input_section (asection *, bfd_boolean); 90 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *); 91 static void lang_record_phdrs (void); 92 static void lang_do_version_exports_section (void); 93 static void lang_finalize_version_expr_head 94 (struct bfd_elf_version_expr_head *); 95 static void lang_do_memory_regions (void); 96 97 /* Exported variables. */ 98 const char *output_target; 99 lang_output_section_statement_type *abs_output_section; 100 lang_statement_list_type lang_output_section_statement; 101 lang_statement_list_type *stat_ptr = &statement_list; 102 lang_statement_list_type file_chain = { NULL, NULL }; 103 lang_statement_list_type input_file_chain; 104 struct bfd_sym_chain entry_symbol = { NULL, NULL }; 105 const char *entry_section = ".text"; 106 struct lang_input_statement_flags input_flags; 107 bfd_boolean entry_from_cmdline; 108 bfd_boolean undef_from_cmdline; 109 bfd_boolean lang_has_input_file = FALSE; 110 bfd_boolean had_output_filename = FALSE; 111 bfd_boolean lang_float_flag = FALSE; 112 bfd_boolean delete_output_file_on_failure = FALSE; 113 struct lang_phdr *lang_phdr_list; 114 struct lang_nocrossrefs *nocrossref_list; 115 struct asneeded_minfo **asneeded_list_tail; 116 117 /* Functions that traverse the linker script and might evaluate 118 DEFINED() need to increment this at the start of the traversal. */ 119 int lang_statement_iteration = 0; 120 121 /* Return TRUE if the PATTERN argument is a wildcard pattern. 122 Although backslashes are treated specially if a pattern contains 123 wildcards, we do not consider the mere presence of a backslash to 124 be enough to cause the pattern to be treated as a wildcard. 125 That lets us handle DOS filenames more naturally. */ 126 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL) 127 128 #define new_stat(x, y) \ 129 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y) 130 131 #define outside_section_address(q) \ 132 ((q)->output_offset + (q)->output_section->vma) 133 134 #define outside_symbol_address(q) \ 135 ((q)->value + outside_section_address (q->section)) 136 137 #define SECTION_NAME_MAP_LENGTH (16) 138 139 void * 140 stat_alloc (size_t size) 141 { 142 return obstack_alloc (&stat_obstack, size); 143 } 144 145 static int 146 name_match (const char *pattern, const char *name) 147 { 148 if (wildcardp (pattern)) 149 return fnmatch (pattern, name, 0); 150 return strcmp (pattern, name); 151 } 152 153 /* If PATTERN is of the form archive:file, return a pointer to the 154 separator. If not, return NULL. */ 155 156 static char * 157 archive_path (const char *pattern) 158 { 159 char *p = NULL; 160 161 if (link_info.path_separator == 0) 162 return p; 163 164 p = strchr (pattern, link_info.path_separator); 165 #ifdef HAVE_DOS_BASED_FILE_SYSTEM 166 if (p == NULL || link_info.path_separator != ':') 167 return p; 168 169 /* Assume a match on the second char is part of drive specifier, 170 as in "c:\silly.dos". */ 171 if (p == pattern + 1 && ISALPHA (*pattern)) 172 p = strchr (p + 1, link_info.path_separator); 173 #endif 174 return p; 175 } 176 177 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path, 178 return whether F matches FILE_SPEC. */ 179 180 static bfd_boolean 181 input_statement_is_archive_path (const char *file_spec, char *sep, 182 lang_input_statement_type *f) 183 { 184 bfd_boolean match = FALSE; 185 186 if ((*(sep + 1) == 0 187 || name_match (sep + 1, f->filename) == 0) 188 && ((sep != file_spec) 189 == (f->the_bfd != NULL && f->the_bfd->my_archive != NULL))) 190 { 191 match = TRUE; 192 193 if (sep != file_spec) 194 { 195 const char *aname = f->the_bfd->my_archive->filename; 196 *sep = 0; 197 match = name_match (file_spec, aname) == 0; 198 *sep = link_info.path_separator; 199 } 200 } 201 return match; 202 } 203 204 static bfd_boolean 205 unique_section_p (const asection *sec, 206 const lang_output_section_statement_type *os) 207 { 208 struct unique_sections *unam; 209 const char *secnam; 210 211 if (bfd_link_relocatable (&link_info) 212 && sec->owner != NULL 213 && bfd_is_group_section (sec->owner, sec)) 214 return !(os != NULL 215 && strcmp (os->name, DISCARD_SECTION_NAME) == 0); 216 217 secnam = sec->name; 218 for (unam = unique_section_list; unam; unam = unam->next) 219 if (name_match (unam->name, secnam) == 0) 220 return TRUE; 221 222 return FALSE; 223 } 224 225 /* Generic traversal routines for finding matching sections. */ 226 227 /* Try processing a section against a wildcard. This just calls 228 the callback unless the filename exclusion list is present 229 and excludes the file. It's hardly ever present so this 230 function is very fast. */ 231 232 static void 233 walk_wild_consider_section (lang_wild_statement_type *ptr, 234 lang_input_statement_type *file, 235 asection *s, 236 struct wildcard_list *sec, 237 callback_t callback, 238 void *data) 239 { 240 struct name_list *list_tmp; 241 242 /* Don't process sections from files which were excluded. */ 243 for (list_tmp = sec->spec.exclude_name_list; 244 list_tmp; 245 list_tmp = list_tmp->next) 246 { 247 char *p = archive_path (list_tmp->name); 248 249 if (p != NULL) 250 { 251 if (input_statement_is_archive_path (list_tmp->name, p, file)) 252 return; 253 } 254 255 else if (name_match (list_tmp->name, file->filename) == 0) 256 return; 257 258 /* FIXME: Perhaps remove the following at some stage? Matching 259 unadorned archives like this was never documented and has 260 been superceded by the archive:path syntax. */ 261 else if (file->the_bfd != NULL 262 && file->the_bfd->my_archive != NULL 263 && name_match (list_tmp->name, 264 file->the_bfd->my_archive->filename) == 0) 265 return; 266 } 267 268 (*callback) (ptr, sec, s, ptr->section_flag_list, file, data); 269 } 270 271 /* Lowest common denominator routine that can handle everything correctly, 272 but slowly. */ 273 274 static void 275 walk_wild_section_general (lang_wild_statement_type *ptr, 276 lang_input_statement_type *file, 277 callback_t callback, 278 void *data) 279 { 280 asection *s; 281 struct wildcard_list *sec; 282 283 for (s = file->the_bfd->sections; s != NULL; s = s->next) 284 { 285 sec = ptr->section_list; 286 if (sec == NULL) 287 (*callback) (ptr, sec, s, ptr->section_flag_list, file, data); 288 289 while (sec != NULL) 290 { 291 bfd_boolean skip = FALSE; 292 293 if (sec->spec.name != NULL) 294 { 295 const char *sname = bfd_get_section_name (file->the_bfd, s); 296 297 skip = name_match (sec->spec.name, sname) != 0; 298 } 299 300 if (!skip) 301 walk_wild_consider_section (ptr, file, s, sec, callback, data); 302 303 sec = sec->next; 304 } 305 } 306 } 307 308 /* Routines to find a single section given its name. If there's more 309 than one section with that name, we report that. */ 310 311 typedef struct 312 { 313 asection *found_section; 314 bfd_boolean multiple_sections_found; 315 } section_iterator_callback_data; 316 317 static bfd_boolean 318 section_iterator_callback (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *data) 319 { 320 section_iterator_callback_data *d = (section_iterator_callback_data *) data; 321 322 if (d->found_section != NULL) 323 { 324 d->multiple_sections_found = TRUE; 325 return TRUE; 326 } 327 328 d->found_section = s; 329 return FALSE; 330 } 331 332 static asection * 333 find_section (lang_input_statement_type *file, 334 struct wildcard_list *sec, 335 bfd_boolean *multiple_sections_found) 336 { 337 section_iterator_callback_data cb_data = { NULL, FALSE }; 338 339 bfd_get_section_by_name_if (file->the_bfd, sec->spec.name, 340 section_iterator_callback, &cb_data); 341 *multiple_sections_found = cb_data.multiple_sections_found; 342 return cb_data.found_section; 343 } 344 345 /* Code for handling simple wildcards without going through fnmatch, 346 which can be expensive because of charset translations etc. */ 347 348 /* A simple wild is a literal string followed by a single '*', 349 where the literal part is at least 4 characters long. */ 350 351 static bfd_boolean 352 is_simple_wild (const char *name) 353 { 354 size_t len = strcspn (name, "*?["); 355 return len >= 4 && name[len] == '*' && name[len + 1] == '\0'; 356 } 357 358 static bfd_boolean 359 match_simple_wild (const char *pattern, const char *name) 360 { 361 /* The first four characters of the pattern are guaranteed valid 362 non-wildcard characters. So we can go faster. */ 363 if (pattern[0] != name[0] || pattern[1] != name[1] 364 || pattern[2] != name[2] || pattern[3] != name[3]) 365 return FALSE; 366 367 pattern += 4; 368 name += 4; 369 while (*pattern != '*') 370 if (*name++ != *pattern++) 371 return FALSE; 372 373 return TRUE; 374 } 375 376 /* Return the numerical value of the init_priority attribute from 377 section name NAME. */ 378 379 static unsigned long 380 get_init_priority (const char *name) 381 { 382 char *end; 383 unsigned long init_priority; 384 385 /* GCC uses the following section names for the init_priority 386 attribute with numerical values 101 and 65535 inclusive. A 387 lower value means a higher priority. 388 389 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the 390 decimal numerical value of the init_priority attribute. 391 The order of execution in .init_array is forward and 392 .fini_array is backward. 393 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the 394 decimal numerical value of the init_priority attribute. 395 The order of execution in .ctors is backward and .dtors 396 is forward. 397 */ 398 if (strncmp (name, ".init_array.", 12) == 0 399 || strncmp (name, ".fini_array.", 12) == 0) 400 { 401 init_priority = strtoul (name + 12, &end, 10); 402 return *end ? 0 : init_priority; 403 } 404 else if (strncmp (name, ".ctors.", 7) == 0 405 || strncmp (name, ".dtors.", 7) == 0) 406 { 407 init_priority = strtoul (name + 7, &end, 10); 408 return *end ? 0 : 65535 - init_priority; 409 } 410 411 return 0; 412 } 413 414 /* Compare sections ASEC and BSEC according to SORT. */ 415 416 static int 417 compare_section (sort_type sort, asection *asec, asection *bsec) 418 { 419 int ret; 420 unsigned long ainit_priority, binit_priority; 421 422 switch (sort) 423 { 424 default: 425 abort (); 426 427 case by_init_priority: 428 ainit_priority 429 = get_init_priority (bfd_get_section_name (asec->owner, asec)); 430 binit_priority 431 = get_init_priority (bfd_get_section_name (bsec->owner, bsec)); 432 if (ainit_priority == 0 || binit_priority == 0) 433 goto sort_by_name; 434 ret = ainit_priority - binit_priority; 435 if (ret) 436 break; 437 else 438 goto sort_by_name; 439 440 case by_alignment_name: 441 ret = (bfd_section_alignment (bsec->owner, bsec) 442 - bfd_section_alignment (asec->owner, asec)); 443 if (ret) 444 break; 445 /* Fall through. */ 446 447 case by_name: 448 sort_by_name: 449 ret = strcmp (bfd_get_section_name (asec->owner, asec), 450 bfd_get_section_name (bsec->owner, bsec)); 451 break; 452 453 case by_name_alignment: 454 ret = strcmp (bfd_get_section_name (asec->owner, asec), 455 bfd_get_section_name (bsec->owner, bsec)); 456 if (ret) 457 break; 458 /* Fall through. */ 459 460 case by_alignment: 461 ret = (bfd_section_alignment (bsec->owner, bsec) 462 - bfd_section_alignment (asec->owner, asec)); 463 break; 464 } 465 466 return ret; 467 } 468 469 /* Build a Binary Search Tree to sort sections, unlike insertion sort 470 used in wild_sort(). BST is considerably faster if the number of 471 of sections are large. */ 472 473 static lang_section_bst_type ** 474 wild_sort_fast (lang_wild_statement_type *wild, 475 struct wildcard_list *sec, 476 lang_input_statement_type *file ATTRIBUTE_UNUSED, 477 asection *section) 478 { 479 lang_section_bst_type **tree; 480 481 tree = &wild->tree; 482 if (!wild->filenames_sorted 483 && (sec == NULL || sec->spec.sorted == none)) 484 { 485 /* Append at the right end of tree. */ 486 while (*tree) 487 tree = &((*tree)->right); 488 return tree; 489 } 490 491 while (*tree) 492 { 493 /* Find the correct node to append this section. */ 494 if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0) 495 tree = &((*tree)->left); 496 else 497 tree = &((*tree)->right); 498 } 499 500 return tree; 501 } 502 503 /* Use wild_sort_fast to build a BST to sort sections. */ 504 505 static void 506 output_section_callback_fast (lang_wild_statement_type *ptr, 507 struct wildcard_list *sec, 508 asection *section, 509 struct flag_info *sflag_list ATTRIBUTE_UNUSED, 510 lang_input_statement_type *file, 511 void *output) 512 { 513 lang_section_bst_type *node; 514 lang_section_bst_type **tree; 515 lang_output_section_statement_type *os; 516 517 os = (lang_output_section_statement_type *) output; 518 519 if (unique_section_p (section, os)) 520 return; 521 522 node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type)); 523 node->left = 0; 524 node->right = 0; 525 node->section = section; 526 527 tree = wild_sort_fast (ptr, sec, file, section); 528 if (tree != NULL) 529 *tree = node; 530 } 531 532 /* Convert a sorted sections' BST back to list form. */ 533 534 static void 535 output_section_callback_tree_to_list (lang_wild_statement_type *ptr, 536 lang_section_bst_type *tree, 537 void *output) 538 { 539 if (tree->left) 540 output_section_callback_tree_to_list (ptr, tree->left, output); 541 542 lang_add_section (&ptr->children, tree->section, NULL, 543 (lang_output_section_statement_type *) output); 544 545 if (tree->right) 546 output_section_callback_tree_to_list (ptr, tree->right, output); 547 548 free (tree); 549 } 550 551 /* Specialized, optimized routines for handling different kinds of 552 wildcards */ 553 554 static void 555 walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr, 556 lang_input_statement_type *file, 557 callback_t callback, 558 void *data) 559 { 560 /* We can just do a hash lookup for the section with the right name. 561 But if that lookup discovers more than one section with the name 562 (should be rare), we fall back to the general algorithm because 563 we would otherwise have to sort the sections to make sure they 564 get processed in the bfd's order. */ 565 bfd_boolean multiple_sections_found; 566 struct wildcard_list *sec0 = ptr->handler_data[0]; 567 asection *s0 = find_section (file, sec0, &multiple_sections_found); 568 569 if (multiple_sections_found) 570 walk_wild_section_general (ptr, file, callback, data); 571 else if (s0) 572 walk_wild_consider_section (ptr, file, s0, sec0, callback, data); 573 } 574 575 static void 576 walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr, 577 lang_input_statement_type *file, 578 callback_t callback, 579 void *data) 580 { 581 asection *s; 582 struct wildcard_list *wildsec0 = ptr->handler_data[0]; 583 584 for (s = file->the_bfd->sections; s != NULL; s = s->next) 585 { 586 const char *sname = bfd_get_section_name (file->the_bfd, s); 587 bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname); 588 589 if (!skip) 590 walk_wild_consider_section (ptr, file, s, wildsec0, callback, data); 591 } 592 } 593 594 static void 595 walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr, 596 lang_input_statement_type *file, 597 callback_t callback, 598 void *data) 599 { 600 asection *s; 601 struct wildcard_list *sec0 = ptr->handler_data[0]; 602 struct wildcard_list *wildsec1 = ptr->handler_data[1]; 603 bfd_boolean multiple_sections_found; 604 asection *s0 = find_section (file, sec0, &multiple_sections_found); 605 606 if (multiple_sections_found) 607 { 608 walk_wild_section_general (ptr, file, callback, data); 609 return; 610 } 611 612 /* Note that if the section was not found, s0 is NULL and 613 we'll simply never succeed the s == s0 test below. */ 614 for (s = file->the_bfd->sections; s != NULL; s = s->next) 615 { 616 /* Recall that in this code path, a section cannot satisfy more 617 than one spec, so if s == s0 then it cannot match 618 wildspec1. */ 619 if (s == s0) 620 walk_wild_consider_section (ptr, file, s, sec0, callback, data); 621 else 622 { 623 const char *sname = bfd_get_section_name (file->the_bfd, s); 624 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname); 625 626 if (!skip) 627 walk_wild_consider_section (ptr, file, s, wildsec1, callback, 628 data); 629 } 630 } 631 } 632 633 static void 634 walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr, 635 lang_input_statement_type *file, 636 callback_t callback, 637 void *data) 638 { 639 asection *s; 640 struct wildcard_list *sec0 = ptr->handler_data[0]; 641 struct wildcard_list *wildsec1 = ptr->handler_data[1]; 642 struct wildcard_list *wildsec2 = ptr->handler_data[2]; 643 bfd_boolean multiple_sections_found; 644 asection *s0 = find_section (file, sec0, &multiple_sections_found); 645 646 if (multiple_sections_found) 647 { 648 walk_wild_section_general (ptr, file, callback, data); 649 return; 650 } 651 652 for (s = file->the_bfd->sections; s != NULL; s = s->next) 653 { 654 if (s == s0) 655 walk_wild_consider_section (ptr, file, s, sec0, callback, data); 656 else 657 { 658 const char *sname = bfd_get_section_name (file->the_bfd, s); 659 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname); 660 661 if (!skip) 662 walk_wild_consider_section (ptr, file, s, wildsec1, callback, data); 663 else 664 { 665 skip = !match_simple_wild (wildsec2->spec.name, sname); 666 if (!skip) 667 walk_wild_consider_section (ptr, file, s, wildsec2, callback, 668 data); 669 } 670 } 671 } 672 } 673 674 static void 675 walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr, 676 lang_input_statement_type *file, 677 callback_t callback, 678 void *data) 679 { 680 asection *s; 681 struct wildcard_list *sec0 = ptr->handler_data[0]; 682 struct wildcard_list *sec1 = ptr->handler_data[1]; 683 struct wildcard_list *wildsec2 = ptr->handler_data[2]; 684 struct wildcard_list *wildsec3 = ptr->handler_data[3]; 685 bfd_boolean multiple_sections_found; 686 asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1; 687 688 if (multiple_sections_found) 689 { 690 walk_wild_section_general (ptr, file, callback, data); 691 return; 692 } 693 694 s1 = find_section (file, sec1, &multiple_sections_found); 695 if (multiple_sections_found) 696 { 697 walk_wild_section_general (ptr, file, callback, data); 698 return; 699 } 700 701 for (s = file->the_bfd->sections; s != NULL; s = s->next) 702 { 703 if (s == s0) 704 walk_wild_consider_section (ptr, file, s, sec0, callback, data); 705 else 706 if (s == s1) 707 walk_wild_consider_section (ptr, file, s, sec1, callback, data); 708 else 709 { 710 const char *sname = bfd_get_section_name (file->the_bfd, s); 711 bfd_boolean skip = !match_simple_wild (wildsec2->spec.name, 712 sname); 713 714 if (!skip) 715 walk_wild_consider_section (ptr, file, s, wildsec2, callback, 716 data); 717 else 718 { 719 skip = !match_simple_wild (wildsec3->spec.name, sname); 720 if (!skip) 721 walk_wild_consider_section (ptr, file, s, wildsec3, 722 callback, data); 723 } 724 } 725 } 726 } 727 728 static void 729 walk_wild_section (lang_wild_statement_type *ptr, 730 lang_input_statement_type *file, 731 callback_t callback, 732 void *data) 733 { 734 if (file->flags.just_syms) 735 return; 736 737 (*ptr->walk_wild_section_handler) (ptr, file, callback, data); 738 } 739 740 /* Returns TRUE when name1 is a wildcard spec that might match 741 something name2 can match. We're conservative: we return FALSE 742 only if the prefixes of name1 and name2 are different up to the 743 first wildcard character. */ 744 745 static bfd_boolean 746 wild_spec_can_overlap (const char *name1, const char *name2) 747 { 748 size_t prefix1_len = strcspn (name1, "?*["); 749 size_t prefix2_len = strcspn (name2, "?*["); 750 size_t min_prefix_len; 751 752 /* Note that if there is no wildcard character, then we treat the 753 terminating 0 as part of the prefix. Thus ".text" won't match 754 ".text." or ".text.*", for example. */ 755 if (name1[prefix1_len] == '\0') 756 prefix1_len++; 757 if (name2[prefix2_len] == '\0') 758 prefix2_len++; 759 760 min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len; 761 762 return memcmp (name1, name2, min_prefix_len) == 0; 763 } 764 765 /* Select specialized code to handle various kinds of wildcard 766 statements. */ 767 768 static void 769 analyze_walk_wild_section_handler (lang_wild_statement_type *ptr) 770 { 771 int sec_count = 0; 772 int wild_name_count = 0; 773 struct wildcard_list *sec; 774 int signature; 775 int data_counter; 776 777 ptr->walk_wild_section_handler = walk_wild_section_general; 778 ptr->handler_data[0] = NULL; 779 ptr->handler_data[1] = NULL; 780 ptr->handler_data[2] = NULL; 781 ptr->handler_data[3] = NULL; 782 ptr->tree = NULL; 783 784 /* Count how many wildcard_specs there are, and how many of those 785 actually use wildcards in the name. Also, bail out if any of the 786 wildcard names are NULL. (Can this actually happen? 787 walk_wild_section used to test for it.) And bail out if any 788 of the wildcards are more complex than a simple string 789 ending in a single '*'. */ 790 for (sec = ptr->section_list; sec != NULL; sec = sec->next) 791 { 792 ++sec_count; 793 if (sec->spec.name == NULL) 794 return; 795 if (wildcardp (sec->spec.name)) 796 { 797 ++wild_name_count; 798 if (!is_simple_wild (sec->spec.name)) 799 return; 800 } 801 } 802 803 /* The zero-spec case would be easy to optimize but it doesn't 804 happen in practice. Likewise, more than 4 specs doesn't 805 happen in practice. */ 806 if (sec_count == 0 || sec_count > 4) 807 return; 808 809 /* Check that no two specs can match the same section. */ 810 for (sec = ptr->section_list; sec != NULL; sec = sec->next) 811 { 812 struct wildcard_list *sec2; 813 for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next) 814 { 815 if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name)) 816 return; 817 } 818 } 819 820 signature = (sec_count << 8) + wild_name_count; 821 switch (signature) 822 { 823 case 0x0100: 824 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0; 825 break; 826 case 0x0101: 827 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1; 828 break; 829 case 0x0201: 830 ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1; 831 break; 832 case 0x0302: 833 ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2; 834 break; 835 case 0x0402: 836 ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2; 837 break; 838 default: 839 return; 840 } 841 842 /* Now fill the data array with pointers to the specs, first the 843 specs with non-wildcard names, then the specs with wildcard 844 names. It's OK to process the specs in different order from the 845 given order, because we've already determined that no section 846 will match more than one spec. */ 847 data_counter = 0; 848 for (sec = ptr->section_list; sec != NULL; sec = sec->next) 849 if (!wildcardp (sec->spec.name)) 850 ptr->handler_data[data_counter++] = sec; 851 for (sec = ptr->section_list; sec != NULL; sec = sec->next) 852 if (wildcardp (sec->spec.name)) 853 ptr->handler_data[data_counter++] = sec; 854 } 855 856 /* Handle a wild statement for a single file F. */ 857 858 static void 859 walk_wild_file (lang_wild_statement_type *s, 860 lang_input_statement_type *f, 861 callback_t callback, 862 void *data) 863 { 864 if (f->the_bfd == NULL 865 || !bfd_check_format (f->the_bfd, bfd_archive)) 866 walk_wild_section (s, f, callback, data); 867 else 868 { 869 bfd *member; 870 871 /* This is an archive file. We must map each member of the 872 archive separately. */ 873 member = bfd_openr_next_archived_file (f->the_bfd, NULL); 874 while (member != NULL) 875 { 876 /* When lookup_name is called, it will call the add_symbols 877 entry point for the archive. For each element of the 878 archive which is included, BFD will call ldlang_add_file, 879 which will set the usrdata field of the member to the 880 lang_input_statement. */ 881 if (member->usrdata != NULL) 882 { 883 walk_wild_section (s, 884 (lang_input_statement_type *) member->usrdata, 885 callback, data); 886 } 887 888 member = bfd_openr_next_archived_file (f->the_bfd, member); 889 } 890 } 891 } 892 893 static void 894 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data) 895 { 896 const char *file_spec = s->filename; 897 char *p; 898 899 if (file_spec == NULL) 900 { 901 /* Perform the iteration over all files in the list. */ 902 LANG_FOR_EACH_INPUT_STATEMENT (f) 903 { 904 walk_wild_file (s, f, callback, data); 905 } 906 } 907 else if ((p = archive_path (file_spec)) != NULL) 908 { 909 LANG_FOR_EACH_INPUT_STATEMENT (f) 910 { 911 if (input_statement_is_archive_path (file_spec, p, f)) 912 walk_wild_file (s, f, callback, data); 913 } 914 } 915 else if (wildcardp (file_spec)) 916 { 917 LANG_FOR_EACH_INPUT_STATEMENT (f) 918 { 919 if (fnmatch (file_spec, f->filename, 0) == 0) 920 walk_wild_file (s, f, callback, data); 921 } 922 } 923 else 924 { 925 lang_input_statement_type *f; 926 927 /* Perform the iteration over a single file. */ 928 f = lookup_name (file_spec); 929 if (f) 930 walk_wild_file (s, f, callback, data); 931 } 932 } 933 934 /* lang_for_each_statement walks the parse tree and calls the provided 935 function for each node, except those inside output section statements 936 with constraint set to -1. */ 937 938 void 939 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *), 940 lang_statement_union_type *s) 941 { 942 for (; s != NULL; s = s->header.next) 943 { 944 func (s); 945 946 switch (s->header.type) 947 { 948 case lang_constructors_statement_enum: 949 lang_for_each_statement_worker (func, constructor_list.head); 950 break; 951 case lang_output_section_statement_enum: 952 if (s->output_section_statement.constraint != -1) 953 lang_for_each_statement_worker 954 (func, s->output_section_statement.children.head); 955 break; 956 case lang_wild_statement_enum: 957 lang_for_each_statement_worker (func, 958 s->wild_statement.children.head); 959 break; 960 case lang_group_statement_enum: 961 lang_for_each_statement_worker (func, 962 s->group_statement.children.head); 963 break; 964 case lang_data_statement_enum: 965 case lang_reloc_statement_enum: 966 case lang_object_symbols_statement_enum: 967 case lang_output_statement_enum: 968 case lang_target_statement_enum: 969 case lang_input_section_enum: 970 case lang_input_statement_enum: 971 case lang_assignment_statement_enum: 972 case lang_padding_statement_enum: 973 case lang_address_statement_enum: 974 case lang_fill_statement_enum: 975 case lang_insert_statement_enum: 976 break; 977 default: 978 FAIL (); 979 break; 980 } 981 } 982 } 983 984 void 985 lang_for_each_statement (void (*func) (lang_statement_union_type *)) 986 { 987 lang_for_each_statement_worker (func, statement_list.head); 988 } 989 990 /*----------------------------------------------------------------------*/ 991 992 void 993 lang_list_init (lang_statement_list_type *list) 994 { 995 list->head = NULL; 996 list->tail = &list->head; 997 } 998 999 void 1000 push_stat_ptr (lang_statement_list_type *new_ptr) 1001 { 1002 if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0])) 1003 abort (); 1004 *stat_save_ptr++ = stat_ptr; 1005 stat_ptr = new_ptr; 1006 } 1007 1008 void 1009 pop_stat_ptr (void) 1010 { 1011 if (stat_save_ptr <= stat_save) 1012 abort (); 1013 stat_ptr = *--stat_save_ptr; 1014 } 1015 1016 /* Build a new statement node for the parse tree. */ 1017 1018 static lang_statement_union_type * 1019 new_statement (enum statement_enum type, 1020 size_t size, 1021 lang_statement_list_type *list) 1022 { 1023 lang_statement_union_type *new_stmt; 1024 1025 new_stmt = (lang_statement_union_type *) stat_alloc (size); 1026 new_stmt->header.type = type; 1027 new_stmt->header.next = NULL; 1028 lang_statement_append (list, new_stmt, &new_stmt->header.next); 1029 return new_stmt; 1030 } 1031 1032 /* Build a new input file node for the language. There are several 1033 ways in which we treat an input file, eg, we only look at symbols, 1034 or prefix it with a -l etc. 1035 1036 We can be supplied with requests for input files more than once; 1037 they may, for example be split over several lines like foo.o(.text) 1038 foo.o(.data) etc, so when asked for a file we check that we haven't 1039 got it already so we don't duplicate the bfd. */ 1040 1041 static lang_input_statement_type * 1042 new_afile (const char *name, 1043 lang_input_file_enum_type file_type, 1044 const char *target, 1045 bfd_boolean add_to_list) 1046 { 1047 lang_input_statement_type *p; 1048 1049 lang_has_input_file = TRUE; 1050 1051 if (add_to_list) 1052 p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr); 1053 else 1054 { 1055 p = (lang_input_statement_type *) 1056 stat_alloc (sizeof (lang_input_statement_type)); 1057 p->header.type = lang_input_statement_enum; 1058 p->header.next = NULL; 1059 } 1060 1061 memset (&p->the_bfd, 0, 1062 sizeof (*p) - offsetof (lang_input_statement_type, the_bfd)); 1063 p->target = target; 1064 p->flags.dynamic = input_flags.dynamic; 1065 p->flags.add_DT_NEEDED_for_dynamic = input_flags.add_DT_NEEDED_for_dynamic; 1066 p->flags.add_DT_NEEDED_for_regular = input_flags.add_DT_NEEDED_for_regular; 1067 p->flags.whole_archive = input_flags.whole_archive; 1068 p->flags.sysrooted = input_flags.sysrooted; 1069 1070 switch (file_type) 1071 { 1072 case lang_input_file_is_symbols_only_enum: 1073 p->filename = name; 1074 p->local_sym_name = name; 1075 p->flags.real = TRUE; 1076 p->flags.just_syms = TRUE; 1077 break; 1078 case lang_input_file_is_fake_enum: 1079 p->filename = name; 1080 p->local_sym_name = name; 1081 break; 1082 case lang_input_file_is_l_enum: 1083 if (name[0] == ':' && name[1] != '\0') 1084 { 1085 p->filename = name + 1; 1086 p->flags.full_name_provided = TRUE; 1087 } 1088 else 1089 p->filename = name; 1090 p->local_sym_name = concat ("-l", name, (const char *) NULL); 1091 p->flags.maybe_archive = TRUE; 1092 p->flags.real = TRUE; 1093 p->flags.search_dirs = TRUE; 1094 break; 1095 case lang_input_file_is_marker_enum: 1096 p->filename = name; 1097 p->local_sym_name = name; 1098 p->flags.search_dirs = TRUE; 1099 break; 1100 case lang_input_file_is_search_file_enum: 1101 p->filename = name; 1102 p->local_sym_name = name; 1103 p->flags.real = TRUE; 1104 p->flags.search_dirs = TRUE; 1105 break; 1106 case lang_input_file_is_file_enum: 1107 p->filename = name; 1108 p->local_sym_name = name; 1109 p->flags.real = TRUE; 1110 break; 1111 default: 1112 FAIL (); 1113 } 1114 1115 lang_statement_append (&input_file_chain, 1116 (lang_statement_union_type *) p, 1117 &p->next_real_file); 1118 return p; 1119 } 1120 1121 lang_input_statement_type * 1122 lang_add_input_file (const char *name, 1123 lang_input_file_enum_type file_type, 1124 const char *target) 1125 { 1126 if (name != NULL && *name == '=') 1127 { 1128 lang_input_statement_type *ret; 1129 char *sysrooted_name 1130 = concat (ld_sysroot, name + 1, (const char *) NULL); 1131 1132 /* We've now forcibly prepended the sysroot, making the input 1133 file independent of the context. Therefore, temporarily 1134 force a non-sysrooted context for this statement, so it won't 1135 get the sysroot prepended again when opened. (N.B. if it's a 1136 script, any child nodes with input files starting with "/" 1137 will be handled as "sysrooted" as they'll be found to be 1138 within the sysroot subdirectory.) */ 1139 unsigned int outer_sysrooted = input_flags.sysrooted; 1140 input_flags.sysrooted = 0; 1141 ret = new_afile (sysrooted_name, file_type, target, TRUE); 1142 input_flags.sysrooted = outer_sysrooted; 1143 return ret; 1144 } 1145 1146 return new_afile (name, file_type, target, TRUE); 1147 } 1148 1149 struct out_section_hash_entry 1150 { 1151 struct bfd_hash_entry root; 1152 lang_statement_union_type s; 1153 }; 1154 1155 /* The hash table. */ 1156 1157 static struct bfd_hash_table output_section_statement_table; 1158 1159 /* Support routines for the hash table used by lang_output_section_find, 1160 initialize the table, fill in an entry and remove the table. */ 1161 1162 static struct bfd_hash_entry * 1163 output_section_statement_newfunc (struct bfd_hash_entry *entry, 1164 struct bfd_hash_table *table, 1165 const char *string) 1166 { 1167 lang_output_section_statement_type **nextp; 1168 struct out_section_hash_entry *ret; 1169 1170 if (entry == NULL) 1171 { 1172 entry = (struct bfd_hash_entry *) bfd_hash_allocate (table, 1173 sizeof (*ret)); 1174 if (entry == NULL) 1175 return entry; 1176 } 1177 1178 entry = bfd_hash_newfunc (entry, table, string); 1179 if (entry == NULL) 1180 return entry; 1181 1182 ret = (struct out_section_hash_entry *) entry; 1183 memset (&ret->s, 0, sizeof (ret->s)); 1184 ret->s.header.type = lang_output_section_statement_enum; 1185 ret->s.output_section_statement.subsection_alignment = -1; 1186 ret->s.output_section_statement.section_alignment = -1; 1187 ret->s.output_section_statement.block_value = 1; 1188 lang_list_init (&ret->s.output_section_statement.children); 1189 lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next); 1190 1191 /* For every output section statement added to the list, except the 1192 first one, lang_output_section_statement.tail points to the "next" 1193 field of the last element of the list. */ 1194 if (lang_output_section_statement.head != NULL) 1195 ret->s.output_section_statement.prev 1196 = ((lang_output_section_statement_type *) 1197 ((char *) lang_output_section_statement.tail 1198 - offsetof (lang_output_section_statement_type, next))); 1199 1200 /* GCC's strict aliasing rules prevent us from just casting the 1201 address, so we store the pointer in a variable and cast that 1202 instead. */ 1203 nextp = &ret->s.output_section_statement.next; 1204 lang_statement_append (&lang_output_section_statement, 1205 &ret->s, 1206 (lang_statement_union_type **) nextp); 1207 return &ret->root; 1208 } 1209 1210 static void 1211 output_section_statement_table_init (void) 1212 { 1213 if (!bfd_hash_table_init_n (&output_section_statement_table, 1214 output_section_statement_newfunc, 1215 sizeof (struct out_section_hash_entry), 1216 61)) 1217 einfo (_("%P%F: can not create hash table: %E\n")); 1218 } 1219 1220 static void 1221 output_section_statement_table_free (void) 1222 { 1223 bfd_hash_table_free (&output_section_statement_table); 1224 } 1225 1226 /* Build enough state so that the parser can build its tree. */ 1227 1228 void 1229 lang_init (void) 1230 { 1231 obstack_begin (&stat_obstack, 1000); 1232 1233 stat_ptr = &statement_list; 1234 1235 output_section_statement_table_init (); 1236 1237 lang_list_init (stat_ptr); 1238 1239 lang_list_init (&input_file_chain); 1240 lang_list_init (&lang_output_section_statement); 1241 lang_list_init (&file_chain); 1242 first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum, 1243 NULL); 1244 abs_output_section = 1245 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE); 1246 1247 abs_output_section->bfd_section = bfd_abs_section_ptr; 1248 1249 asneeded_list_head = NULL; 1250 asneeded_list_tail = &asneeded_list_head; 1251 } 1252 1253 void 1254 lang_finish (void) 1255 { 1256 output_section_statement_table_free (); 1257 } 1258 1259 /*---------------------------------------------------------------------- 1260 A region is an area of memory declared with the 1261 MEMORY { name:org=exp, len=exp ... } 1262 syntax. 1263 1264 We maintain a list of all the regions here. 1265 1266 If no regions are specified in the script, then the default is used 1267 which is created when looked up to be the entire data space. 1268 1269 If create is true we are creating a region inside a MEMORY block. 1270 In this case it is probably an error to create a region that has 1271 already been created. If we are not inside a MEMORY block it is 1272 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION) 1273 and so we issue a warning. 1274 1275 Each region has at least one name. The first name is either 1276 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add 1277 alias names to an existing region within a script with 1278 REGION_ALIAS (alias, region_name). Each name corresponds to at most one 1279 region. */ 1280 1281 static lang_memory_region_type *lang_memory_region_list; 1282 static lang_memory_region_type **lang_memory_region_list_tail 1283 = &lang_memory_region_list; 1284 1285 lang_memory_region_type * 1286 lang_memory_region_lookup (const char *const name, bfd_boolean create) 1287 { 1288 lang_memory_region_name *n; 1289 lang_memory_region_type *r; 1290 lang_memory_region_type *new_region; 1291 1292 /* NAME is NULL for LMA memspecs if no region was specified. */ 1293 if (name == NULL) 1294 return NULL; 1295 1296 for (r = lang_memory_region_list; r != NULL; r = r->next) 1297 for (n = &r->name_list; n != NULL; n = n->next) 1298 if (strcmp (n->name, name) == 0) 1299 { 1300 if (create) 1301 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"), 1302 NULL, name); 1303 return r; 1304 } 1305 1306 if (!create && strcmp (name, DEFAULT_MEMORY_REGION)) 1307 einfo (_("%P:%S: warning: memory region `%s' not declared\n"), 1308 NULL, name); 1309 1310 new_region = (lang_memory_region_type *) 1311 stat_alloc (sizeof (lang_memory_region_type)); 1312 1313 new_region->name_list.name = xstrdup (name); 1314 new_region->name_list.next = NULL; 1315 new_region->next = NULL; 1316 new_region->origin_exp = NULL; 1317 new_region->origin = 0; 1318 new_region->length_exp = NULL; 1319 new_region->length = ~(bfd_size_type) 0; 1320 new_region->current = 0; 1321 new_region->last_os = NULL; 1322 new_region->flags = 0; 1323 new_region->not_flags = 0; 1324 new_region->had_full_message = FALSE; 1325 1326 *lang_memory_region_list_tail = new_region; 1327 lang_memory_region_list_tail = &new_region->next; 1328 1329 return new_region; 1330 } 1331 1332 void 1333 lang_memory_region_alias (const char *alias, const char *region_name) 1334 { 1335 lang_memory_region_name *n; 1336 lang_memory_region_type *r; 1337 lang_memory_region_type *region; 1338 1339 /* The default region must be unique. This ensures that it is not necessary 1340 to iterate through the name list if someone wants the check if a region is 1341 the default memory region. */ 1342 if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0 1343 || strcmp (alias, DEFAULT_MEMORY_REGION) == 0) 1344 einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL); 1345 1346 /* Look for the target region and check if the alias is not already 1347 in use. */ 1348 region = NULL; 1349 for (r = lang_memory_region_list; r != NULL; r = r->next) 1350 for (n = &r->name_list; n != NULL; n = n->next) 1351 { 1352 if (region == NULL && strcmp (n->name, region_name) == 0) 1353 region = r; 1354 if (strcmp (n->name, alias) == 0) 1355 einfo (_("%F%P:%S: error: redefinition of memory region " 1356 "alias `%s'\n"), 1357 NULL, alias); 1358 } 1359 1360 /* Check if the target region exists. */ 1361 if (region == NULL) 1362 einfo (_("%F%P:%S: error: memory region `%s' " 1363 "for alias `%s' does not exist\n"), 1364 NULL, region_name, alias); 1365 1366 /* Add alias to region name list. */ 1367 n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name)); 1368 n->name = xstrdup (alias); 1369 n->next = region->name_list.next; 1370 region->name_list.next = n; 1371 } 1372 1373 static lang_memory_region_type * 1374 lang_memory_default (asection *section) 1375 { 1376 lang_memory_region_type *p; 1377 1378 flagword sec_flags = section->flags; 1379 1380 /* Override SEC_DATA to mean a writable section. */ 1381 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC) 1382 sec_flags |= SEC_DATA; 1383 1384 for (p = lang_memory_region_list; p != NULL; p = p->next) 1385 { 1386 if ((p->flags & sec_flags) != 0 1387 && (p->not_flags & sec_flags) == 0) 1388 { 1389 return p; 1390 } 1391 } 1392 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE); 1393 } 1394 1395 /* Get the output section statement directly from the userdata. */ 1396 1397 lang_output_section_statement_type * 1398 lang_output_section_get (const asection *output_section) 1399 { 1400 return get_userdata (output_section); 1401 } 1402 1403 /* Find or create an output_section_statement with the given NAME. 1404 If CONSTRAINT is non-zero match one with that constraint, otherwise 1405 match any non-negative constraint. If CREATE, always make a 1406 new output_section_statement for SPECIAL CONSTRAINT. */ 1407 1408 lang_output_section_statement_type * 1409 lang_output_section_statement_lookup (const char *name, 1410 int constraint, 1411 bfd_boolean create) 1412 { 1413 struct out_section_hash_entry *entry; 1414 1415 entry = ((struct out_section_hash_entry *) 1416 bfd_hash_lookup (&output_section_statement_table, name, 1417 create, FALSE)); 1418 if (entry == NULL) 1419 { 1420 if (create) 1421 einfo (_("%P%F: failed creating section `%s': %E\n"), name); 1422 return NULL; 1423 } 1424 1425 if (entry->s.output_section_statement.name != NULL) 1426 { 1427 /* We have a section of this name, but it might not have the correct 1428 constraint. */ 1429 struct out_section_hash_entry *last_ent; 1430 1431 name = entry->s.output_section_statement.name; 1432 if (create && constraint == SPECIAL) 1433 /* Not traversing to the end reverses the order of the second 1434 and subsequent SPECIAL sections in the hash table chain, 1435 but that shouldn't matter. */ 1436 last_ent = entry; 1437 else 1438 do 1439 { 1440 if (constraint == entry->s.output_section_statement.constraint 1441 || (constraint == 0 1442 && entry->s.output_section_statement.constraint >= 0)) 1443 return &entry->s.output_section_statement; 1444 last_ent = entry; 1445 entry = (struct out_section_hash_entry *) entry->root.next; 1446 } 1447 while (entry != NULL 1448 && name == entry->s.output_section_statement.name); 1449 1450 if (!create) 1451 return NULL; 1452 1453 entry 1454 = ((struct out_section_hash_entry *) 1455 output_section_statement_newfunc (NULL, 1456 &output_section_statement_table, 1457 name)); 1458 if (entry == NULL) 1459 { 1460 einfo (_("%P%F: failed creating section `%s': %E\n"), name); 1461 return NULL; 1462 } 1463 entry->root = last_ent->root; 1464 last_ent->root.next = &entry->root; 1465 } 1466 1467 entry->s.output_section_statement.name = name; 1468 entry->s.output_section_statement.constraint = constraint; 1469 return &entry->s.output_section_statement; 1470 } 1471 1472 /* Find the next output_section_statement with the same name as OS. 1473 If CONSTRAINT is non-zero, find one with that constraint otherwise 1474 match any non-negative constraint. */ 1475 1476 lang_output_section_statement_type * 1477 next_matching_output_section_statement (lang_output_section_statement_type *os, 1478 int constraint) 1479 { 1480 /* All output_section_statements are actually part of a 1481 struct out_section_hash_entry. */ 1482 struct out_section_hash_entry *entry = (struct out_section_hash_entry *) 1483 ((char *) os 1484 - offsetof (struct out_section_hash_entry, s.output_section_statement)); 1485 const char *name = os->name; 1486 1487 ASSERT (name == entry->root.string); 1488 do 1489 { 1490 entry = (struct out_section_hash_entry *) entry->root.next; 1491 if (entry == NULL 1492 || name != entry->s.output_section_statement.name) 1493 return NULL; 1494 } 1495 while (constraint != entry->s.output_section_statement.constraint 1496 && (constraint != 0 1497 || entry->s.output_section_statement.constraint < 0)); 1498 1499 return &entry->s.output_section_statement; 1500 } 1501 1502 /* A variant of lang_output_section_find used by place_orphan. 1503 Returns the output statement that should precede a new output 1504 statement for SEC. If an exact match is found on certain flags, 1505 sets *EXACT too. */ 1506 1507 lang_output_section_statement_type * 1508 lang_output_section_find_by_flags (const asection *sec, 1509 flagword sec_flags, 1510 lang_output_section_statement_type **exact, 1511 lang_match_sec_type_func match_type) 1512 { 1513 lang_output_section_statement_type *first, *look, *found; 1514 flagword look_flags, differ; 1515 1516 /* We know the first statement on this list is *ABS*. May as well 1517 skip it. */ 1518 first = &lang_output_section_statement.head->output_section_statement; 1519 first = first->next; 1520 1521 /* First try for an exact match. */ 1522 found = NULL; 1523 for (look = first; look; look = look->next) 1524 { 1525 look_flags = look->flags; 1526 if (look->bfd_section != NULL) 1527 { 1528 look_flags = look->bfd_section->flags; 1529 if (match_type && !match_type (link_info.output_bfd, 1530 look->bfd_section, 1531 sec->owner, sec)) 1532 continue; 1533 } 1534 differ = look_flags ^ sec_flags; 1535 if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY 1536 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL))) 1537 found = look; 1538 } 1539 if (found != NULL) 1540 { 1541 if (exact != NULL) 1542 *exact = found; 1543 return found; 1544 } 1545 1546 if ((sec_flags & SEC_CODE) != 0 1547 && (sec_flags & SEC_ALLOC) != 0) 1548 { 1549 /* Try for a rw code section. */ 1550 for (look = first; look; look = look->next) 1551 { 1552 look_flags = look->flags; 1553 if (look->bfd_section != NULL) 1554 { 1555 look_flags = look->bfd_section->flags; 1556 if (match_type && !match_type (link_info.output_bfd, 1557 look->bfd_section, 1558 sec->owner, sec)) 1559 continue; 1560 } 1561 differ = look_flags ^ sec_flags; 1562 if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD 1563 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL))) 1564 found = look; 1565 } 1566 } 1567 else if ((sec_flags & SEC_READONLY) != 0 1568 && (sec_flags & SEC_ALLOC) != 0) 1569 { 1570 /* .rodata can go after .text, .sdata2 after .rodata. */ 1571 for (look = first; look; look = look->next) 1572 { 1573 look_flags = look->flags; 1574 if (look->bfd_section != NULL) 1575 { 1576 look_flags = look->bfd_section->flags; 1577 if (match_type && !match_type (link_info.output_bfd, 1578 look->bfd_section, 1579 sec->owner, sec)) 1580 continue; 1581 } 1582 differ = look_flags ^ sec_flags; 1583 if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD 1584 | SEC_READONLY | SEC_SMALL_DATA)) 1585 || (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD 1586 | SEC_READONLY)) 1587 && !(look_flags & SEC_SMALL_DATA))) 1588 found = look; 1589 } 1590 } 1591 else if ((sec_flags & SEC_THREAD_LOCAL) != 0 1592 && (sec_flags & SEC_ALLOC) != 0) 1593 { 1594 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss 1595 as if it were a loaded section, and don't use match_type. */ 1596 bfd_boolean seen_thread_local = FALSE; 1597 1598 match_type = NULL; 1599 for (look = first; look; look = look->next) 1600 { 1601 look_flags = look->flags; 1602 if (look->bfd_section != NULL) 1603 look_flags = look->bfd_section->flags; 1604 1605 differ = look_flags ^ (sec_flags | SEC_LOAD | SEC_HAS_CONTENTS); 1606 if (!(differ & (SEC_THREAD_LOCAL | SEC_ALLOC))) 1607 { 1608 /* .tdata and .tbss must be adjacent and in that order. */ 1609 if (!(look_flags & SEC_LOAD) 1610 && (sec_flags & SEC_LOAD)) 1611 /* ..so if we're at a .tbss section and we're placing 1612 a .tdata section stop looking and return the 1613 previous section. */ 1614 break; 1615 found = look; 1616 seen_thread_local = TRUE; 1617 } 1618 else if (seen_thread_local) 1619 break; 1620 else if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD))) 1621 found = look; 1622 } 1623 } 1624 else if ((sec_flags & SEC_SMALL_DATA) != 0 1625 && (sec_flags & SEC_ALLOC) != 0) 1626 { 1627 /* .sdata goes after .data, .sbss after .sdata. */ 1628 for (look = first; look; look = look->next) 1629 { 1630 look_flags = look->flags; 1631 if (look->bfd_section != NULL) 1632 { 1633 look_flags = look->bfd_section->flags; 1634 if (match_type && !match_type (link_info.output_bfd, 1635 look->bfd_section, 1636 sec->owner, sec)) 1637 continue; 1638 } 1639 differ = look_flags ^ sec_flags; 1640 if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD 1641 | SEC_THREAD_LOCAL)) 1642 || ((look_flags & SEC_SMALL_DATA) 1643 && !(sec_flags & SEC_HAS_CONTENTS))) 1644 found = look; 1645 } 1646 } 1647 else if ((sec_flags & SEC_HAS_CONTENTS) != 0 1648 && (sec_flags & SEC_ALLOC) != 0) 1649 { 1650 /* .data goes after .rodata. */ 1651 for (look = first; look; look = look->next) 1652 { 1653 look_flags = look->flags; 1654 if (look->bfd_section != NULL) 1655 { 1656 look_flags = look->bfd_section->flags; 1657 if (match_type && !match_type (link_info.output_bfd, 1658 look->bfd_section, 1659 sec->owner, sec)) 1660 continue; 1661 } 1662 differ = look_flags ^ sec_flags; 1663 if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD 1664 | SEC_SMALL_DATA | SEC_THREAD_LOCAL))) 1665 found = look; 1666 } 1667 } 1668 else if ((sec_flags & SEC_ALLOC) != 0) 1669 { 1670 /* .bss goes after any other alloc section. */ 1671 for (look = first; look; look = look->next) 1672 { 1673 look_flags = look->flags; 1674 if (look->bfd_section != NULL) 1675 { 1676 look_flags = look->bfd_section->flags; 1677 if (match_type && !match_type (link_info.output_bfd, 1678 look->bfd_section, 1679 sec->owner, sec)) 1680 continue; 1681 } 1682 differ = look_flags ^ sec_flags; 1683 if (!(differ & SEC_ALLOC)) 1684 found = look; 1685 } 1686 } 1687 else 1688 { 1689 /* non-alloc go last. */ 1690 for (look = first; look; look = look->next) 1691 { 1692 look_flags = look->flags; 1693 if (look->bfd_section != NULL) 1694 look_flags = look->bfd_section->flags; 1695 differ = look_flags ^ sec_flags; 1696 if (!(differ & SEC_DEBUGGING)) 1697 found = look; 1698 } 1699 return found; 1700 } 1701 1702 if (found || !match_type) 1703 return found; 1704 1705 return lang_output_section_find_by_flags (sec, sec_flags, NULL, NULL); 1706 } 1707 1708 /* Find the last output section before given output statement. 1709 Used by place_orphan. */ 1710 1711 static asection * 1712 output_prev_sec_find (lang_output_section_statement_type *os) 1713 { 1714 lang_output_section_statement_type *lookup; 1715 1716 for (lookup = os->prev; lookup != NULL; lookup = lookup->prev) 1717 { 1718 if (lookup->constraint < 0) 1719 continue; 1720 1721 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL) 1722 return lookup->bfd_section; 1723 } 1724 1725 return NULL; 1726 } 1727 1728 /* Look for a suitable place for a new output section statement. The 1729 idea is to skip over anything that might be inside a SECTIONS {} 1730 statement in a script, before we find another output section 1731 statement. Assignments to "dot" before an output section statement 1732 are assumed to belong to it, except in two cases; The first 1733 assignment to dot, and assignments before non-alloc sections. 1734 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or 1735 similar assignments that set the initial address, or we might 1736 insert non-alloc note sections among assignments setting end of 1737 image symbols. */ 1738 1739 static lang_statement_union_type ** 1740 insert_os_after (lang_output_section_statement_type *after) 1741 { 1742 lang_statement_union_type **where; 1743 lang_statement_union_type **assign = NULL; 1744 bfd_boolean ignore_first; 1745 1746 ignore_first 1747 = after == &lang_output_section_statement.head->output_section_statement; 1748 1749 for (where = &after->header.next; 1750 *where != NULL; 1751 where = &(*where)->header.next) 1752 { 1753 switch ((*where)->header.type) 1754 { 1755 case lang_assignment_statement_enum: 1756 if (assign == NULL) 1757 { 1758 lang_assignment_statement_type *ass; 1759 1760 ass = &(*where)->assignment_statement; 1761 if (ass->exp->type.node_class != etree_assert 1762 && ass->exp->assign.dst[0] == '.' 1763 && ass->exp->assign.dst[1] == 0 1764 && !ignore_first) 1765 assign = where; 1766 } 1767 ignore_first = FALSE; 1768 continue; 1769 case lang_wild_statement_enum: 1770 case lang_input_section_enum: 1771 case lang_object_symbols_statement_enum: 1772 case lang_fill_statement_enum: 1773 case lang_data_statement_enum: 1774 case lang_reloc_statement_enum: 1775 case lang_padding_statement_enum: 1776 case lang_constructors_statement_enum: 1777 assign = NULL; 1778 continue; 1779 case lang_output_section_statement_enum: 1780 if (assign != NULL) 1781 { 1782 asection *s = (*where)->output_section_statement.bfd_section; 1783 1784 if (s == NULL 1785 || s->map_head.s == NULL 1786 || (s->flags & SEC_ALLOC) != 0) 1787 where = assign; 1788 } 1789 break; 1790 case lang_input_statement_enum: 1791 case lang_address_statement_enum: 1792 case lang_target_statement_enum: 1793 case lang_output_statement_enum: 1794 case lang_group_statement_enum: 1795 case lang_insert_statement_enum: 1796 continue; 1797 } 1798 break; 1799 } 1800 1801 return where; 1802 } 1803 1804 lang_output_section_statement_type * 1805 lang_insert_orphan (asection *s, 1806 const char *secname, 1807 int constraint, 1808 lang_output_section_statement_type *after, 1809 struct orphan_save *place, 1810 etree_type *address, 1811 lang_statement_list_type *add_child) 1812 { 1813 lang_statement_list_type add; 1814 const char *ps; 1815 lang_assignment_statement_type *start_assign; 1816 lang_output_section_statement_type *os; 1817 lang_output_section_statement_type **os_tail; 1818 1819 /* If we have found an appropriate place for the output section 1820 statements for this orphan, add them to our own private list, 1821 inserting them later into the global statement list. */ 1822 if (after != NULL) 1823 { 1824 lang_list_init (&add); 1825 push_stat_ptr (&add); 1826 } 1827 1828 if (bfd_link_relocatable (&link_info) 1829 || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0) 1830 address = exp_intop (0); 1831 1832 os_tail = ((lang_output_section_statement_type **) 1833 lang_output_section_statement.tail); 1834 os = lang_enter_output_section_statement (secname, address, normal_section, 1835 NULL, NULL, NULL, constraint, 0); 1836 1837 ps = NULL; 1838 start_assign = NULL; 1839 if (config.build_constructors && *os_tail == os) 1840 { 1841 /* If the name of the section is representable in C, then create 1842 symbols to mark the start and the end of the section. */ 1843 for (ps = secname; *ps != '\0'; ps++) 1844 if (!ISALNUM ((unsigned char) *ps) && *ps != '_') 1845 break; 1846 if (*ps == '\0') 1847 { 1848 char *symname; 1849 1850 symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1); 1851 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd); 1852 sprintf (symname + (symname[0] != 0), "__start_%s", secname); 1853 start_assign 1854 = lang_add_assignment (exp_provide (symname, 1855 exp_nameop (NAME, "."), 1856 FALSE)); 1857 } 1858 } 1859 1860 if (add_child == NULL) 1861 add_child = &os->children; 1862 lang_add_section (add_child, s, NULL, os); 1863 1864 if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0) 1865 { 1866 const char *region = (after->region 1867 ? after->region->name_list.name 1868 : DEFAULT_MEMORY_REGION); 1869 const char *lma_region = (after->lma_region 1870 ? after->lma_region->name_list.name 1871 : NULL); 1872 lang_leave_output_section_statement (NULL, region, after->phdrs, 1873 lma_region); 1874 } 1875 else 1876 lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL, 1877 NULL); 1878 1879 if (start_assign != NULL) 1880 { 1881 char *symname; 1882 lang_assignment_statement_type *stop_assign; 1883 bfd_vma dot; 1884 1885 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1); 1886 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd); 1887 sprintf (symname + (symname[0] != 0), "__stop_%s", secname); 1888 stop_assign 1889 = lang_add_assignment (exp_provide (symname, 1890 exp_nameop (NAME, "."), 1891 FALSE)); 1892 /* Evaluate the expression to define the symbol if referenced, 1893 before sizing dynamic sections. */ 1894 dot = os->bfd_section->vma; 1895 exp_fold_tree (start_assign->exp, os->bfd_section, &dot); 1896 dot += TO_ADDR (s->size); 1897 exp_fold_tree (stop_assign->exp, os->bfd_section, &dot); 1898 } 1899 1900 /* Restore the global list pointer. */ 1901 if (after != NULL) 1902 pop_stat_ptr (); 1903 1904 if (after != NULL && os->bfd_section != NULL) 1905 { 1906 asection *snew, *as; 1907 1908 snew = os->bfd_section; 1909 1910 /* Shuffle the bfd section list to make the output file look 1911 neater. This is really only cosmetic. */ 1912 if (place->section == NULL 1913 && after != (&lang_output_section_statement.head 1914 ->output_section_statement)) 1915 { 1916 asection *bfd_section = after->bfd_section; 1917 1918 /* If the output statement hasn't been used to place any input 1919 sections (and thus doesn't have an output bfd_section), 1920 look for the closest prior output statement having an 1921 output section. */ 1922 if (bfd_section == NULL) 1923 bfd_section = output_prev_sec_find (after); 1924 1925 if (bfd_section != NULL && bfd_section != snew) 1926 place->section = &bfd_section->next; 1927 } 1928 1929 if (place->section == NULL) 1930 place->section = &link_info.output_bfd->sections; 1931 1932 as = *place->section; 1933 1934 if (!as) 1935 { 1936 /* Put the section at the end of the list. */ 1937 1938 /* Unlink the section. */ 1939 bfd_section_list_remove (link_info.output_bfd, snew); 1940 1941 /* Now tack it back on in the right place. */ 1942 bfd_section_list_append (link_info.output_bfd, snew); 1943 } 1944 else if (as != snew && as->prev != snew) 1945 { 1946 /* Unlink the section. */ 1947 bfd_section_list_remove (link_info.output_bfd, snew); 1948 1949 /* Now tack it back on in the right place. */ 1950 bfd_section_list_insert_before (link_info.output_bfd, as, snew); 1951 } 1952 1953 /* Save the end of this list. Further ophans of this type will 1954 follow the one we've just added. */ 1955 place->section = &snew->next; 1956 1957 /* The following is non-cosmetic. We try to put the output 1958 statements in some sort of reasonable order here, because they 1959 determine the final load addresses of the orphan sections. 1960 In addition, placing output statements in the wrong order may 1961 require extra segments. For instance, given a typical 1962 situation of all read-only sections placed in one segment and 1963 following that a segment containing all the read-write 1964 sections, we wouldn't want to place an orphan read/write 1965 section before or amongst the read-only ones. */ 1966 if (add.head != NULL) 1967 { 1968 lang_output_section_statement_type *newly_added_os; 1969 1970 if (place->stmt == NULL) 1971 { 1972 lang_statement_union_type **where = insert_os_after (after); 1973 1974 *add.tail = *where; 1975 *where = add.head; 1976 1977 place->os_tail = &after->next; 1978 } 1979 else 1980 { 1981 /* Put it after the last orphan statement we added. */ 1982 *add.tail = *place->stmt; 1983 *place->stmt = add.head; 1984 } 1985 1986 /* Fix the global list pointer if we happened to tack our 1987 new list at the tail. */ 1988 if (*stat_ptr->tail == add.head) 1989 stat_ptr->tail = add.tail; 1990 1991 /* Save the end of this list. */ 1992 place->stmt = add.tail; 1993 1994 /* Do the same for the list of output section statements. */ 1995 newly_added_os = *os_tail; 1996 *os_tail = NULL; 1997 newly_added_os->prev = (lang_output_section_statement_type *) 1998 ((char *) place->os_tail 1999 - offsetof (lang_output_section_statement_type, next)); 2000 newly_added_os->next = *place->os_tail; 2001 if (newly_added_os->next != NULL) 2002 newly_added_os->next->prev = newly_added_os; 2003 *place->os_tail = newly_added_os; 2004 place->os_tail = &newly_added_os->next; 2005 2006 /* Fixing the global list pointer here is a little different. 2007 We added to the list in lang_enter_output_section_statement, 2008 trimmed off the new output_section_statment above when 2009 assigning *os_tail = NULL, but possibly added it back in 2010 the same place when assigning *place->os_tail. */ 2011 if (*os_tail == NULL) 2012 lang_output_section_statement.tail 2013 = (lang_statement_union_type **) os_tail; 2014 } 2015 } 2016 return os; 2017 } 2018 2019 static void 2020 lang_print_asneeded (void) 2021 { 2022 struct asneeded_minfo *m; 2023 char buf[100]; 2024 2025 if (asneeded_list_head == NULL) 2026 return; 2027 2028 sprintf (buf, _("\nAs-needed library included " 2029 "to satisfy reference by file (symbol)\n\n")); 2030 minfo ("%s", buf); 2031 2032 for (m = asneeded_list_head; m != NULL; m = m->next) 2033 { 2034 size_t len; 2035 2036 minfo ("%s", m->soname); 2037 len = strlen (m->soname); 2038 2039 if (len >= 29) 2040 { 2041 print_nl (); 2042 len = 0; 2043 } 2044 while (len < 30) 2045 { 2046 print_space (); 2047 ++len; 2048 } 2049 2050 if (m->ref != NULL) 2051 minfo ("%B ", m->ref); 2052 minfo ("(%T)\n", m->name); 2053 } 2054 } 2055 2056 static void 2057 lang_map_flags (flagword flag) 2058 { 2059 if (flag & SEC_ALLOC) 2060 minfo ("a"); 2061 2062 if (flag & SEC_CODE) 2063 minfo ("x"); 2064 2065 if (flag & SEC_READONLY) 2066 minfo ("r"); 2067 2068 if (flag & SEC_DATA) 2069 minfo ("w"); 2070 2071 if (flag & SEC_LOAD) 2072 minfo ("l"); 2073 } 2074 2075 void 2076 lang_map (void) 2077 { 2078 lang_memory_region_type *m; 2079 bfd_boolean dis_header_printed = FALSE; 2080 2081 LANG_FOR_EACH_INPUT_STATEMENT (file) 2082 { 2083 asection *s; 2084 2085 if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0 2086 || file->flags.just_syms) 2087 continue; 2088 2089 for (s = file->the_bfd->sections; s != NULL; s = s->next) 2090 if ((s->output_section == NULL 2091 || s->output_section->owner != link_info.output_bfd) 2092 && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0) 2093 { 2094 if (!dis_header_printed) 2095 { 2096 fprintf (config.map_file, _("\nDiscarded input sections\n\n")); 2097 dis_header_printed = TRUE; 2098 } 2099 2100 print_input_section (s, TRUE); 2101 } 2102 } 2103 2104 minfo (_("\nMemory Configuration\n\n")); 2105 fprintf (config.map_file, "%-16s %-18s %-18s %s\n", 2106 _("Name"), _("Origin"), _("Length"), _("Attributes")); 2107 2108 for (m = lang_memory_region_list; m != NULL; m = m->next) 2109 { 2110 char buf[100]; 2111 int len; 2112 2113 fprintf (config.map_file, "%-16s ", m->name_list.name); 2114 2115 sprintf_vma (buf, m->origin); 2116 minfo ("0x%s ", buf); 2117 len = strlen (buf); 2118 while (len < 16) 2119 { 2120 print_space (); 2121 ++len; 2122 } 2123 2124 minfo ("0x%V", m->length); 2125 if (m->flags || m->not_flags) 2126 { 2127 #ifndef BFD64 2128 minfo (" "); 2129 #endif 2130 if (m->flags) 2131 { 2132 print_space (); 2133 lang_map_flags (m->flags); 2134 } 2135 2136 if (m->not_flags) 2137 { 2138 minfo (" !"); 2139 lang_map_flags (m->not_flags); 2140 } 2141 } 2142 2143 print_nl (); 2144 } 2145 2146 fprintf (config.map_file, _("\nLinker script and memory map\n\n")); 2147 2148 if (!link_info.reduce_memory_overheads) 2149 { 2150 obstack_begin (&map_obstack, 1000); 2151 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0); 2152 } 2153 lang_statement_iteration++; 2154 print_statements (); 2155 2156 ldemul_extra_map_file_text (link_info.output_bfd, &link_info, 2157 config.map_file); 2158 } 2159 2160 static bfd_boolean 2161 sort_def_symbol (struct bfd_link_hash_entry *hash_entry, 2162 void *info ATTRIBUTE_UNUSED) 2163 { 2164 if ((hash_entry->type == bfd_link_hash_defined 2165 || hash_entry->type == bfd_link_hash_defweak) 2166 && hash_entry->u.def.section->owner != link_info.output_bfd 2167 && hash_entry->u.def.section->owner != NULL) 2168 { 2169 input_section_userdata_type *ud; 2170 struct map_symbol_def *def; 2171 2172 ud = ((input_section_userdata_type *) 2173 get_userdata (hash_entry->u.def.section)); 2174 if (!ud) 2175 { 2176 ud = (input_section_userdata_type *) stat_alloc (sizeof (*ud)); 2177 get_userdata (hash_entry->u.def.section) = ud; 2178 ud->map_symbol_def_tail = &ud->map_symbol_def_head; 2179 ud->map_symbol_def_count = 0; 2180 } 2181 else if (!ud->map_symbol_def_tail) 2182 ud->map_symbol_def_tail = &ud->map_symbol_def_head; 2183 2184 def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def); 2185 def->entry = hash_entry; 2186 *(ud->map_symbol_def_tail) = def; 2187 ud->map_symbol_def_tail = &def->next; 2188 ud->map_symbol_def_count++; 2189 } 2190 return TRUE; 2191 } 2192 2193 /* Initialize an output section. */ 2194 2195 static void 2196 init_os (lang_output_section_statement_type *s, flagword flags) 2197 { 2198 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0) 2199 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME); 2200 2201 if (s->constraint != SPECIAL) 2202 s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name); 2203 if (s->bfd_section == NULL) 2204 s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd, 2205 s->name, flags); 2206 if (s->bfd_section == NULL) 2207 { 2208 einfo (_("%P%F: output format %s cannot represent section" 2209 " called %s: %E\n"), 2210 link_info.output_bfd->xvec->name, s->name); 2211 } 2212 s->bfd_section->output_section = s->bfd_section; 2213 s->bfd_section->output_offset = 0; 2214 2215 /* Set the userdata of the output section to the output section 2216 statement to avoid lookup. */ 2217 get_userdata (s->bfd_section) = s; 2218 2219 /* If there is a base address, make sure that any sections it might 2220 mention are initialized. */ 2221 if (s->addr_tree != NULL) 2222 exp_init_os (s->addr_tree); 2223 2224 if (s->load_base != NULL) 2225 exp_init_os (s->load_base); 2226 2227 /* If supplied an alignment, set it. */ 2228 if (s->section_alignment != -1) 2229 s->bfd_section->alignment_power = s->section_alignment; 2230 } 2231 2232 /* Make sure that all output sections mentioned in an expression are 2233 initialized. */ 2234 2235 static void 2236 exp_init_os (etree_type *exp) 2237 { 2238 switch (exp->type.node_class) 2239 { 2240 case etree_assign: 2241 case etree_provide: 2242 exp_init_os (exp->assign.src); 2243 break; 2244 2245 case etree_binary: 2246 exp_init_os (exp->binary.lhs); 2247 exp_init_os (exp->binary.rhs); 2248 break; 2249 2250 case etree_trinary: 2251 exp_init_os (exp->trinary.cond); 2252 exp_init_os (exp->trinary.lhs); 2253 exp_init_os (exp->trinary.rhs); 2254 break; 2255 2256 case etree_assert: 2257 exp_init_os (exp->assert_s.child); 2258 break; 2259 2260 case etree_unary: 2261 exp_init_os (exp->unary.child); 2262 break; 2263 2264 case etree_name: 2265 switch (exp->type.node_code) 2266 { 2267 case ADDR: 2268 case LOADADDR: 2269 case SIZEOF: 2270 { 2271 lang_output_section_statement_type *os; 2272 2273 os = lang_output_section_find (exp->name.name); 2274 if (os != NULL && os->bfd_section == NULL) 2275 init_os (os, 0); 2276 } 2277 } 2278 break; 2279 2280 default: 2281 break; 2282 } 2283 } 2284 2285 static void 2287 section_already_linked (bfd *abfd, asection *sec, void *data) 2288 { 2289 lang_input_statement_type *entry = (lang_input_statement_type *) data; 2290 2291 /* If we are only reading symbols from this object, then we want to 2292 discard all sections. */ 2293 if (entry->flags.just_syms) 2294 { 2295 bfd_link_just_syms (abfd, sec, &link_info); 2296 return; 2297 } 2298 2299 if (!(abfd->flags & DYNAMIC)) 2300 bfd_section_already_linked (abfd, sec, &link_info); 2301 } 2302 2303 /* The wild routines. 2305 2306 These expand statements like *(.text) and foo.o to a list of 2307 explicit actions, like foo.o(.text), bar.o(.text) and 2308 foo.o(.text, .data). */ 2309 2310 /* Add SECTION to the output section OUTPUT. Do this by creating a 2311 lang_input_section statement which is placed at PTR. */ 2312 2313 void 2314 lang_add_section (lang_statement_list_type *ptr, 2315 asection *section, 2316 struct flag_info *sflag_info, 2317 lang_output_section_statement_type *output) 2318 { 2319 flagword flags = section->flags; 2320 2321 bfd_boolean discard; 2322 lang_input_section_type *new_section; 2323 bfd *abfd = link_info.output_bfd; 2324 2325 /* Discard sections marked with SEC_EXCLUDE. */ 2326 discard = (flags & SEC_EXCLUDE) != 0; 2327 2328 /* Discard input sections which are assigned to a section named 2329 DISCARD_SECTION_NAME. */ 2330 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0) 2331 discard = TRUE; 2332 2333 /* Discard debugging sections if we are stripping debugging 2334 information. */ 2335 if ((link_info.strip == strip_debugger || link_info.strip == strip_all) 2336 && (flags & SEC_DEBUGGING) != 0) 2337 discard = TRUE; 2338 2339 if (discard) 2340 { 2341 if (section->output_section == NULL) 2342 { 2343 /* This prevents future calls from assigning this section. */ 2344 section->output_section = bfd_abs_section_ptr; 2345 } 2346 return; 2347 } 2348 2349 if (sflag_info) 2350 { 2351 bfd_boolean keep; 2352 2353 keep = bfd_lookup_section_flags (&link_info, sflag_info, section); 2354 if (!keep) 2355 return; 2356 } 2357 2358 if (section->output_section != NULL) 2359 return; 2360 2361 /* We don't copy the SEC_NEVER_LOAD flag from an input section 2362 to an output section, because we want to be able to include a 2363 SEC_NEVER_LOAD section in the middle of an otherwise loaded 2364 section (I don't know why we want to do this, but we do). 2365 build_link_order in ldwrite.c handles this case by turning 2366 the embedded SEC_NEVER_LOAD section into a fill. */ 2367 flags &= ~ SEC_NEVER_LOAD; 2368 2369 /* If final link, don't copy the SEC_LINK_ONCE flags, they've 2370 already been processed. One reason to do this is that on pe 2371 format targets, .text$foo sections go into .text and it's odd 2372 to see .text with SEC_LINK_ONCE set. */ 2373 2374 if (!bfd_link_relocatable (&link_info)) 2375 flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC); 2376 2377 switch (output->sectype) 2378 { 2379 case normal_section: 2380 case overlay_section: 2381 break; 2382 case noalloc_section: 2383 flags &= ~SEC_ALLOC; 2384 break; 2385 case noload_section: 2386 flags &= ~SEC_LOAD; 2387 flags |= SEC_NEVER_LOAD; 2388 /* Unfortunately GNU ld has managed to evolve two different 2389 meanings to NOLOAD in scripts. ELF gets a .bss style noload, 2390 alloc, no contents section. All others get a noload, noalloc 2391 section. */ 2392 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour) 2393 flags &= ~SEC_HAS_CONTENTS; 2394 else 2395 flags &= ~SEC_ALLOC; 2396 break; 2397 } 2398 2399 if (output->bfd_section == NULL) 2400 init_os (output, flags); 2401 2402 /* If SEC_READONLY is not set in the input section, then clear 2403 it from the output section. */ 2404 output->bfd_section->flags &= flags | ~SEC_READONLY; 2405 2406 if (output->bfd_section->linker_has_input) 2407 { 2408 /* Only set SEC_READONLY flag on the first input section. */ 2409 flags &= ~ SEC_READONLY; 2410 2411 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */ 2412 if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS)) 2413 != (flags & (SEC_MERGE | SEC_STRINGS)) 2414 || ((flags & SEC_MERGE) != 0 2415 && output->bfd_section->entsize != section->entsize)) 2416 { 2417 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS); 2418 flags &= ~ (SEC_MERGE | SEC_STRINGS); 2419 } 2420 } 2421 output->bfd_section->flags |= flags; 2422 2423 if (!output->bfd_section->linker_has_input) 2424 { 2425 output->bfd_section->linker_has_input = 1; 2426 /* This must happen after flags have been updated. The output 2427 section may have been created before we saw its first input 2428 section, eg. for a data statement. */ 2429 bfd_init_private_section_data (section->owner, section, 2430 link_info.output_bfd, 2431 output->bfd_section, 2432 &link_info); 2433 if ((flags & SEC_MERGE) != 0) 2434 output->bfd_section->entsize = section->entsize; 2435 } 2436 2437 if ((flags & SEC_TIC54X_BLOCK) != 0 2438 && bfd_get_arch (section->owner) == bfd_arch_tic54x) 2439 { 2440 /* FIXME: This value should really be obtained from the bfd... */ 2441 output->block_value = 128; 2442 } 2443 2444 if (section->alignment_power > output->bfd_section->alignment_power) 2445 output->bfd_section->alignment_power = section->alignment_power; 2446 2447 section->output_section = output->bfd_section; 2448 2449 if (!map_head_is_link_order) 2450 { 2451 asection *s = output->bfd_section->map_tail.s; 2452 output->bfd_section->map_tail.s = section; 2453 section->map_head.s = NULL; 2454 section->map_tail.s = s; 2455 if (s != NULL) 2456 s->map_head.s = section; 2457 else 2458 output->bfd_section->map_head.s = section; 2459 } 2460 2461 /* Add a section reference to the list. */ 2462 new_section = new_stat (lang_input_section, ptr); 2463 new_section->section = section; 2464 } 2465 2466 /* Handle wildcard sorting. This returns the lang_input_section which 2467 should follow the one we are going to create for SECTION and FILE, 2468 based on the sorting requirements of WILD. It returns NULL if the 2469 new section should just go at the end of the current list. */ 2470 2471 static lang_statement_union_type * 2472 wild_sort (lang_wild_statement_type *wild, 2473 struct wildcard_list *sec, 2474 lang_input_statement_type *file, 2475 asection *section) 2476 { 2477 lang_statement_union_type *l; 2478 2479 if (!wild->filenames_sorted 2480 && (sec == NULL || sec->spec.sorted == none)) 2481 return NULL; 2482 2483 for (l = wild->children.head; l != NULL; l = l->header.next) 2484 { 2485 lang_input_section_type *ls; 2486 2487 if (l->header.type != lang_input_section_enum) 2488 continue; 2489 ls = &l->input_section; 2490 2491 /* Sorting by filename takes precedence over sorting by section 2492 name. */ 2493 2494 if (wild->filenames_sorted) 2495 { 2496 const char *fn, *ln; 2497 bfd_boolean fa, la; 2498 int i; 2499 2500 /* The PE support for the .idata section as generated by 2501 dlltool assumes that files will be sorted by the name of 2502 the archive and then the name of the file within the 2503 archive. */ 2504 2505 if (file->the_bfd != NULL 2506 && file->the_bfd->my_archive != NULL) 2507 { 2508 fn = bfd_get_filename (file->the_bfd->my_archive); 2509 fa = TRUE; 2510 } 2511 else 2512 { 2513 fn = file->filename; 2514 fa = FALSE; 2515 } 2516 2517 if (ls->section->owner->my_archive != NULL) 2518 { 2519 ln = bfd_get_filename (ls->section->owner->my_archive); 2520 la = TRUE; 2521 } 2522 else 2523 { 2524 ln = ls->section->owner->filename; 2525 la = FALSE; 2526 } 2527 2528 i = filename_cmp (fn, ln); 2529 if (i > 0) 2530 continue; 2531 else if (i < 0) 2532 break; 2533 2534 if (fa || la) 2535 { 2536 if (fa) 2537 fn = file->filename; 2538 if (la) 2539 ln = ls->section->owner->filename; 2540 2541 i = filename_cmp (fn, ln); 2542 if (i > 0) 2543 continue; 2544 else if (i < 0) 2545 break; 2546 } 2547 } 2548 2549 /* Here either the files are not sorted by name, or we are 2550 looking at the sections for this file. */ 2551 2552 if (sec != NULL 2553 && sec->spec.sorted != none 2554 && sec->spec.sorted != by_none) 2555 if (compare_section (sec->spec.sorted, section, ls->section) < 0) 2556 break; 2557 } 2558 2559 return l; 2560 } 2561 2562 /* Expand a wild statement for a particular FILE. SECTION may be 2563 NULL, in which case it is a wild card. */ 2564 2565 static void 2566 output_section_callback (lang_wild_statement_type *ptr, 2567 struct wildcard_list *sec, 2568 asection *section, 2569 struct flag_info *sflag_info, 2570 lang_input_statement_type *file, 2571 void *output) 2572 { 2573 lang_statement_union_type *before; 2574 lang_output_section_statement_type *os; 2575 2576 os = (lang_output_section_statement_type *) output; 2577 2578 /* Exclude sections that match UNIQUE_SECTION_LIST. */ 2579 if (unique_section_p (section, os)) 2580 return; 2581 2582 before = wild_sort (ptr, sec, file, section); 2583 2584 /* Here BEFORE points to the lang_input_section which 2585 should follow the one we are about to add. If BEFORE 2586 is NULL, then the section should just go at the end 2587 of the current list. */ 2588 2589 if (before == NULL) 2590 lang_add_section (&ptr->children, section, sflag_info, os); 2591 else 2592 { 2593 lang_statement_list_type list; 2594 lang_statement_union_type **pp; 2595 2596 lang_list_init (&list); 2597 lang_add_section (&list, section, sflag_info, os); 2598 2599 /* If we are discarding the section, LIST.HEAD will 2600 be NULL. */ 2601 if (list.head != NULL) 2602 { 2603 ASSERT (list.head->header.next == NULL); 2604 2605 for (pp = &ptr->children.head; 2606 *pp != before; 2607 pp = &(*pp)->header.next) 2608 ASSERT (*pp != NULL); 2609 2610 list.head->header.next = *pp; 2611 *pp = list.head; 2612 } 2613 } 2614 } 2615 2616 /* Check if all sections in a wild statement for a particular FILE 2617 are readonly. */ 2618 2619 static void 2620 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED, 2621 struct wildcard_list *sec ATTRIBUTE_UNUSED, 2622 asection *section, 2623 struct flag_info *sflag_info ATTRIBUTE_UNUSED, 2624 lang_input_statement_type *file ATTRIBUTE_UNUSED, 2625 void *output) 2626 { 2627 lang_output_section_statement_type *os; 2628 2629 os = (lang_output_section_statement_type *) output; 2630 2631 /* Exclude sections that match UNIQUE_SECTION_LIST. */ 2632 if (unique_section_p (section, os)) 2633 return; 2634 2635 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0) 2636 os->all_input_readonly = FALSE; 2637 } 2638 2639 /* This is passed a file name which must have been seen already and 2640 added to the statement tree. We will see if it has been opened 2641 already and had its symbols read. If not then we'll read it. */ 2642 2643 static lang_input_statement_type * 2644 lookup_name (const char *name) 2645 { 2646 lang_input_statement_type *search; 2647 2648 for (search = (lang_input_statement_type *) input_file_chain.head; 2649 search != NULL; 2650 search = (lang_input_statement_type *) search->next_real_file) 2651 { 2652 /* Use the local_sym_name as the name of the file that has 2653 already been loaded as filename might have been transformed 2654 via the search directory lookup mechanism. */ 2655 const char *filename = search->local_sym_name; 2656 2657 if (filename != NULL 2658 && filename_cmp (filename, name) == 0) 2659 break; 2660 } 2661 2662 if (search == NULL) 2663 search = new_afile (name, lang_input_file_is_search_file_enum, 2664 default_target, FALSE); 2665 2666 /* If we have already added this file, or this file is not real 2667 don't add this file. */ 2668 if (search->flags.loaded || !search->flags.real) 2669 return search; 2670 2671 if (!load_symbols (search, NULL)) 2672 return NULL; 2673 2674 return search; 2675 } 2676 2677 /* Save LIST as a list of libraries whose symbols should not be exported. */ 2678 2679 struct excluded_lib 2680 { 2681 char *name; 2682 struct excluded_lib *next; 2683 }; 2684 static struct excluded_lib *excluded_libs; 2685 2686 void 2687 add_excluded_libs (const char *list) 2688 { 2689 const char *p = list, *end; 2690 2691 while (*p != '\0') 2692 { 2693 struct excluded_lib *entry; 2694 end = strpbrk (p, ",:"); 2695 if (end == NULL) 2696 end = p + strlen (p); 2697 entry = (struct excluded_lib *) xmalloc (sizeof (*entry)); 2698 entry->next = excluded_libs; 2699 entry->name = (char *) xmalloc (end - p + 1); 2700 memcpy (entry->name, p, end - p); 2701 entry->name[end - p] = '\0'; 2702 excluded_libs = entry; 2703 if (*end == '\0') 2704 break; 2705 p = end + 1; 2706 } 2707 } 2708 2709 static void 2710 check_excluded_libs (bfd *abfd) 2711 { 2712 struct excluded_lib *lib = excluded_libs; 2713 2714 while (lib) 2715 { 2716 int len = strlen (lib->name); 2717 const char *filename = lbasename (abfd->filename); 2718 2719 if (strcmp (lib->name, "ALL") == 0) 2720 { 2721 abfd->no_export = TRUE; 2722 return; 2723 } 2724 2725 if (filename_ncmp (lib->name, filename, len) == 0 2726 && (filename[len] == '\0' 2727 || (filename[len] == '.' && filename[len + 1] == 'a' 2728 && filename[len + 2] == '\0'))) 2729 { 2730 abfd->no_export = TRUE; 2731 return; 2732 } 2733 2734 lib = lib->next; 2735 } 2736 } 2737 2738 /* Get the symbols for an input file. */ 2739 2740 bfd_boolean 2741 load_symbols (lang_input_statement_type *entry, 2742 lang_statement_list_type *place) 2743 { 2744 char **matching; 2745 2746 if (entry->flags.loaded) 2747 return TRUE; 2748 2749 ldfile_open_file (entry); 2750 2751 /* Do not process further if the file was missing. */ 2752 if (entry->flags.missing_file) 2753 return TRUE; 2754 2755 if (!bfd_check_format (entry->the_bfd, bfd_archive) 2756 && !bfd_check_format_matches (entry->the_bfd, bfd_object, &matching)) 2757 { 2758 bfd_error_type err; 2759 struct lang_input_statement_flags save_flags; 2760 extern FILE *yyin; 2761 2762 err = bfd_get_error (); 2763 2764 /* See if the emulation has some special knowledge. */ 2765 if (ldemul_unrecognized_file (entry)) 2766 return TRUE; 2767 2768 if (err == bfd_error_file_ambiguously_recognized) 2769 { 2770 char **p; 2771 2772 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd); 2773 einfo (_("%B: matching formats:"), entry->the_bfd); 2774 for (p = matching; *p != NULL; p++) 2775 einfo (" %s", *p); 2776 einfo ("%F\n"); 2777 } 2778 else if (err != bfd_error_file_not_recognized 2779 || place == NULL) 2780 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd); 2781 2782 bfd_close (entry->the_bfd); 2783 entry->the_bfd = NULL; 2784 2785 /* Try to interpret the file as a linker script. */ 2786 save_flags = input_flags; 2787 ldfile_open_command_file (entry->filename); 2788 2789 push_stat_ptr (place); 2790 input_flags.add_DT_NEEDED_for_regular 2791 = entry->flags.add_DT_NEEDED_for_regular; 2792 input_flags.add_DT_NEEDED_for_dynamic 2793 = entry->flags.add_DT_NEEDED_for_dynamic; 2794 input_flags.whole_archive = entry->flags.whole_archive; 2795 input_flags.dynamic = entry->flags.dynamic; 2796 2797 ldfile_assumed_script = TRUE; 2798 parser_input = input_script; 2799 yyparse (); 2800 ldfile_assumed_script = FALSE; 2801 2802 /* missing_file is sticky. sysrooted will already have been 2803 restored when seeing EOF in yyparse, but no harm to restore 2804 again. */ 2805 save_flags.missing_file |= input_flags.missing_file; 2806 input_flags = save_flags; 2807 pop_stat_ptr (); 2808 fclose (yyin); 2809 yyin = NULL; 2810 entry->flags.loaded = TRUE; 2811 2812 return TRUE; 2813 } 2814 2815 if (ldemul_recognized_file (entry)) 2816 return TRUE; 2817 2818 /* We don't call ldlang_add_file for an archive. Instead, the 2819 add_symbols entry point will call ldlang_add_file, via the 2820 add_archive_element callback, for each element of the archive 2821 which is used. */ 2822 switch (bfd_get_format (entry->the_bfd)) 2823 { 2824 default: 2825 break; 2826 2827 case bfd_object: 2828 if (!entry->flags.reload) 2829 ldlang_add_file (entry); 2830 if (trace_files || verbose) 2831 info_msg ("%I\n", entry); 2832 break; 2833 2834 case bfd_archive: 2835 check_excluded_libs (entry->the_bfd); 2836 2837 if (entry->flags.whole_archive) 2838 { 2839 bfd *member = NULL; 2840 bfd_boolean loaded = TRUE; 2841 2842 for (;;) 2843 { 2844 bfd *subsbfd; 2845 member = bfd_openr_next_archived_file (entry->the_bfd, member); 2846 2847 if (member == NULL) 2848 break; 2849 2850 if (!bfd_check_format (member, bfd_object)) 2851 { 2852 einfo (_("%F%B: member %B in archive is not an object\n"), 2853 entry->the_bfd, member); 2854 loaded = FALSE; 2855 } 2856 2857 subsbfd = member; 2858 if (!(*link_info.callbacks 2859 ->add_archive_element) (&link_info, member, 2860 "--whole-archive", &subsbfd)) 2861 abort (); 2862 2863 /* Potentially, the add_archive_element hook may have set a 2864 substitute BFD for us. */ 2865 if (!bfd_link_add_symbols (subsbfd, &link_info)) 2866 { 2867 einfo (_("%F%B: error adding symbols: %E\n"), member); 2868 loaded = FALSE; 2869 } 2870 } 2871 2872 entry->flags.loaded = loaded; 2873 return loaded; 2874 } 2875 break; 2876 } 2877 2878 if (bfd_link_add_symbols (entry->the_bfd, &link_info)) 2879 entry->flags.loaded = TRUE; 2880 else 2881 einfo (_("%F%B: error adding symbols: %E\n"), entry->the_bfd); 2882 2883 return entry->flags.loaded; 2884 } 2885 2886 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both 2887 may be NULL, indicating that it is a wildcard. Separate 2888 lang_input_section statements are created for each part of the 2889 expansion; they are added after the wild statement S. OUTPUT is 2890 the output section. */ 2891 2892 static void 2893 wild (lang_wild_statement_type *s, 2894 const char *target ATTRIBUTE_UNUSED, 2895 lang_output_section_statement_type *output) 2896 { 2897 struct wildcard_list *sec; 2898 2899 if (s->handler_data[0] 2900 && s->handler_data[0]->spec.sorted == by_name 2901 && !s->filenames_sorted) 2902 { 2903 lang_section_bst_type *tree; 2904 2905 walk_wild (s, output_section_callback_fast, output); 2906 2907 tree = s->tree; 2908 if (tree) 2909 { 2910 output_section_callback_tree_to_list (s, tree, output); 2911 s->tree = NULL; 2912 } 2913 } 2914 else 2915 walk_wild (s, output_section_callback, output); 2916 2917 if (default_common_section == NULL) 2918 for (sec = s->section_list; sec != NULL; sec = sec->next) 2919 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0) 2920 { 2921 /* Remember the section that common is going to in case we 2922 later get something which doesn't know where to put it. */ 2923 default_common_section = output; 2924 break; 2925 } 2926 } 2927 2928 /* Return TRUE iff target is the sought target. */ 2929 2930 static int 2931 get_target (const bfd_target *target, void *data) 2932 { 2933 const char *sought = (const char *) data; 2934 2935 return strcmp (target->name, sought) == 0; 2936 } 2937 2938 /* Like strcpy() but convert to lower case as well. */ 2939 2940 static void 2941 stricpy (char *dest, char *src) 2942 { 2943 char c; 2944 2945 while ((c = *src++) != 0) 2946 *dest++ = TOLOWER (c); 2947 2948 *dest = 0; 2949 } 2950 2951 /* Remove the first occurrence of needle (if any) in haystack 2952 from haystack. */ 2953 2954 static void 2955 strcut (char *haystack, char *needle) 2956 { 2957 haystack = strstr (haystack, needle); 2958 2959 if (haystack) 2960 { 2961 char *src; 2962 2963 for (src = haystack + strlen (needle); *src;) 2964 *haystack++ = *src++; 2965 2966 *haystack = 0; 2967 } 2968 } 2969 2970 /* Compare two target format name strings. 2971 Return a value indicating how "similar" they are. */ 2972 2973 static int 2974 name_compare (char *first, char *second) 2975 { 2976 char *copy1; 2977 char *copy2; 2978 int result; 2979 2980 copy1 = (char *) xmalloc (strlen (first) + 1); 2981 copy2 = (char *) xmalloc (strlen (second) + 1); 2982 2983 /* Convert the names to lower case. */ 2984 stricpy (copy1, first); 2985 stricpy (copy2, second); 2986 2987 /* Remove size and endian strings from the name. */ 2988 strcut (copy1, "big"); 2989 strcut (copy1, "little"); 2990 strcut (copy2, "big"); 2991 strcut (copy2, "little"); 2992 2993 /* Return a value based on how many characters match, 2994 starting from the beginning. If both strings are 2995 the same then return 10 * their length. */ 2996 for (result = 0; copy1[result] == copy2[result]; result++) 2997 if (copy1[result] == 0) 2998 { 2999 result *= 10; 3000 break; 3001 } 3002 3003 free (copy1); 3004 free (copy2); 3005 3006 return result; 3007 } 3008 3009 /* Set by closest_target_match() below. */ 3010 static const bfd_target *winner; 3011 3012 /* Scan all the valid bfd targets looking for one that has the endianness 3013 requirement that was specified on the command line, and is the nearest 3014 match to the original output target. */ 3015 3016 static int 3017 closest_target_match (const bfd_target *target, void *data) 3018 { 3019 const bfd_target *original = (const bfd_target *) data; 3020 3021 if (command_line.endian == ENDIAN_BIG 3022 && target->byteorder != BFD_ENDIAN_BIG) 3023 return 0; 3024 3025 if (command_line.endian == ENDIAN_LITTLE 3026 && target->byteorder != BFD_ENDIAN_LITTLE) 3027 return 0; 3028 3029 /* Must be the same flavour. */ 3030 if (target->flavour != original->flavour) 3031 return 0; 3032 3033 /* Ignore generic big and little endian elf vectors. */ 3034 if (strcmp (target->name, "elf32-big") == 0 3035 || strcmp (target->name, "elf64-big") == 0 3036 || strcmp (target->name, "elf32-little") == 0 3037 || strcmp (target->name, "elf64-little") == 0) 3038 return 0; 3039 3040 /* If we have not found a potential winner yet, then record this one. */ 3041 if (winner == NULL) 3042 { 3043 winner = target; 3044 return 0; 3045 } 3046 3047 /* Oh dear, we now have two potential candidates for a successful match. 3048 Compare their names and choose the better one. */ 3049 if (name_compare (target->name, original->name) 3050 > name_compare (winner->name, original->name)) 3051 winner = target; 3052 3053 /* Keep on searching until wqe have checked them all. */ 3054 return 0; 3055 } 3056 3057 /* Return the BFD target format of the first input file. */ 3058 3059 static char * 3060 get_first_input_target (void) 3061 { 3062 char *target = NULL; 3063 3064 LANG_FOR_EACH_INPUT_STATEMENT (s) 3065 { 3066 if (s->header.type == lang_input_statement_enum 3067 && s->flags.real) 3068 { 3069 ldfile_open_file (s); 3070 3071 if (s->the_bfd != NULL 3072 && bfd_check_format (s->the_bfd, bfd_object)) 3073 { 3074 target = bfd_get_target (s->the_bfd); 3075 3076 if (target != NULL) 3077 break; 3078 } 3079 } 3080 } 3081 3082 return target; 3083 } 3084 3085 const char * 3086 lang_get_output_target (void) 3087 { 3088 const char *target; 3089 3090 /* Has the user told us which output format to use? */ 3091 if (output_target != NULL) 3092 return output_target; 3093 3094 /* No - has the current target been set to something other than 3095 the default? */ 3096 if (current_target != default_target && current_target != NULL) 3097 return current_target; 3098 3099 /* No - can we determine the format of the first input file? */ 3100 target = get_first_input_target (); 3101 if (target != NULL) 3102 return target; 3103 3104 /* Failed - use the default output target. */ 3105 return default_target; 3106 } 3107 3108 /* Open the output file. */ 3109 3110 static void 3111 open_output (const char *name) 3112 { 3113 output_target = lang_get_output_target (); 3114 3115 /* Has the user requested a particular endianness on the command 3116 line? */ 3117 if (command_line.endian != ENDIAN_UNSET) 3118 { 3119 const bfd_target *target; 3120 enum bfd_endian desired_endian; 3121 3122 /* Get the chosen target. */ 3123 target = bfd_search_for_target (get_target, (void *) output_target); 3124 3125 /* If the target is not supported, we cannot do anything. */ 3126 if (target != NULL) 3127 { 3128 if (command_line.endian == ENDIAN_BIG) 3129 desired_endian = BFD_ENDIAN_BIG; 3130 else 3131 desired_endian = BFD_ENDIAN_LITTLE; 3132 3133 /* See if the target has the wrong endianness. This should 3134 not happen if the linker script has provided big and 3135 little endian alternatives, but some scrips don't do 3136 this. */ 3137 if (target->byteorder != desired_endian) 3138 { 3139 /* If it does, then see if the target provides 3140 an alternative with the correct endianness. */ 3141 if (target->alternative_target != NULL 3142 && (target->alternative_target->byteorder == desired_endian)) 3143 output_target = target->alternative_target->name; 3144 else 3145 { 3146 /* Try to find a target as similar as possible to 3147 the default target, but which has the desired 3148 endian characteristic. */ 3149 bfd_search_for_target (closest_target_match, 3150 (void *) target); 3151 3152 /* Oh dear - we could not find any targets that 3153 satisfy our requirements. */ 3154 if (winner == NULL) 3155 einfo (_("%P: warning: could not find any targets" 3156 " that match endianness requirement\n")); 3157 else 3158 output_target = winner->name; 3159 } 3160 } 3161 } 3162 } 3163 3164 link_info.output_bfd = bfd_openw (name, output_target); 3165 3166 if (link_info.output_bfd == NULL) 3167 { 3168 if (bfd_get_error () == bfd_error_invalid_target) 3169 einfo (_("%P%F: target %s not found\n"), output_target); 3170 3171 einfo (_("%P%F: cannot open output file %s: %E\n"), name); 3172 } 3173 3174 delete_output_file_on_failure = TRUE; 3175 3176 if (!bfd_set_format (link_info.output_bfd, bfd_object)) 3177 einfo (_("%P%F:%s: can not make object file: %E\n"), name); 3178 if (!bfd_set_arch_mach (link_info.output_bfd, 3179 ldfile_output_architecture, 3180 ldfile_output_machine)) 3181 einfo (_("%P%F:%s: can not set architecture: %E\n"), name); 3182 3183 link_info.hash = bfd_link_hash_table_create (link_info.output_bfd); 3184 if (link_info.hash == NULL) 3185 einfo (_("%P%F: can not create hash table: %E\n")); 3186 3187 bfd_set_gp_size (link_info.output_bfd, g_switch_value); 3188 } 3189 3190 static void 3191 ldlang_open_output (lang_statement_union_type *statement) 3192 { 3193 switch (statement->header.type) 3194 { 3195 case lang_output_statement_enum: 3196 ASSERT (link_info.output_bfd == NULL); 3197 open_output (statement->output_statement.name); 3198 ldemul_set_output_arch (); 3199 if (config.magic_demand_paged 3200 && !bfd_link_relocatable (&link_info)) 3201 link_info.output_bfd->flags |= D_PAGED; 3202 else 3203 link_info.output_bfd->flags &= ~D_PAGED; 3204 if (config.text_read_only) 3205 link_info.output_bfd->flags |= WP_TEXT; 3206 else 3207 link_info.output_bfd->flags &= ~WP_TEXT; 3208 if (link_info.traditional_format) 3209 link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT; 3210 else 3211 link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT; 3212 break; 3213 3214 case lang_target_statement_enum: 3215 current_target = statement->target_statement.target; 3216 break; 3217 default: 3218 break; 3219 } 3220 } 3221 3222 static void 3223 init_opb (void) 3224 { 3225 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 3226 ldfile_output_machine); 3227 opb_shift = 0; 3228 if (x > 1) 3229 while ((x & 1) == 0) 3230 { 3231 x >>= 1; 3232 ++opb_shift; 3233 } 3234 ASSERT (x == 1); 3235 } 3236 3237 /* Open all the input files. */ 3238 3239 enum open_bfd_mode 3240 { 3241 OPEN_BFD_NORMAL = 0, 3242 OPEN_BFD_FORCE = 1, 3243 OPEN_BFD_RESCAN = 2 3244 }; 3245 #ifdef ENABLE_PLUGINS 3246 static lang_input_statement_type *plugin_insert = NULL; 3247 #endif 3248 3249 static void 3250 open_input_bfds (lang_statement_union_type *s, enum open_bfd_mode mode) 3251 { 3252 for (; s != NULL; s = s->header.next) 3253 { 3254 switch (s->header.type) 3255 { 3256 case lang_constructors_statement_enum: 3257 open_input_bfds (constructor_list.head, mode); 3258 break; 3259 case lang_output_section_statement_enum: 3260 open_input_bfds (s->output_section_statement.children.head, mode); 3261 break; 3262 case lang_wild_statement_enum: 3263 /* Maybe we should load the file's symbols. */ 3264 if ((mode & OPEN_BFD_RESCAN) == 0 3265 && s->wild_statement.filename 3266 && !wildcardp (s->wild_statement.filename) 3267 && !archive_path (s->wild_statement.filename)) 3268 lookup_name (s->wild_statement.filename); 3269 open_input_bfds (s->wild_statement.children.head, mode); 3270 break; 3271 case lang_group_statement_enum: 3272 { 3273 struct bfd_link_hash_entry *undefs; 3274 3275 /* We must continually search the entries in the group 3276 until no new symbols are added to the list of undefined 3277 symbols. */ 3278 3279 do 3280 { 3281 undefs = link_info.hash->undefs_tail; 3282 open_input_bfds (s->group_statement.children.head, 3283 mode | OPEN_BFD_FORCE); 3284 } 3285 while (undefs != link_info.hash->undefs_tail); 3286 } 3287 break; 3288 case lang_target_statement_enum: 3289 current_target = s->target_statement.target; 3290 break; 3291 case lang_input_statement_enum: 3292 if (s->input_statement.flags.real) 3293 { 3294 lang_statement_union_type **os_tail; 3295 lang_statement_list_type add; 3296 bfd *abfd; 3297 3298 s->input_statement.target = current_target; 3299 3300 /* If we are being called from within a group, and this 3301 is an archive which has already been searched, then 3302 force it to be researched unless the whole archive 3303 has been loaded already. Do the same for a rescan. 3304 Likewise reload --as-needed shared libs. */ 3305 if (mode != OPEN_BFD_NORMAL 3306 #ifdef ENABLE_PLUGINS 3307 && ((mode & OPEN_BFD_RESCAN) == 0 3308 || plugin_insert == NULL) 3309 #endif 3310 && s->input_statement.flags.loaded 3311 && (abfd = s->input_statement.the_bfd) != NULL 3312 && ((bfd_get_format (abfd) == bfd_archive 3313 && !s->input_statement.flags.whole_archive) 3314 || (bfd_get_format (abfd) == bfd_object 3315 && ((abfd->flags) & DYNAMIC) != 0 3316 && s->input_statement.flags.add_DT_NEEDED_for_regular 3317 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 3318 && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0))) 3319 { 3320 s->input_statement.flags.loaded = FALSE; 3321 s->input_statement.flags.reload = TRUE; 3322 } 3323 3324 os_tail = lang_output_section_statement.tail; 3325 lang_list_init (&add); 3326 3327 if (!load_symbols (&s->input_statement, &add)) 3328 config.make_executable = FALSE; 3329 3330 if (add.head != NULL) 3331 { 3332 /* If this was a script with output sections then 3333 tack any added statements on to the end of the 3334 list. This avoids having to reorder the output 3335 section statement list. Very likely the user 3336 forgot -T, and whatever we do here will not meet 3337 naive user expectations. */ 3338 if (os_tail != lang_output_section_statement.tail) 3339 { 3340 einfo (_("%P: warning: %s contains output sections;" 3341 " did you forget -T?\n"), 3342 s->input_statement.filename); 3343 *stat_ptr->tail = add.head; 3344 stat_ptr->tail = add.tail; 3345 } 3346 else 3347 { 3348 *add.tail = s->header.next; 3349 s->header.next = add.head; 3350 } 3351 } 3352 } 3353 #ifdef ENABLE_PLUGINS 3354 /* If we have found the point at which a plugin added new 3355 files, clear plugin_insert to enable archive rescan. */ 3356 if (&s->input_statement == plugin_insert) 3357 plugin_insert = NULL; 3358 #endif 3359 break; 3360 case lang_assignment_statement_enum: 3361 if (s->assignment_statement.exp->assign.defsym) 3362 /* This is from a --defsym on the command line. */ 3363 exp_fold_tree_no_dot (s->assignment_statement.exp); 3364 break; 3365 default: 3366 break; 3367 } 3368 } 3369 3370 /* Exit if any of the files were missing. */ 3371 if (input_flags.missing_file) 3372 einfo ("%F"); 3373 } 3374 3375 /* Add the supplied name to the symbol table as an undefined reference. 3376 This is a two step process as the symbol table doesn't even exist at 3377 the time the ld command line is processed. First we put the name 3378 on a list, then, once the output file has been opened, transfer the 3379 name to the symbol table. */ 3380 3381 typedef struct bfd_sym_chain ldlang_undef_chain_list_type; 3382 3383 #define ldlang_undef_chain_list_head entry_symbol.next 3384 3385 void 3386 ldlang_add_undef (const char *const name, bfd_boolean cmdline) 3387 { 3388 ldlang_undef_chain_list_type *new_undef; 3389 3390 undef_from_cmdline = undef_from_cmdline || cmdline; 3391 new_undef = (ldlang_undef_chain_list_type *) stat_alloc (sizeof (*new_undef)); 3392 new_undef->next = ldlang_undef_chain_list_head; 3393 ldlang_undef_chain_list_head = new_undef; 3394 3395 new_undef->name = xstrdup (name); 3396 3397 if (link_info.output_bfd != NULL) 3398 insert_undefined (new_undef->name); 3399 } 3400 3401 /* Insert NAME as undefined in the symbol table. */ 3402 3403 static void 3404 insert_undefined (const char *name) 3405 { 3406 struct bfd_link_hash_entry *h; 3407 3408 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE); 3409 if (h == NULL) 3410 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); 3411 if (h->type == bfd_link_hash_new) 3412 { 3413 h->type = bfd_link_hash_undefined; 3414 h->u.undef.abfd = NULL; 3415 bfd_link_add_undef (link_info.hash, h); 3416 } 3417 } 3418 3419 /* Run through the list of undefineds created above and place them 3420 into the linker hash table as undefined symbols belonging to the 3421 script file. */ 3422 3423 static void 3424 lang_place_undefineds (void) 3425 { 3426 ldlang_undef_chain_list_type *ptr; 3427 3428 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next) 3429 insert_undefined (ptr->name); 3430 } 3431 3432 /* Structure used to build the list of symbols that the user has required 3433 be defined. */ 3434 3435 struct require_defined_symbol 3436 { 3437 const char *name; 3438 struct require_defined_symbol *next; 3439 }; 3440 3441 /* The list of symbols that the user has required be defined. */ 3442 3443 static struct require_defined_symbol *require_defined_symbol_list; 3444 3445 /* Add a new symbol NAME to the list of symbols that are required to be 3446 defined. */ 3447 3448 void 3449 ldlang_add_require_defined (const char *const name) 3450 { 3451 struct require_defined_symbol *ptr; 3452 3453 ldlang_add_undef (name, TRUE); 3454 ptr = (struct require_defined_symbol *) stat_alloc (sizeof (*ptr)); 3455 ptr->next = require_defined_symbol_list; 3456 ptr->name = strdup (name); 3457 require_defined_symbol_list = ptr; 3458 } 3459 3460 /* Check that all symbols the user required to be defined, are defined, 3461 raise an error if we find a symbol that is not defined. */ 3462 3463 static void 3464 ldlang_check_require_defined_symbols (void) 3465 { 3466 struct require_defined_symbol *ptr; 3467 3468 for (ptr = require_defined_symbol_list; ptr != NULL; ptr = ptr->next) 3469 { 3470 struct bfd_link_hash_entry *h; 3471 3472 h = bfd_link_hash_lookup (link_info.hash, ptr->name, 3473 FALSE, FALSE, TRUE); 3474 if (h == NULL 3475 || (h->type != bfd_link_hash_defined 3476 && h->type != bfd_link_hash_defweak)) 3477 einfo(_("%P%X: required symbol `%s' not defined\n"), ptr->name); 3478 } 3479 } 3480 3481 /* Check for all readonly or some readwrite sections. */ 3482 3483 static void 3484 check_input_sections 3485 (lang_statement_union_type *s, 3486 lang_output_section_statement_type *output_section_statement) 3487 { 3488 for (; s != (lang_statement_union_type *) NULL; s = s->header.next) 3489 { 3490 switch (s->header.type) 3491 { 3492 case lang_wild_statement_enum: 3493 walk_wild (&s->wild_statement, check_section_callback, 3494 output_section_statement); 3495 if (!output_section_statement->all_input_readonly) 3496 return; 3497 break; 3498 case lang_constructors_statement_enum: 3499 check_input_sections (constructor_list.head, 3500 output_section_statement); 3501 if (!output_section_statement->all_input_readonly) 3502 return; 3503 break; 3504 case lang_group_statement_enum: 3505 check_input_sections (s->group_statement.children.head, 3506 output_section_statement); 3507 if (!output_section_statement->all_input_readonly) 3508 return; 3509 break; 3510 default: 3511 break; 3512 } 3513 } 3514 } 3515 3516 /* Update wildcard statements if needed. */ 3517 3518 static void 3519 update_wild_statements (lang_statement_union_type *s) 3520 { 3521 struct wildcard_list *sec; 3522 3523 switch (sort_section) 3524 { 3525 default: 3526 FAIL (); 3527 3528 case none: 3529 break; 3530 3531 case by_name: 3532 case by_alignment: 3533 for (; s != NULL; s = s->header.next) 3534 { 3535 switch (s->header.type) 3536 { 3537 default: 3538 break; 3539 3540 case lang_wild_statement_enum: 3541 for (sec = s->wild_statement.section_list; sec != NULL; 3542 sec = sec->next) 3543 { 3544 switch (sec->spec.sorted) 3545 { 3546 case none: 3547 sec->spec.sorted = sort_section; 3548 break; 3549 case by_name: 3550 if (sort_section == by_alignment) 3551 sec->spec.sorted = by_name_alignment; 3552 break; 3553 case by_alignment: 3554 if (sort_section == by_name) 3555 sec->spec.sorted = by_alignment_name; 3556 break; 3557 default: 3558 break; 3559 } 3560 } 3561 break; 3562 3563 case lang_constructors_statement_enum: 3564 update_wild_statements (constructor_list.head); 3565 break; 3566 3567 case lang_output_section_statement_enum: 3568 /* Don't sort .init/.fini sections. */ 3569 if (strcmp (s->output_section_statement.name, ".init") != 0 3570 && strcmp (s->output_section_statement.name, ".fini") != 0) 3571 update_wild_statements 3572 (s->output_section_statement.children.head); 3573 break; 3574 3575 case lang_group_statement_enum: 3576 update_wild_statements (s->group_statement.children.head); 3577 break; 3578 } 3579 } 3580 break; 3581 } 3582 } 3583 3584 /* Open input files and attach to output sections. */ 3585 3586 static void 3587 map_input_to_output_sections 3588 (lang_statement_union_type *s, const char *target, 3589 lang_output_section_statement_type *os) 3590 { 3591 for (; s != NULL; s = s->header.next) 3592 { 3593 lang_output_section_statement_type *tos; 3594 flagword flags; 3595 3596 switch (s->header.type) 3597 { 3598 case lang_wild_statement_enum: 3599 wild (&s->wild_statement, target, os); 3600 break; 3601 case lang_constructors_statement_enum: 3602 map_input_to_output_sections (constructor_list.head, 3603 target, 3604 os); 3605 break; 3606 case lang_output_section_statement_enum: 3607 tos = &s->output_section_statement; 3608 if (tos->constraint != 0) 3609 { 3610 if (tos->constraint != ONLY_IF_RW 3611 && tos->constraint != ONLY_IF_RO) 3612 break; 3613 tos->all_input_readonly = TRUE; 3614 check_input_sections (tos->children.head, tos); 3615 if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO)) 3616 { 3617 tos->constraint = -1; 3618 break; 3619 } 3620 } 3621 map_input_to_output_sections (tos->children.head, 3622 target, 3623 tos); 3624 break; 3625 case lang_output_statement_enum: 3626 break; 3627 case lang_target_statement_enum: 3628 target = s->target_statement.target; 3629 break; 3630 case lang_group_statement_enum: 3631 map_input_to_output_sections (s->group_statement.children.head, 3632 target, 3633 os); 3634 break; 3635 case lang_data_statement_enum: 3636 /* Make sure that any sections mentioned in the expression 3637 are initialized. */ 3638 exp_init_os (s->data_statement.exp); 3639 /* The output section gets CONTENTS, ALLOC and LOAD, but 3640 these may be overridden by the script. */ 3641 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD; 3642 switch (os->sectype) 3643 { 3644 case normal_section: 3645 case overlay_section: 3646 break; 3647 case noalloc_section: 3648 flags = SEC_HAS_CONTENTS; 3649 break; 3650 case noload_section: 3651 if (bfd_get_flavour (link_info.output_bfd) 3652 == bfd_target_elf_flavour) 3653 flags = SEC_NEVER_LOAD | SEC_ALLOC; 3654 else 3655 flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS; 3656 break; 3657 } 3658 if (os->bfd_section == NULL) 3659 init_os (os, flags); 3660 else 3661 os->bfd_section->flags |= flags; 3662 break; 3663 case lang_input_section_enum: 3664 break; 3665 case lang_fill_statement_enum: 3666 case lang_object_symbols_statement_enum: 3667 case lang_reloc_statement_enum: 3668 case lang_padding_statement_enum: 3669 case lang_input_statement_enum: 3670 if (os != NULL && os->bfd_section == NULL) 3671 init_os (os, 0); 3672 break; 3673 case lang_assignment_statement_enum: 3674 if (os != NULL && os->bfd_section == NULL) 3675 init_os (os, 0); 3676 3677 /* Make sure that any sections mentioned in the assignment 3678 are initialized. */ 3679 exp_init_os (s->assignment_statement.exp); 3680 break; 3681 case lang_address_statement_enum: 3682 /* Mark the specified section with the supplied address. 3683 If this section was actually a segment marker, then the 3684 directive is ignored if the linker script explicitly 3685 processed the segment marker. Originally, the linker 3686 treated segment directives (like -Ttext on the 3687 command-line) as section directives. We honor the 3688 section directive semantics for backwards compatibilty; 3689 linker scripts that do not specifically check for 3690 SEGMENT_START automatically get the old semantics. */ 3691 if (!s->address_statement.segment 3692 || !s->address_statement.segment->used) 3693 { 3694 const char *name = s->address_statement.section_name; 3695 3696 /* Create the output section statement here so that 3697 orphans with a set address will be placed after other 3698 script sections. If we let the orphan placement code 3699 place them in amongst other sections then the address 3700 will affect following script sections, which is 3701 likely to surprise naive users. */ 3702 tos = lang_output_section_statement_lookup (name, 0, TRUE); 3703 tos->addr_tree = s->address_statement.address; 3704 if (tos->bfd_section == NULL) 3705 init_os (tos, 0); 3706 } 3707 break; 3708 case lang_insert_statement_enum: 3709 break; 3710 } 3711 } 3712 } 3713 3714 /* An insert statement snips out all the linker statements from the 3715 start of the list and places them after the output section 3716 statement specified by the insert. This operation is complicated 3717 by the fact that we keep a doubly linked list of output section 3718 statements as well as the singly linked list of all statements. */ 3719 3720 static void 3721 process_insert_statements (void) 3722 { 3723 lang_statement_union_type **s; 3724 lang_output_section_statement_type *first_os = NULL; 3725 lang_output_section_statement_type *last_os = NULL; 3726 lang_output_section_statement_type *os; 3727 3728 /* "start of list" is actually the statement immediately after 3729 the special abs_section output statement, so that it isn't 3730 reordered. */ 3731 s = &lang_output_section_statement.head; 3732 while (*(s = &(*s)->header.next) != NULL) 3733 { 3734 if ((*s)->header.type == lang_output_section_statement_enum) 3735 { 3736 /* Keep pointers to the first and last output section 3737 statement in the sequence we may be about to move. */ 3738 os = &(*s)->output_section_statement; 3739 3740 ASSERT (last_os == NULL || last_os->next == os); 3741 last_os = os; 3742 3743 /* Set constraint negative so that lang_output_section_find 3744 won't match this output section statement. At this 3745 stage in linking constraint has values in the range 3746 [-1, ONLY_IN_RW]. */ 3747 last_os->constraint = -2 - last_os->constraint; 3748 if (first_os == NULL) 3749 first_os = last_os; 3750 } 3751 else if ((*s)->header.type == lang_insert_statement_enum) 3752 { 3753 lang_insert_statement_type *i = &(*s)->insert_statement; 3754 lang_output_section_statement_type *where; 3755 lang_statement_union_type **ptr; 3756 lang_statement_union_type *first; 3757 3758 where = lang_output_section_find (i->where); 3759 if (where != NULL && i->is_before) 3760 { 3761 do 3762 where = where->prev; 3763 while (where != NULL && where->constraint < 0); 3764 } 3765 if (where == NULL) 3766 { 3767 einfo (_("%F%P: %s not found for insert\n"), i->where); 3768 return; 3769 } 3770 3771 /* Deal with reordering the output section statement list. */ 3772 if (last_os != NULL) 3773 { 3774 asection *first_sec, *last_sec; 3775 struct lang_output_section_statement_struct **next; 3776 3777 /* Snip out the output sections we are moving. */ 3778 first_os->prev->next = last_os->next; 3779 if (last_os->next == NULL) 3780 { 3781 next = &first_os->prev->next; 3782 lang_output_section_statement.tail 3783 = (lang_statement_union_type **) next; 3784 } 3785 else 3786 last_os->next->prev = first_os->prev; 3787 /* Add them in at the new position. */ 3788 last_os->next = where->next; 3789 if (where->next == NULL) 3790 { 3791 next = &last_os->next; 3792 lang_output_section_statement.tail 3793 = (lang_statement_union_type **) next; 3794 } 3795 else 3796 where->next->prev = last_os; 3797 first_os->prev = where; 3798 where->next = first_os; 3799 3800 /* Move the bfd sections in the same way. */ 3801 first_sec = NULL; 3802 last_sec = NULL; 3803 for (os = first_os; os != NULL; os = os->next) 3804 { 3805 os->constraint = -2 - os->constraint; 3806 if (os->bfd_section != NULL 3807 && os->bfd_section->owner != NULL) 3808 { 3809 last_sec = os->bfd_section; 3810 if (first_sec == NULL) 3811 first_sec = last_sec; 3812 } 3813 if (os == last_os) 3814 break; 3815 } 3816 if (last_sec != NULL) 3817 { 3818 asection *sec = where->bfd_section; 3819 if (sec == NULL) 3820 sec = output_prev_sec_find (where); 3821 3822 /* The place we want to insert must come after the 3823 sections we are moving. So if we find no 3824 section or if the section is the same as our 3825 last section, then no move is needed. */ 3826 if (sec != NULL && sec != last_sec) 3827 { 3828 /* Trim them off. */ 3829 if (first_sec->prev != NULL) 3830 first_sec->prev->next = last_sec->next; 3831 else 3832 link_info.output_bfd->sections = last_sec->next; 3833 if (last_sec->next != NULL) 3834 last_sec->next->prev = first_sec->prev; 3835 else 3836 link_info.output_bfd->section_last = first_sec->prev; 3837 /* Add back. */ 3838 last_sec->next = sec->next; 3839 if (sec->next != NULL) 3840 sec->next->prev = last_sec; 3841 else 3842 link_info.output_bfd->section_last = last_sec; 3843 first_sec->prev = sec; 3844 sec->next = first_sec; 3845 } 3846 } 3847 3848 first_os = NULL; 3849 last_os = NULL; 3850 } 3851 3852 ptr = insert_os_after (where); 3853 /* Snip everything after the abs_section output statement we 3854 know is at the start of the list, up to and including 3855 the insert statement we are currently processing. */ 3856 first = lang_output_section_statement.head->header.next; 3857 lang_output_section_statement.head->header.next = (*s)->header.next; 3858 /* Add them back where they belong. */ 3859 *s = *ptr; 3860 if (*s == NULL) 3861 statement_list.tail = s; 3862 *ptr = first; 3863 s = &lang_output_section_statement.head; 3864 } 3865 } 3866 3867 /* Undo constraint twiddling. */ 3868 for (os = first_os; os != NULL; os = os->next) 3869 { 3870 os->constraint = -2 - os->constraint; 3871 if (os == last_os) 3872 break; 3873 } 3874 } 3875 3876 /* An output section might have been removed after its statement was 3877 added. For example, ldemul_before_allocation can remove dynamic 3878 sections if they turn out to be not needed. Clean them up here. */ 3879 3880 void 3881 strip_excluded_output_sections (void) 3882 { 3883 lang_output_section_statement_type *os; 3884 3885 /* Run lang_size_sections (if not already done). */ 3886 if (expld.phase != lang_mark_phase_enum) 3887 { 3888 expld.phase = lang_mark_phase_enum; 3889 expld.dataseg.phase = exp_dataseg_none; 3890 one_lang_size_sections_pass (NULL, FALSE); 3891 lang_reset_memory_regions (); 3892 } 3893 3894 for (os = &lang_output_section_statement.head->output_section_statement; 3895 os != NULL; 3896 os = os->next) 3897 { 3898 asection *output_section; 3899 bfd_boolean exclude; 3900 3901 if (os->constraint < 0) 3902 continue; 3903 3904 output_section = os->bfd_section; 3905 if (output_section == NULL) 3906 continue; 3907 3908 exclude = (output_section->rawsize == 0 3909 && (output_section->flags & SEC_KEEP) == 0 3910 && !bfd_section_removed_from_list (link_info.output_bfd, 3911 output_section)); 3912 3913 /* Some sections have not yet been sized, notably .gnu.version, 3914 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED 3915 input sections, so don't drop output sections that have such 3916 input sections unless they are also marked SEC_EXCLUDE. */ 3917 if (exclude && output_section->map_head.s != NULL) 3918 { 3919 asection *s; 3920 3921 for (s = output_section->map_head.s; s != NULL; s = s->map_head.s) 3922 if ((s->flags & SEC_EXCLUDE) == 0 3923 && ((s->flags & SEC_LINKER_CREATED) != 0 3924 || link_info.emitrelocations)) 3925 { 3926 exclude = FALSE; 3927 break; 3928 } 3929 } 3930 3931 if (exclude) 3932 { 3933 /* We don't set bfd_section to NULL since bfd_section of the 3934 removed output section statement may still be used. */ 3935 if (!os->update_dot) 3936 os->ignored = TRUE; 3937 output_section->flags |= SEC_EXCLUDE; 3938 bfd_section_list_remove (link_info.output_bfd, output_section); 3939 link_info.output_bfd->section_count--; 3940 } 3941 } 3942 } 3943 3944 /* Called from ldwrite to clear out asection.map_head and 3945 asection.map_tail for use as link_orders in ldwrite. 3946 FIXME: Except for sh64elf.em which starts creating link_orders in 3947 its after_allocation routine so needs to call it early. */ 3948 3949 void 3950 lang_clear_os_map (void) 3951 { 3952 lang_output_section_statement_type *os; 3953 3954 if (map_head_is_link_order) 3955 return; 3956 3957 for (os = &lang_output_section_statement.head->output_section_statement; 3958 os != NULL; 3959 os = os->next) 3960 { 3961 asection *output_section; 3962 3963 if (os->constraint < 0) 3964 continue; 3965 3966 output_section = os->bfd_section; 3967 if (output_section == NULL) 3968 continue; 3969 3970 /* TODO: Don't just junk map_head.s, turn them into link_orders. */ 3971 output_section->map_head.link_order = NULL; 3972 output_section->map_tail.link_order = NULL; 3973 } 3974 3975 /* Stop future calls to lang_add_section from messing with map_head 3976 and map_tail link_order fields. */ 3977 map_head_is_link_order = TRUE; 3978 } 3979 3980 static void 3981 print_output_section_statement 3982 (lang_output_section_statement_type *output_section_statement) 3983 { 3984 asection *section = output_section_statement->bfd_section; 3985 int len; 3986 3987 if (output_section_statement != abs_output_section) 3988 { 3989 minfo ("\n%s", output_section_statement->name); 3990 3991 if (section != NULL) 3992 { 3993 print_dot = section->vma; 3994 3995 len = strlen (output_section_statement->name); 3996 if (len >= SECTION_NAME_MAP_LENGTH - 1) 3997 { 3998 print_nl (); 3999 len = 0; 4000 } 4001 while (len < SECTION_NAME_MAP_LENGTH) 4002 { 4003 print_space (); 4004 ++len; 4005 } 4006 4007 minfo ("0x%V %W", section->vma, TO_ADDR (section->size)); 4008 4009 if (section->vma != section->lma) 4010 minfo (_(" load address 0x%V"), section->lma); 4011 4012 if (output_section_statement->update_dot_tree != NULL) 4013 exp_fold_tree (output_section_statement->update_dot_tree, 4014 bfd_abs_section_ptr, &print_dot); 4015 } 4016 4017 print_nl (); 4018 } 4019 4020 print_statement_list (output_section_statement->children.head, 4021 output_section_statement); 4022 } 4023 4024 static void 4025 print_assignment (lang_assignment_statement_type *assignment, 4026 lang_output_section_statement_type *output_section) 4027 { 4028 unsigned int i; 4029 bfd_boolean is_dot; 4030 etree_type *tree; 4031 asection *osec; 4032 4033 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) 4034 print_space (); 4035 4036 if (assignment->exp->type.node_class == etree_assert) 4037 { 4038 is_dot = FALSE; 4039 tree = assignment->exp->assert_s.child; 4040 } 4041 else 4042 { 4043 const char *dst = assignment->exp->assign.dst; 4044 4045 is_dot = (dst[0] == '.' && dst[1] == 0); 4046 if (!is_dot) 4047 expld.assign_name = dst; 4048 tree = assignment->exp->assign.src; 4049 } 4050 4051 osec = output_section->bfd_section; 4052 if (osec == NULL) 4053 osec = bfd_abs_section_ptr; 4054 4055 if (assignment->exp->type.node_class != etree_provide) 4056 exp_fold_tree (tree, osec, &print_dot); 4057 else 4058 expld.result.valid_p = FALSE; 4059 4060 if (expld.result.valid_p) 4061 { 4062 bfd_vma value; 4063 4064 if (assignment->exp->type.node_class == etree_assert 4065 || is_dot 4066 || expld.assign_name != NULL) 4067 { 4068 value = expld.result.value; 4069 4070 if (expld.result.section != NULL) 4071 value += expld.result.section->vma; 4072 4073 minfo ("0x%V", value); 4074 if (is_dot) 4075 print_dot = value; 4076 } 4077 else 4078 { 4079 struct bfd_link_hash_entry *h; 4080 4081 h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst, 4082 FALSE, FALSE, TRUE); 4083 if (h) 4084 { 4085 value = h->u.def.value; 4086 value += h->u.def.section->output_section->vma; 4087 value += h->u.def.section->output_offset; 4088 4089 minfo ("[0x%V]", value); 4090 } 4091 else 4092 minfo ("[unresolved]"); 4093 } 4094 } 4095 else 4096 { 4097 if (assignment->exp->type.node_class == etree_provide) 4098 minfo ("[!provide]"); 4099 else 4100 minfo ("*undef* "); 4101 #ifdef BFD64 4102 minfo (" "); 4103 #endif 4104 } 4105 expld.assign_name = NULL; 4106 4107 minfo (" "); 4108 exp_print_tree (assignment->exp); 4109 print_nl (); 4110 } 4111 4112 static void 4113 print_input_statement (lang_input_statement_type *statm) 4114 { 4115 if (statm->filename != NULL 4116 && (statm->the_bfd == NULL 4117 || (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0)) 4118 fprintf (config.map_file, "LOAD %s\n", statm->filename); 4119 } 4120 4121 /* Print all symbols defined in a particular section. This is called 4122 via bfd_link_hash_traverse, or by print_all_symbols. */ 4123 4124 static bfd_boolean 4125 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr) 4126 { 4127 asection *sec = (asection *) ptr; 4128 4129 if ((hash_entry->type == bfd_link_hash_defined 4130 || hash_entry->type == bfd_link_hash_defweak) 4131 && sec == hash_entry->u.def.section) 4132 { 4133 int i; 4134 4135 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) 4136 print_space (); 4137 minfo ("0x%V ", 4138 (hash_entry->u.def.value 4139 + hash_entry->u.def.section->output_offset 4140 + hash_entry->u.def.section->output_section->vma)); 4141 4142 minfo (" %T\n", hash_entry->root.string); 4143 } 4144 4145 return TRUE; 4146 } 4147 4148 static int 4149 hash_entry_addr_cmp (const void *a, const void *b) 4150 { 4151 const struct bfd_link_hash_entry *l = *(const struct bfd_link_hash_entry **)a; 4152 const struct bfd_link_hash_entry *r = *(const struct bfd_link_hash_entry **)b; 4153 4154 if (l->u.def.value < r->u.def.value) 4155 return -1; 4156 else if (l->u.def.value > r->u.def.value) 4157 return 1; 4158 else 4159 return 0; 4160 } 4161 4162 static void 4163 print_all_symbols (asection *sec) 4164 { 4165 input_section_userdata_type *ud 4166 = (input_section_userdata_type *) get_userdata (sec); 4167 struct map_symbol_def *def; 4168 struct bfd_link_hash_entry **entries; 4169 unsigned int i; 4170 4171 if (!ud) 4172 return; 4173 4174 *ud->map_symbol_def_tail = 0; 4175 4176 /* Sort the symbols by address. */ 4177 entries = (struct bfd_link_hash_entry **) 4178 obstack_alloc (&map_obstack, 4179 ud->map_symbol_def_count * sizeof (*entries)); 4180 4181 for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++) 4182 entries[i] = def->entry; 4183 4184 qsort (entries, ud->map_symbol_def_count, sizeof (*entries), 4185 hash_entry_addr_cmp); 4186 4187 /* Print the symbols. */ 4188 for (i = 0; i < ud->map_symbol_def_count; i++) 4189 print_one_symbol (entries[i], sec); 4190 4191 obstack_free (&map_obstack, entries); 4192 } 4193 4194 /* Print information about an input section to the map file. */ 4195 4196 static void 4197 print_input_section (asection *i, bfd_boolean is_discarded) 4198 { 4199 bfd_size_type size = i->size; 4200 int len; 4201 bfd_vma addr; 4202 4203 init_opb (); 4204 4205 print_space (); 4206 minfo ("%s", i->name); 4207 4208 len = 1 + strlen (i->name); 4209 if (len >= SECTION_NAME_MAP_LENGTH - 1) 4210 { 4211 print_nl (); 4212 len = 0; 4213 } 4214 while (len < SECTION_NAME_MAP_LENGTH) 4215 { 4216 print_space (); 4217 ++len; 4218 } 4219 4220 if (i->output_section != NULL 4221 && i->output_section->owner == link_info.output_bfd) 4222 addr = i->output_section->vma + i->output_offset; 4223 else 4224 { 4225 addr = print_dot; 4226 if (!is_discarded) 4227 size = 0; 4228 } 4229 4230 minfo ("0x%V %W %B\n", addr, size, i->owner); 4231 4232 if (size != i->rawsize && i->rawsize != 0) 4233 { 4234 len = SECTION_NAME_MAP_LENGTH + 3; 4235 #ifdef BFD64 4236 len += 16; 4237 #else 4238 len += 8; 4239 #endif 4240 while (len > 0) 4241 { 4242 print_space (); 4243 --len; 4244 } 4245 4246 minfo (_("%W (size before relaxing)\n"), i->rawsize); 4247 } 4248 4249 if (i->output_section != NULL 4250 && i->output_section->owner == link_info.output_bfd) 4251 { 4252 if (link_info.reduce_memory_overheads) 4253 bfd_link_hash_traverse (link_info.hash, print_one_symbol, i); 4254 else 4255 print_all_symbols (i); 4256 4257 /* Update print_dot, but make sure that we do not move it 4258 backwards - this could happen if we have overlays and a 4259 later overlay is shorter than an earier one. */ 4260 if (addr + TO_ADDR (size) > print_dot) 4261 print_dot = addr + TO_ADDR (size); 4262 } 4263 } 4264 4265 static void 4266 print_fill_statement (lang_fill_statement_type *fill) 4267 { 4268 size_t size; 4269 unsigned char *p; 4270 fputs (" FILL mask 0x", config.map_file); 4271 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--) 4272 fprintf (config.map_file, "%02x", *p); 4273 fputs ("\n", config.map_file); 4274 } 4275 4276 static void 4277 print_data_statement (lang_data_statement_type *data) 4278 { 4279 int i; 4280 bfd_vma addr; 4281 bfd_size_type size; 4282 const char *name; 4283 4284 init_opb (); 4285 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) 4286 print_space (); 4287 4288 addr = data->output_offset; 4289 if (data->output_section != NULL) 4290 addr += data->output_section->vma; 4291 4292 switch (data->type) 4293 { 4294 default: 4295 abort (); 4296 case BYTE: 4297 size = BYTE_SIZE; 4298 name = "BYTE"; 4299 break; 4300 case SHORT: 4301 size = SHORT_SIZE; 4302 name = "SHORT"; 4303 break; 4304 case LONG: 4305 size = LONG_SIZE; 4306 name = "LONG"; 4307 break; 4308 case QUAD: 4309 size = QUAD_SIZE; 4310 name = "QUAD"; 4311 break; 4312 case SQUAD: 4313 size = QUAD_SIZE; 4314 name = "SQUAD"; 4315 break; 4316 } 4317 4318 if (size < TO_SIZE ((unsigned) 1)) 4319 size = TO_SIZE ((unsigned) 1); 4320 minfo ("0x%V %W %s 0x%v", addr, TO_ADDR (size), name, data->value); 4321 4322 if (data->exp->type.node_class != etree_value) 4323 { 4324 print_space (); 4325 exp_print_tree (data->exp); 4326 } 4327 4328 print_nl (); 4329 4330 print_dot = addr + TO_ADDR (size); 4331 } 4332 4333 /* Print an address statement. These are generated by options like 4334 -Ttext. */ 4335 4336 static void 4337 print_address_statement (lang_address_statement_type *address) 4338 { 4339 minfo (_("Address of section %s set to "), address->section_name); 4340 exp_print_tree (address->address); 4341 print_nl (); 4342 } 4343 4344 /* Print a reloc statement. */ 4345 4346 static void 4347 print_reloc_statement (lang_reloc_statement_type *reloc) 4348 { 4349 int i; 4350 bfd_vma addr; 4351 bfd_size_type size; 4352 4353 init_opb (); 4354 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) 4355 print_space (); 4356 4357 addr = reloc->output_offset; 4358 if (reloc->output_section != NULL) 4359 addr += reloc->output_section->vma; 4360 4361 size = bfd_get_reloc_size (reloc->howto); 4362 4363 minfo ("0x%V %W RELOC %s ", addr, TO_ADDR (size), reloc->howto->name); 4364 4365 if (reloc->name != NULL) 4366 minfo ("%s+", reloc->name); 4367 else 4368 minfo ("%s+", reloc->section->name); 4369 4370 exp_print_tree (reloc->addend_exp); 4371 4372 print_nl (); 4373 4374 print_dot = addr + TO_ADDR (size); 4375 } 4376 4377 static void 4378 print_padding_statement (lang_padding_statement_type *s) 4379 { 4380 int len; 4381 bfd_vma addr; 4382 4383 init_opb (); 4384 minfo (" *fill*"); 4385 4386 len = sizeof " *fill*" - 1; 4387 while (len < SECTION_NAME_MAP_LENGTH) 4388 { 4389 print_space (); 4390 ++len; 4391 } 4392 4393 addr = s->output_offset; 4394 if (s->output_section != NULL) 4395 addr += s->output_section->vma; 4396 minfo ("0x%V %W ", addr, TO_ADDR (s->size)); 4397 4398 if (s->fill->size != 0) 4399 { 4400 size_t size; 4401 unsigned char *p; 4402 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--) 4403 fprintf (config.map_file, "%02x", *p); 4404 } 4405 4406 print_nl (); 4407 4408 print_dot = addr + TO_ADDR (s->size); 4409 } 4410 4411 static void 4412 print_wild_statement (lang_wild_statement_type *w, 4413 lang_output_section_statement_type *os) 4414 { 4415 struct wildcard_list *sec; 4416 4417 print_space (); 4418 4419 if (w->filenames_sorted) 4420 minfo ("SORT("); 4421 if (w->filename != NULL) 4422 minfo ("%s", w->filename); 4423 else 4424 minfo ("*"); 4425 if (w->filenames_sorted) 4426 minfo (")"); 4427 4428 minfo ("("); 4429 for (sec = w->section_list; sec; sec = sec->next) 4430 { 4431 if (sec->spec.sorted) 4432 minfo ("SORT("); 4433 if (sec->spec.exclude_name_list != NULL) 4434 { 4435 name_list *tmp; 4436 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name); 4437 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next) 4438 minfo (" %s", tmp->name); 4439 minfo (") "); 4440 } 4441 if (sec->spec.name != NULL) 4442 minfo ("%s", sec->spec.name); 4443 else 4444 minfo ("*"); 4445 if (sec->spec.sorted) 4446 minfo (")"); 4447 if (sec->next) 4448 minfo (" "); 4449 } 4450 minfo (")"); 4451 4452 print_nl (); 4453 4454 print_statement_list (w->children.head, os); 4455 } 4456 4457 /* Print a group statement. */ 4458 4459 static void 4460 print_group (lang_group_statement_type *s, 4461 lang_output_section_statement_type *os) 4462 { 4463 fprintf (config.map_file, "START GROUP\n"); 4464 print_statement_list (s->children.head, os); 4465 fprintf (config.map_file, "END GROUP\n"); 4466 } 4467 4468 /* Print the list of statements in S. 4469 This can be called for any statement type. */ 4470 4471 static void 4472 print_statement_list (lang_statement_union_type *s, 4473 lang_output_section_statement_type *os) 4474 { 4475 while (s != NULL) 4476 { 4477 print_statement (s, os); 4478 s = s->header.next; 4479 } 4480 } 4481 4482 /* Print the first statement in statement list S. 4483 This can be called for any statement type. */ 4484 4485 static void 4486 print_statement (lang_statement_union_type *s, 4487 lang_output_section_statement_type *os) 4488 { 4489 switch (s->header.type) 4490 { 4491 default: 4492 fprintf (config.map_file, _("Fail with %d\n"), s->header.type); 4493 FAIL (); 4494 break; 4495 case lang_constructors_statement_enum: 4496 if (constructor_list.head != NULL) 4497 { 4498 if (constructors_sorted) 4499 minfo (" SORT (CONSTRUCTORS)\n"); 4500 else 4501 minfo (" CONSTRUCTORS\n"); 4502 print_statement_list (constructor_list.head, os); 4503 } 4504 break; 4505 case lang_wild_statement_enum: 4506 print_wild_statement (&s->wild_statement, os); 4507 break; 4508 case lang_address_statement_enum: 4509 print_address_statement (&s->address_statement); 4510 break; 4511 case lang_object_symbols_statement_enum: 4512 minfo (" CREATE_OBJECT_SYMBOLS\n"); 4513 break; 4514 case lang_fill_statement_enum: 4515 print_fill_statement (&s->fill_statement); 4516 break; 4517 case lang_data_statement_enum: 4518 print_data_statement (&s->data_statement); 4519 break; 4520 case lang_reloc_statement_enum: 4521 print_reloc_statement (&s->reloc_statement); 4522 break; 4523 case lang_input_section_enum: 4524 print_input_section (s->input_section.section, FALSE); 4525 break; 4526 case lang_padding_statement_enum: 4527 print_padding_statement (&s->padding_statement); 4528 break; 4529 case lang_output_section_statement_enum: 4530 print_output_section_statement (&s->output_section_statement); 4531 break; 4532 case lang_assignment_statement_enum: 4533 print_assignment (&s->assignment_statement, os); 4534 break; 4535 case lang_target_statement_enum: 4536 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target); 4537 break; 4538 case lang_output_statement_enum: 4539 minfo ("OUTPUT(%s", s->output_statement.name); 4540 if (output_target != NULL) 4541 minfo (" %s", output_target); 4542 minfo (")\n"); 4543 break; 4544 case lang_input_statement_enum: 4545 print_input_statement (&s->input_statement); 4546 break; 4547 case lang_group_statement_enum: 4548 print_group (&s->group_statement, os); 4549 break; 4550 case lang_insert_statement_enum: 4551 minfo ("INSERT %s %s\n", 4552 s->insert_statement.is_before ? "BEFORE" : "AFTER", 4553 s->insert_statement.where); 4554 break; 4555 } 4556 } 4557 4558 static void 4559 print_statements (void) 4560 { 4561 print_statement_list (statement_list.head, abs_output_section); 4562 } 4563 4564 /* Print the first N statements in statement list S to STDERR. 4565 If N == 0, nothing is printed. 4566 If N < 0, the entire list is printed. 4567 Intended to be called from GDB. */ 4568 4569 void 4570 dprint_statement (lang_statement_union_type *s, int n) 4571 { 4572 FILE *map_save = config.map_file; 4573 4574 config.map_file = stderr; 4575 4576 if (n < 0) 4577 print_statement_list (s, abs_output_section); 4578 else 4579 { 4580 while (s && --n >= 0) 4581 { 4582 print_statement (s, abs_output_section); 4583 s = s->header.next; 4584 } 4585 } 4586 4587 config.map_file = map_save; 4588 } 4589 4590 static void 4591 insert_pad (lang_statement_union_type **ptr, 4592 fill_type *fill, 4593 bfd_size_type alignment_needed, 4594 asection *output_section, 4595 bfd_vma dot) 4596 { 4597 static fill_type zero_fill; 4598 lang_statement_union_type *pad = NULL; 4599 4600 if (ptr != &statement_list.head) 4601 pad = ((lang_statement_union_type *) 4602 ((char *) ptr - offsetof (lang_statement_union_type, header.next))); 4603 if (pad != NULL 4604 && pad->header.type == lang_padding_statement_enum 4605 && pad->padding_statement.output_section == output_section) 4606 { 4607 /* Use the existing pad statement. */ 4608 } 4609 else if ((pad = *ptr) != NULL 4610 && pad->header.type == lang_padding_statement_enum 4611 && pad->padding_statement.output_section == output_section) 4612 { 4613 /* Use the existing pad statement. */ 4614 } 4615 else 4616 { 4617 /* Make a new padding statement, linked into existing chain. */ 4618 pad = (lang_statement_union_type *) 4619 stat_alloc (sizeof (lang_padding_statement_type)); 4620 pad->header.next = *ptr; 4621 *ptr = pad; 4622 pad->header.type = lang_padding_statement_enum; 4623 pad->padding_statement.output_section = output_section; 4624 if (fill == NULL) 4625 fill = &zero_fill; 4626 pad->padding_statement.fill = fill; 4627 } 4628 pad->padding_statement.output_offset = dot - output_section->vma; 4629 pad->padding_statement.size = alignment_needed; 4630 output_section->size = TO_SIZE (dot + TO_ADDR (alignment_needed) 4631 - output_section->vma); 4632 } 4633 4634 /* Work out how much this section will move the dot point. */ 4635 4636 static bfd_vma 4637 size_input_section 4638 (lang_statement_union_type **this_ptr, 4639 lang_output_section_statement_type *output_section_statement, 4640 fill_type *fill, 4641 bfd_vma dot) 4642 { 4643 lang_input_section_type *is = &((*this_ptr)->input_section); 4644 asection *i = is->section; 4645 asection *o = output_section_statement->bfd_section; 4646 4647 if (i->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 4648 i->output_offset = i->vma - o->vma; 4649 else if ((i->flags & SEC_EXCLUDE) != 0) 4650 i->output_offset = dot - o->vma; 4651 else 4652 { 4653 bfd_size_type alignment_needed; 4654 4655 /* Align this section first to the input sections requirement, 4656 then to the output section's requirement. If this alignment 4657 is greater than any seen before, then record it too. Perform 4658 the alignment by inserting a magic 'padding' statement. */ 4659 4660 if (output_section_statement->subsection_alignment != -1) 4661 i->alignment_power = output_section_statement->subsection_alignment; 4662 4663 if (o->alignment_power < i->alignment_power) 4664 o->alignment_power = i->alignment_power; 4665 4666 alignment_needed = align_power (dot, i->alignment_power) - dot; 4667 4668 if (alignment_needed != 0) 4669 { 4670 insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot); 4671 dot += alignment_needed; 4672 } 4673 4674 /* Remember where in the output section this input section goes. */ 4675 i->output_offset = dot - o->vma; 4676 4677 /* Mark how big the output section must be to contain this now. */ 4678 dot += TO_ADDR (i->size); 4679 o->size = TO_SIZE (dot - o->vma); 4680 } 4681 4682 return dot; 4683 } 4684 4685 struct check_sec 4686 { 4687 asection *sec; 4688 bfd_boolean warned; 4689 }; 4690 4691 static int 4692 sort_sections_by_lma (const void *arg1, const void *arg2) 4693 { 4694 const asection *sec1 = ((const struct check_sec *) arg1)->sec; 4695 const asection *sec2 = ((const struct check_sec *) arg2)->sec; 4696 4697 if (sec1->lma < sec2->lma) 4698 return -1; 4699 else if (sec1->lma > sec2->lma) 4700 return 1; 4701 else if (sec1->id < sec2->id) 4702 return -1; 4703 else if (sec1->id > sec2->id) 4704 return 1; 4705 4706 return 0; 4707 } 4708 4709 static int 4710 sort_sections_by_vma (const void *arg1, const void *arg2) 4711 { 4712 const asection *sec1 = ((const struct check_sec *) arg1)->sec; 4713 const asection *sec2 = ((const struct check_sec *) arg2)->sec; 4714 4715 if (sec1->vma < sec2->vma) 4716 return -1; 4717 else if (sec1->vma > sec2->vma) 4718 return 1; 4719 else if (sec1->id < sec2->id) 4720 return -1; 4721 else if (sec1->id > sec2->id) 4722 return 1; 4723 4724 return 0; 4725 } 4726 4727 #define IS_TBSS(s) \ 4728 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL) 4729 4730 #define IGNORE_SECTION(s) \ 4731 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s)) 4732 4733 /* Check to see if any allocated sections overlap with other allocated 4734 sections. This can happen if a linker script specifies the output 4735 section addresses of the two sections. Also check whether any memory 4736 region has overflowed. */ 4737 4738 static void 4739 lang_check_section_addresses (void) 4740 { 4741 asection *s, *p; 4742 struct check_sec *sections; 4743 size_t i, count; 4744 bfd_vma s_start; 4745 bfd_vma s_end; 4746 bfd_vma p_start = 0; 4747 bfd_vma p_end = 0; 4748 lang_memory_region_type *m; 4749 bfd_boolean overlays; 4750 4751 if (bfd_count_sections (link_info.output_bfd) <= 1) 4752 return; 4753 4754 count = bfd_count_sections (link_info.output_bfd); 4755 sections = XNEWVEC (struct check_sec, count); 4756 4757 /* Scan all sections in the output list. */ 4758 count = 0; 4759 for (s = link_info.output_bfd->sections; s != NULL; s = s->next) 4760 { 4761 if (IGNORE_SECTION (s) 4762 || s->size == 0) 4763 continue; 4764 4765 sections[count].sec = s; 4766 sections[count].warned = FALSE; 4767 count++; 4768 } 4769 4770 if (count <= 1) 4771 { 4772 free (sections); 4773 return; 4774 } 4775 4776 qsort (sections, count, sizeof (*sections), sort_sections_by_lma); 4777 4778 /* First check section LMAs. There should be no overlap of LMAs on 4779 loadable sections, even with overlays. */ 4780 for (p = NULL, i = 0; i < count; i++) 4781 { 4782 s = sections[i].sec; 4783 if ((s->flags & SEC_LOAD) != 0) 4784 { 4785 s_start = s->lma; 4786 s_end = s_start + TO_ADDR (s->size) - 1; 4787 4788 /* Look for an overlap. We have sorted sections by lma, so 4789 we know that s_start >= p_start. Besides the obvious 4790 case of overlap when the current section starts before 4791 the previous one ends, we also must have overlap if the 4792 previous section wraps around the address space. */ 4793 if (p != NULL 4794 && (s_start <= p_end 4795 || p_end < p_start)) 4796 { 4797 einfo (_("%X%P: section %s LMA [%V,%V]" 4798 " overlaps section %s LMA [%V,%V]\n"), 4799 s->name, s_start, s_end, p->name, p_start, p_end); 4800 sections[i].warned = TRUE; 4801 } 4802 p = s; 4803 p_start = s_start; 4804 p_end = s_end; 4805 } 4806 } 4807 4808 /* If any non-zero size allocated section (excluding tbss) starts at 4809 exactly the same VMA as another such section, then we have 4810 overlays. Overlays generated by the OVERLAY keyword will have 4811 this property. It is possible to intentionally generate overlays 4812 that fail this test, but it would be unusual. */ 4813 qsort (sections, count, sizeof (*sections), sort_sections_by_vma); 4814 overlays = FALSE; 4815 p_start = sections[0].sec->vma; 4816 for (i = 1; i < count; i++) 4817 { 4818 s_start = sections[i].sec->vma; 4819 if (p_start == s_start) 4820 { 4821 overlays = TRUE; 4822 break; 4823 } 4824 p_start = s_start; 4825 } 4826 4827 /* Now check section VMAs if no overlays were detected. */ 4828 if (!overlays) 4829 { 4830 for (p = NULL, i = 0; i < count; i++) 4831 { 4832 s = sections[i].sec; 4833 s_start = s->vma; 4834 s_end = s_start + TO_ADDR (s->size) - 1; 4835 4836 if (p != NULL 4837 && !sections[i].warned 4838 && (s_start <= p_end 4839 || p_end < p_start)) 4840 einfo (_("%X%P: section %s VMA [%V,%V]" 4841 " overlaps section %s VMA [%V,%V]\n"), 4842 s->name, s_start, s_end, p->name, p_start, p_end); 4843 p = s; 4844 p_start = s_start; 4845 p_end = s_end; 4846 } 4847 } 4848 4849 free (sections); 4850 4851 /* If any memory region has overflowed, report by how much. 4852 We do not issue this diagnostic for regions that had sections 4853 explicitly placed outside their bounds; os_region_check's 4854 diagnostics are adequate for that case. 4855 4856 FIXME: It is conceivable that m->current - (m->origin + m->length) 4857 might overflow a 32-bit integer. There is, alas, no way to print 4858 a bfd_vma quantity in decimal. */ 4859 for (m = lang_memory_region_list; m; m = m->next) 4860 if (m->had_full_message) 4861 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"), 4862 m->name_list.name, (long)(m->current - (m->origin + m->length))); 4863 } 4864 4865 /* Make sure the new address is within the region. We explicitly permit the 4866 current address to be at the exact end of the region when the address is 4867 non-zero, in case the region is at the end of addressable memory and the 4868 calculation wraps around. */ 4869 4870 static void 4871 os_region_check (lang_output_section_statement_type *os, 4872 lang_memory_region_type *region, 4873 etree_type *tree, 4874 bfd_vma rbase) 4875 { 4876 if ((region->current < region->origin 4877 || (region->current - region->origin > region->length)) 4878 && ((region->current != region->origin + region->length) 4879 || rbase == 0)) 4880 { 4881 if (tree != NULL) 4882 { 4883 einfo (_("%X%P: address 0x%v of %B section `%s'" 4884 " is not within region `%s'\n"), 4885 region->current, 4886 os->bfd_section->owner, 4887 os->bfd_section->name, 4888 region->name_list.name); 4889 } 4890 else if (!region->had_full_message) 4891 { 4892 region->had_full_message = TRUE; 4893 4894 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"), 4895 os->bfd_section->owner, 4896 os->bfd_section->name, 4897 region->name_list.name); 4898 } 4899 } 4900 } 4901 4902 /* Set the sizes for all the output sections. */ 4903 4904 static bfd_vma 4905 lang_size_sections_1 4906 (lang_statement_union_type **prev, 4907 lang_output_section_statement_type *output_section_statement, 4908 fill_type *fill, 4909 bfd_vma dot, 4910 bfd_boolean *relax, 4911 bfd_boolean check_regions) 4912 { 4913 lang_statement_union_type *s; 4914 4915 /* Size up the sections from their constituent parts. */ 4916 for (s = *prev; s != NULL; s = s->header.next) 4917 { 4918 switch (s->header.type) 4919 { 4920 case lang_output_section_statement_enum: 4921 { 4922 bfd_vma newdot, after, dotdelta; 4923 lang_output_section_statement_type *os; 4924 lang_memory_region_type *r; 4925 int section_alignment = 0; 4926 4927 os = &s->output_section_statement; 4928 if (os->constraint == -1) 4929 break; 4930 4931 /* FIXME: We shouldn't need to zero section vmas for ld -r 4932 here, in lang_insert_orphan, or in the default linker scripts. 4933 This is covering for coff backend linker bugs. See PR6945. */ 4934 if (os->addr_tree == NULL 4935 && bfd_link_relocatable (&link_info) 4936 && (bfd_get_flavour (link_info.output_bfd) 4937 == bfd_target_coff_flavour)) 4938 os->addr_tree = exp_intop (0); 4939 if (os->addr_tree != NULL) 4940 { 4941 os->processed_vma = FALSE; 4942 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot); 4943 4944 if (expld.result.valid_p) 4945 { 4946 dot = expld.result.value; 4947 if (expld.result.section != NULL) 4948 dot += expld.result.section->vma; 4949 } 4950 else if (expld.phase != lang_mark_phase_enum) 4951 einfo (_("%F%S: non constant or forward reference" 4952 " address expression for section %s\n"), 4953 os->addr_tree, os->name); 4954 } 4955 4956 if (os->bfd_section == NULL) 4957 /* This section was removed or never actually created. */ 4958 break; 4959 4960 /* If this is a COFF shared library section, use the size and 4961 address from the input section. FIXME: This is COFF 4962 specific; it would be cleaner if there were some other way 4963 to do this, but nothing simple comes to mind. */ 4964 if (((bfd_get_flavour (link_info.output_bfd) 4965 == bfd_target_ecoff_flavour) 4966 || (bfd_get_flavour (link_info.output_bfd) 4967 == bfd_target_coff_flavour)) 4968 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0) 4969 { 4970 asection *input; 4971 4972 if (os->children.head == NULL 4973 || os->children.head->header.next != NULL 4974 || (os->children.head->header.type 4975 != lang_input_section_enum)) 4976 einfo (_("%P%X: Internal error on COFF shared library" 4977 " section %s\n"), os->name); 4978 4979 input = os->children.head->input_section.section; 4980 bfd_set_section_vma (os->bfd_section->owner, 4981 os->bfd_section, 4982 bfd_section_vma (input->owner, input)); 4983 os->bfd_section->size = input->size; 4984 break; 4985 } 4986 4987 newdot = dot; 4988 dotdelta = 0; 4989 if (bfd_is_abs_section (os->bfd_section)) 4990 { 4991 /* No matter what happens, an abs section starts at zero. */ 4992 ASSERT (os->bfd_section->vma == 0); 4993 } 4994 else 4995 { 4996 if (os->addr_tree == NULL) 4997 { 4998 /* No address specified for this section, get one 4999 from the region specification. */ 5000 if (os->region == NULL 5001 || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD)) 5002 && os->region->name_list.name[0] == '*' 5003 && strcmp (os->region->name_list.name, 5004 DEFAULT_MEMORY_REGION) == 0)) 5005 { 5006 os->region = lang_memory_default (os->bfd_section); 5007 } 5008 5009 /* If a loadable section is using the default memory 5010 region, and some non default memory regions were 5011 defined, issue an error message. */ 5012 if (!os->ignored 5013 && !IGNORE_SECTION (os->bfd_section) 5014 && !bfd_link_relocatable (&link_info) 5015 && check_regions 5016 && strcmp (os->region->name_list.name, 5017 DEFAULT_MEMORY_REGION) == 0 5018 && lang_memory_region_list != NULL 5019 && (strcmp (lang_memory_region_list->name_list.name, 5020 DEFAULT_MEMORY_REGION) != 0 5021 || lang_memory_region_list->next != NULL) 5022 && expld.phase != lang_mark_phase_enum) 5023 { 5024 /* By default this is an error rather than just a 5025 warning because if we allocate the section to the 5026 default memory region we can end up creating an 5027 excessively large binary, or even seg faulting when 5028 attempting to perform a negative seek. See 5029 sources.redhat.com/ml/binutils/2003-04/msg00423.html 5030 for an example of this. This behaviour can be 5031 overridden by the using the --no-check-sections 5032 switch. */ 5033 if (command_line.check_section_addresses) 5034 einfo (_("%P%F: error: no memory region specified" 5035 " for loadable section `%s'\n"), 5036 bfd_get_section_name (link_info.output_bfd, 5037 os->bfd_section)); 5038 else 5039 einfo (_("%P: warning: no memory region specified" 5040 " for loadable section `%s'\n"), 5041 bfd_get_section_name (link_info.output_bfd, 5042 os->bfd_section)); 5043 } 5044 5045 newdot = os->region->current; 5046 section_alignment = os->bfd_section->alignment_power; 5047 } 5048 else 5049 section_alignment = os->section_alignment; 5050 5051 /* Align to what the section needs. */ 5052 if (section_alignment > 0) 5053 { 5054 bfd_vma savedot = newdot; 5055 newdot = align_power (newdot, section_alignment); 5056 5057 dotdelta = newdot - savedot; 5058 if (dotdelta != 0 5059 && (config.warn_section_align 5060 || os->addr_tree != NULL) 5061 && expld.phase != lang_mark_phase_enum) 5062 einfo (_("%P: warning: changing start of section" 5063 " %s by %lu bytes\n"), 5064 os->name, (unsigned long) dotdelta); 5065 } 5066 5067 bfd_set_section_vma (0, os->bfd_section, newdot); 5068 5069 os->bfd_section->output_offset = 0; 5070 } 5071 5072 lang_size_sections_1 (&os->children.head, os, 5073 os->fill, newdot, relax, check_regions); 5074 5075 os->processed_vma = TRUE; 5076 5077 if (bfd_is_abs_section (os->bfd_section) || os->ignored) 5078 /* Except for some special linker created sections, 5079 no output section should change from zero size 5080 after strip_excluded_output_sections. A non-zero 5081 size on an ignored section indicates that some 5082 input section was not sized early enough. */ 5083 ASSERT (os->bfd_section->size == 0); 5084 else 5085 { 5086 dot = os->bfd_section->vma; 5087 5088 /* Put the section within the requested block size, or 5089 align at the block boundary. */ 5090 after = ((dot 5091 + TO_ADDR (os->bfd_section->size) 5092 + os->block_value - 1) 5093 & - (bfd_vma) os->block_value); 5094 5095 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma); 5096 } 5097 5098 /* Set section lma. */ 5099 r = os->region; 5100 if (r == NULL) 5101 r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE); 5102 5103 if (os->load_base) 5104 { 5105 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base"); 5106 os->bfd_section->lma = lma; 5107 } 5108 else if (os->lma_region != NULL) 5109 { 5110 bfd_vma lma = os->lma_region->current; 5111 5112 if (os->align_lma_with_input) 5113 lma += dotdelta; 5114 else 5115 { 5116 /* When LMA_REGION is the same as REGION, align the LMA 5117 as we did for the VMA, possibly including alignment 5118 from the bfd section. If a different region, then 5119 only align according to the value in the output 5120 statement. */ 5121 if (os->lma_region != os->region) 5122 section_alignment = os->section_alignment; 5123 if (section_alignment > 0) 5124 lma = align_power (lma, section_alignment); 5125 } 5126 os->bfd_section->lma = lma; 5127 } 5128 else if (r->last_os != NULL 5129 && (os->bfd_section->flags & SEC_ALLOC) != 0) 5130 { 5131 bfd_vma lma; 5132 asection *last; 5133 5134 last = r->last_os->output_section_statement.bfd_section; 5135 5136 /* A backwards move of dot should be accompanied by 5137 an explicit assignment to the section LMA (ie. 5138 os->load_base set) because backwards moves can 5139 create overlapping LMAs. */ 5140 if (dot < last->vma 5141 && os->bfd_section->size != 0 5142 && dot + TO_ADDR (os->bfd_section->size) <= last->vma) 5143 { 5144 /* If dot moved backwards then leave lma equal to 5145 vma. This is the old default lma, which might 5146 just happen to work when the backwards move is 5147 sufficiently large. Nag if this changes anything, 5148 so people can fix their linker scripts. */ 5149 5150 if (last->vma != last->lma) 5151 einfo (_("%P: warning: dot moved backwards " 5152 "before `%s'\n"), os->name); 5153 } 5154 else 5155 { 5156 /* If this is an overlay, set the current lma to that 5157 at the end of the previous section. */ 5158 if (os->sectype == overlay_section) 5159 lma = last->lma + TO_ADDR (last->size); 5160 5161 /* Otherwise, keep the same lma to vma relationship 5162 as the previous section. */ 5163 else 5164 lma = dot + last->lma - last->vma; 5165 5166 if (section_alignment > 0) 5167 lma = align_power (lma, section_alignment); 5168 os->bfd_section->lma = lma; 5169 } 5170 } 5171 os->processed_lma = TRUE; 5172 5173 if (bfd_is_abs_section (os->bfd_section) || os->ignored) 5174 break; 5175 5176 /* Keep track of normal sections using the default 5177 lma region. We use this to set the lma for 5178 following sections. Overlays or other linker 5179 script assignment to lma might mean that the 5180 default lma == vma is incorrect. 5181 To avoid warnings about dot moving backwards when using 5182 -Ttext, don't start tracking sections until we find one 5183 of non-zero size or with lma set differently to vma. */ 5184 if (!IGNORE_SECTION (os->bfd_section) 5185 && (os->bfd_section->size != 0 5186 || (r->last_os == NULL 5187 && os->bfd_section->vma != os->bfd_section->lma) 5188 || (r->last_os != NULL 5189 && dot >= (r->last_os->output_section_statement 5190 .bfd_section->vma))) 5191 && os->lma_region == NULL 5192 && !bfd_link_relocatable (&link_info)) 5193 r->last_os = s; 5194 5195 /* .tbss sections effectively have zero size. */ 5196 if (!IS_TBSS (os->bfd_section) 5197 || bfd_link_relocatable (&link_info)) 5198 dotdelta = TO_ADDR (os->bfd_section->size); 5199 else 5200 dotdelta = 0; 5201 dot += dotdelta; 5202 5203 if (os->update_dot_tree != 0) 5204 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot); 5205 5206 /* Update dot in the region ? 5207 We only do this if the section is going to be allocated, 5208 since unallocated sections do not contribute to the region's 5209 overall size in memory. */ 5210 if (os->region != NULL 5211 && (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))) 5212 { 5213 os->region->current = dot; 5214 5215 if (check_regions) 5216 /* Make sure the new address is within the region. */ 5217 os_region_check (os, os->region, os->addr_tree, 5218 os->bfd_section->vma); 5219 5220 if (os->lma_region != NULL && os->lma_region != os->region 5221 && ((os->bfd_section->flags & SEC_LOAD) 5222 || os->align_lma_with_input)) 5223 { 5224 os->lma_region->current = os->bfd_section->lma + dotdelta; 5225 5226 if (check_regions) 5227 os_region_check (os, os->lma_region, NULL, 5228 os->bfd_section->lma); 5229 } 5230 } 5231 } 5232 break; 5233 5234 case lang_constructors_statement_enum: 5235 dot = lang_size_sections_1 (&constructor_list.head, 5236 output_section_statement, 5237 fill, dot, relax, check_regions); 5238 break; 5239 5240 case lang_data_statement_enum: 5241 { 5242 unsigned int size = 0; 5243 5244 s->data_statement.output_offset = 5245 dot - output_section_statement->bfd_section->vma; 5246 s->data_statement.output_section = 5247 output_section_statement->bfd_section; 5248 5249 /* We might refer to provided symbols in the expression, and 5250 need to mark them as needed. */ 5251 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot); 5252 5253 switch (s->data_statement.type) 5254 { 5255 default: 5256 abort (); 5257 case QUAD: 5258 case SQUAD: 5259 size = QUAD_SIZE; 5260 break; 5261 case LONG: 5262 size = LONG_SIZE; 5263 break; 5264 case SHORT: 5265 size = SHORT_SIZE; 5266 break; 5267 case BYTE: 5268 size = BYTE_SIZE; 5269 break; 5270 } 5271 if (size < TO_SIZE ((unsigned) 1)) 5272 size = TO_SIZE ((unsigned) 1); 5273 dot += TO_ADDR (size); 5274 output_section_statement->bfd_section->size 5275 = TO_SIZE (dot - output_section_statement->bfd_section->vma); 5276 5277 } 5278 break; 5279 5280 case lang_reloc_statement_enum: 5281 { 5282 int size; 5283 5284 s->reloc_statement.output_offset = 5285 dot - output_section_statement->bfd_section->vma; 5286 s->reloc_statement.output_section = 5287 output_section_statement->bfd_section; 5288 size = bfd_get_reloc_size (s->reloc_statement.howto); 5289 dot += TO_ADDR (size); 5290 output_section_statement->bfd_section->size 5291 = TO_SIZE (dot - output_section_statement->bfd_section->vma); 5292 } 5293 break; 5294 5295 case lang_wild_statement_enum: 5296 dot = lang_size_sections_1 (&s->wild_statement.children.head, 5297 output_section_statement, 5298 fill, dot, relax, check_regions); 5299 break; 5300 5301 case lang_object_symbols_statement_enum: 5302 link_info.create_object_symbols_section = 5303 output_section_statement->bfd_section; 5304 break; 5305 5306 case lang_output_statement_enum: 5307 case lang_target_statement_enum: 5308 break; 5309 5310 case lang_input_section_enum: 5311 { 5312 asection *i; 5313 5314 i = s->input_section.section; 5315 if (relax) 5316 { 5317 bfd_boolean again; 5318 5319 if (!bfd_relax_section (i->owner, i, &link_info, &again)) 5320 einfo (_("%P%F: can't relax section: %E\n")); 5321 if (again) 5322 *relax = TRUE; 5323 } 5324 dot = size_input_section (prev, output_section_statement, 5325 fill, dot); 5326 } 5327 break; 5328 5329 case lang_input_statement_enum: 5330 break; 5331 5332 case lang_fill_statement_enum: 5333 s->fill_statement.output_section = 5334 output_section_statement->bfd_section; 5335 5336 fill = s->fill_statement.fill; 5337 break; 5338 5339 case lang_assignment_statement_enum: 5340 { 5341 bfd_vma newdot = dot; 5342 etree_type *tree = s->assignment_statement.exp; 5343 5344 expld.dataseg.relro = exp_dataseg_relro_none; 5345 5346 exp_fold_tree (tree, 5347 output_section_statement->bfd_section, 5348 &newdot); 5349 5350 if (expld.dataseg.relro == exp_dataseg_relro_start) 5351 { 5352 if (!expld.dataseg.relro_start_stat) 5353 expld.dataseg.relro_start_stat = s; 5354 else 5355 { 5356 ASSERT (expld.dataseg.relro_start_stat == s); 5357 } 5358 } 5359 else if (expld.dataseg.relro == exp_dataseg_relro_end) 5360 { 5361 if (!expld.dataseg.relro_end_stat) 5362 expld.dataseg.relro_end_stat = s; 5363 else 5364 { 5365 ASSERT (expld.dataseg.relro_end_stat == s); 5366 } 5367 } 5368 expld.dataseg.relro = exp_dataseg_relro_none; 5369 5370 /* This symbol is relative to this section. */ 5371 if ((tree->type.node_class == etree_provided 5372 || tree->type.node_class == etree_assign) 5373 && (tree->assign.dst [0] != '.' 5374 || tree->assign.dst [1] != '\0')) 5375 output_section_statement->update_dot = 1; 5376 5377 if (!output_section_statement->ignored) 5378 { 5379 if (output_section_statement == abs_output_section) 5380 { 5381 /* If we don't have an output section, then just adjust 5382 the default memory address. */ 5383 lang_memory_region_lookup (DEFAULT_MEMORY_REGION, 5384 FALSE)->current = newdot; 5385 } 5386 else if (newdot != dot) 5387 { 5388 /* Insert a pad after this statement. We can't 5389 put the pad before when relaxing, in case the 5390 assignment references dot. */ 5391 insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot), 5392 output_section_statement->bfd_section, dot); 5393 5394 /* Don't neuter the pad below when relaxing. */ 5395 s = s->header.next; 5396 5397 /* If dot is advanced, this implies that the section 5398 should have space allocated to it, unless the 5399 user has explicitly stated that the section 5400 should not be allocated. */ 5401 if (output_section_statement->sectype != noalloc_section 5402 && (output_section_statement->sectype != noload_section 5403 || (bfd_get_flavour (link_info.output_bfd) 5404 == bfd_target_elf_flavour))) 5405 output_section_statement->bfd_section->flags |= SEC_ALLOC; 5406 } 5407 dot = newdot; 5408 } 5409 } 5410 break; 5411 5412 case lang_padding_statement_enum: 5413 /* If this is the first time lang_size_sections is called, 5414 we won't have any padding statements. If this is the 5415 second or later passes when relaxing, we should allow 5416 padding to shrink. If padding is needed on this pass, it 5417 will be added back in. */ 5418 s->padding_statement.size = 0; 5419 5420 /* Make sure output_offset is valid. If relaxation shrinks 5421 the section and this pad isn't needed, it's possible to 5422 have output_offset larger than the final size of the 5423 section. bfd_set_section_contents will complain even for 5424 a pad size of zero. */ 5425 s->padding_statement.output_offset 5426 = dot - output_section_statement->bfd_section->vma; 5427 break; 5428 5429 case lang_group_statement_enum: 5430 dot = lang_size_sections_1 (&s->group_statement.children.head, 5431 output_section_statement, 5432 fill, dot, relax, check_regions); 5433 break; 5434 5435 case lang_insert_statement_enum: 5436 break; 5437 5438 /* We can only get here when relaxing is turned on. */ 5439 case lang_address_statement_enum: 5440 break; 5441 5442 default: 5443 FAIL (); 5444 break; 5445 } 5446 prev = &s->header.next; 5447 } 5448 return dot; 5449 } 5450 5451 /* Callback routine that is used in _bfd_elf_map_sections_to_segments. 5452 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that 5453 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different 5454 segments. We are allowed an opportunity to override this decision. */ 5455 5456 bfd_boolean 5457 ldlang_override_segment_assignment (struct bfd_link_info *info ATTRIBUTE_UNUSED, 5458 bfd *abfd ATTRIBUTE_UNUSED, 5459 asection *current_section, 5460 asection *previous_section, 5461 bfd_boolean new_segment) 5462 { 5463 lang_output_section_statement_type *cur; 5464 lang_output_section_statement_type *prev; 5465 5466 /* The checks below are only necessary when the BFD library has decided 5467 that the two sections ought to be placed into the same segment. */ 5468 if (new_segment) 5469 return TRUE; 5470 5471 /* Paranoia checks. */ 5472 if (current_section == NULL || previous_section == NULL) 5473 return new_segment; 5474 5475 /* If this flag is set, the target never wants code and non-code 5476 sections comingled in the same segment. */ 5477 if (config.separate_code 5478 && ((current_section->flags ^ previous_section->flags) & SEC_CODE)) 5479 return TRUE; 5480 5481 /* Find the memory regions associated with the two sections. 5482 We call lang_output_section_find() here rather than scanning the list 5483 of output sections looking for a matching section pointer because if 5484 we have a large number of sections then a hash lookup is faster. */ 5485 cur = lang_output_section_find (current_section->name); 5486 prev = lang_output_section_find (previous_section->name); 5487 5488 /* More paranoia. */ 5489 if (cur == NULL || prev == NULL) 5490 return new_segment; 5491 5492 /* If the regions are different then force the sections to live in 5493 different segments. See the email thread starting at the following 5494 URL for the reasons why this is necessary: 5495 http://sourceware.org/ml/binutils/2007-02/msg00216.html */ 5496 return cur->region != prev->region; 5497 } 5498 5499 void 5500 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions) 5501 { 5502 lang_statement_iteration++; 5503 lang_size_sections_1 (&statement_list.head, abs_output_section, 5504 0, 0, relax, check_regions); 5505 } 5506 5507 void 5508 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions) 5509 { 5510 expld.phase = lang_allocating_phase_enum; 5511 expld.dataseg.phase = exp_dataseg_none; 5512 5513 one_lang_size_sections_pass (relax, check_regions); 5514 if (expld.dataseg.phase == exp_dataseg_end_seen 5515 && link_info.relro && expld.dataseg.relro_end) 5516 { 5517 bfd_vma initial_base, relro_end, desired_end; 5518 asection *sec; 5519 5520 /* Compute the expected PT_GNU_RELRO segment end. */ 5521 relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1) 5522 & ~(expld.dataseg.pagesize - 1)); 5523 5524 /* Adjust by the offset arg of DATA_SEGMENT_RELRO_END. */ 5525 desired_end = relro_end - expld.dataseg.relro_offset; 5526 5527 /* For sections in the relro segment.. */ 5528 for (sec = link_info.output_bfd->section_last; sec; sec = sec->prev) 5529 if ((sec->flags & SEC_ALLOC) != 0 5530 && sec->vma >= expld.dataseg.base 5531 && sec->vma < expld.dataseg.relro_end - expld.dataseg.relro_offset) 5532 { 5533 /* Where do we want to put this section so that it ends as 5534 desired? */ 5535 bfd_vma start, end, bump; 5536 5537 end = start = sec->vma; 5538 if (!IS_TBSS (sec)) 5539 end += TO_ADDR (sec->size); 5540 bump = desired_end - end; 5541 /* We'd like to increase START by BUMP, but we must heed 5542 alignment so the increase might be less than optimum. */ 5543 start += bump; 5544 start &= ~(((bfd_vma) 1 << sec->alignment_power) - 1); 5545 /* This is now the desired end for the previous section. */ 5546 desired_end = start; 5547 } 5548 5549 expld.dataseg.phase = exp_dataseg_relro_adjust; 5550 ASSERT (desired_end >= expld.dataseg.base); 5551 initial_base = expld.dataseg.base; 5552 expld.dataseg.base = desired_end; 5553 lang_reset_memory_regions (); 5554 one_lang_size_sections_pass (relax, check_regions); 5555 5556 if (expld.dataseg.relro_end > relro_end) 5557 { 5558 /* Assignments to dot, or to output section address in a 5559 user script have increased padding over the original. 5560 Revert. */ 5561 expld.dataseg.base = initial_base; 5562 lang_reset_memory_regions (); 5563 one_lang_size_sections_pass (relax, check_regions); 5564 } 5565 5566 link_info.relro_start = expld.dataseg.base; 5567 link_info.relro_end = expld.dataseg.relro_end; 5568 } 5569 else if (expld.dataseg.phase == exp_dataseg_end_seen) 5570 { 5571 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether 5572 a page could be saved in the data segment. */ 5573 bfd_vma first, last; 5574 5575 first = -expld.dataseg.base & (expld.dataseg.pagesize - 1); 5576 last = expld.dataseg.end & (expld.dataseg.pagesize - 1); 5577 if (first && last 5578 && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1)) 5579 != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1))) 5580 && first + last <= expld.dataseg.pagesize) 5581 { 5582 expld.dataseg.phase = exp_dataseg_adjust; 5583 lang_reset_memory_regions (); 5584 one_lang_size_sections_pass (relax, check_regions); 5585 } 5586 else 5587 expld.dataseg.phase = exp_dataseg_done; 5588 } 5589 else 5590 expld.dataseg.phase = exp_dataseg_done; 5591 } 5592 5593 /* Worker function for lang_do_assignments. Recursiveness goes here. */ 5594 5595 static bfd_vma 5596 lang_do_assignments_1 (lang_statement_union_type *s, 5597 lang_output_section_statement_type *current_os, 5598 fill_type *fill, 5599 bfd_vma dot) 5600 { 5601 for (; s != NULL; s = s->header.next) 5602 { 5603 switch (s->header.type) 5604 { 5605 case lang_constructors_statement_enum: 5606 dot = lang_do_assignments_1 (constructor_list.head, 5607 current_os, fill, dot); 5608 break; 5609 5610 case lang_output_section_statement_enum: 5611 { 5612 lang_output_section_statement_type *os; 5613 5614 os = &(s->output_section_statement); 5615 if (os->bfd_section != NULL && !os->ignored) 5616 { 5617 dot = os->bfd_section->vma; 5618 5619 lang_do_assignments_1 (os->children.head, os, os->fill, dot); 5620 5621 /* .tbss sections effectively have zero size. */ 5622 if (!IS_TBSS (os->bfd_section) 5623 || bfd_link_relocatable (&link_info)) 5624 dot += TO_ADDR (os->bfd_section->size); 5625 5626 if (os->update_dot_tree != NULL) 5627 exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, 5628 &dot); 5629 } 5630 } 5631 break; 5632 5633 case lang_wild_statement_enum: 5634 5635 dot = lang_do_assignments_1 (s->wild_statement.children.head, 5636 current_os, fill, dot); 5637 break; 5638 5639 case lang_object_symbols_statement_enum: 5640 case lang_output_statement_enum: 5641 case lang_target_statement_enum: 5642 break; 5643 5644 case lang_data_statement_enum: 5645 exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot); 5646 if (expld.result.valid_p) 5647 { 5648 s->data_statement.value = expld.result.value; 5649 if (expld.result.section != NULL) 5650 s->data_statement.value += expld.result.section->vma; 5651 } 5652 else 5653 einfo (_("%F%P: invalid data statement\n")); 5654 { 5655 unsigned int size; 5656 switch (s->data_statement.type) 5657 { 5658 default: 5659 abort (); 5660 case QUAD: 5661 case SQUAD: 5662 size = QUAD_SIZE; 5663 break; 5664 case LONG: 5665 size = LONG_SIZE; 5666 break; 5667 case SHORT: 5668 size = SHORT_SIZE; 5669 break; 5670 case BYTE: 5671 size = BYTE_SIZE; 5672 break; 5673 } 5674 if (size < TO_SIZE ((unsigned) 1)) 5675 size = TO_SIZE ((unsigned) 1); 5676 dot += TO_ADDR (size); 5677 } 5678 break; 5679 5680 case lang_reloc_statement_enum: 5681 exp_fold_tree (s->reloc_statement.addend_exp, 5682 bfd_abs_section_ptr, &dot); 5683 if (expld.result.valid_p) 5684 s->reloc_statement.addend_value = expld.result.value; 5685 else 5686 einfo (_("%F%P: invalid reloc statement\n")); 5687 dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto)); 5688 break; 5689 5690 case lang_input_section_enum: 5691 { 5692 asection *in = s->input_section.section; 5693 5694 if ((in->flags & SEC_EXCLUDE) == 0) 5695 dot += TO_ADDR (in->size); 5696 } 5697 break; 5698 5699 case lang_input_statement_enum: 5700 break; 5701 5702 case lang_fill_statement_enum: 5703 fill = s->fill_statement.fill; 5704 break; 5705 5706 case lang_assignment_statement_enum: 5707 exp_fold_tree (s->assignment_statement.exp, 5708 current_os->bfd_section, 5709 &dot); 5710 break; 5711 5712 case lang_padding_statement_enum: 5713 dot += TO_ADDR (s->padding_statement.size); 5714 break; 5715 5716 case lang_group_statement_enum: 5717 dot = lang_do_assignments_1 (s->group_statement.children.head, 5718 current_os, fill, dot); 5719 break; 5720 5721 case lang_insert_statement_enum: 5722 break; 5723 5724 case lang_address_statement_enum: 5725 break; 5726 5727 default: 5728 FAIL (); 5729 break; 5730 } 5731 } 5732 return dot; 5733 } 5734 5735 void 5736 lang_do_assignments (lang_phase_type phase) 5737 { 5738 expld.phase = phase; 5739 lang_statement_iteration++; 5740 lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0); 5741 } 5742 5743 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the 5744 operator .startof. (section_name), it produces an undefined symbol 5745 .startof.section_name. Similarly, when it sees 5746 .sizeof. (section_name), it produces an undefined symbol 5747 .sizeof.section_name. For all the output sections, we look for 5748 such symbols, and set them to the correct value. */ 5749 5750 static void 5751 lang_set_startof (void) 5752 { 5753 asection *s; 5754 5755 if (bfd_link_relocatable (&link_info)) 5756 return; 5757 5758 for (s = link_info.output_bfd->sections; s != NULL; s = s->next) 5759 { 5760 const char *secname; 5761 char *buf; 5762 struct bfd_link_hash_entry *h; 5763 5764 secname = bfd_get_section_name (link_info.output_bfd, s); 5765 buf = (char *) xmalloc (10 + strlen (secname)); 5766 5767 sprintf (buf, ".startof.%s", secname); 5768 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE); 5769 if (h != NULL && h->type == bfd_link_hash_undefined) 5770 { 5771 h->type = bfd_link_hash_defined; 5772 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s); 5773 h->u.def.section = bfd_abs_section_ptr; 5774 } 5775 5776 sprintf (buf, ".sizeof.%s", secname); 5777 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE); 5778 if (h != NULL && h->type == bfd_link_hash_undefined) 5779 { 5780 h->type = bfd_link_hash_defined; 5781 h->u.def.value = TO_ADDR (s->size); 5782 h->u.def.section = bfd_abs_section_ptr; 5783 } 5784 5785 free (buf); 5786 } 5787 } 5788 5789 static void 5790 lang_end (void) 5791 { 5792 struct bfd_link_hash_entry *h; 5793 bfd_boolean warn; 5794 5795 if ((bfd_link_relocatable (&link_info) && !link_info.gc_sections) 5796 || bfd_link_dll (&link_info)) 5797 warn = entry_from_cmdline; 5798 else 5799 warn = TRUE; 5800 5801 /* Force the user to specify a root when generating a relocatable with 5802 --gc-sections. */ 5803 if (link_info.gc_sections && bfd_link_relocatable (&link_info) 5804 && !(entry_from_cmdline || undef_from_cmdline)) 5805 einfo (_("%P%F: gc-sections requires either an entry or " 5806 "an undefined symbol\n")); 5807 5808 if (entry_symbol.name == NULL) 5809 { 5810 /* No entry has been specified. Look for the default entry, but 5811 don't warn if we don't find it. */ 5812 entry_symbol.name = entry_symbol_default; 5813 warn = FALSE; 5814 } 5815 5816 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name, 5817 FALSE, FALSE, TRUE); 5818 if (h != NULL 5819 && (h->type == bfd_link_hash_defined 5820 || h->type == bfd_link_hash_defweak) 5821 && h->u.def.section->output_section != NULL) 5822 { 5823 bfd_vma val; 5824 5825 val = (h->u.def.value 5826 + bfd_get_section_vma (link_info.output_bfd, 5827 h->u.def.section->output_section) 5828 + h->u.def.section->output_offset); 5829 if (!bfd_set_start_address (link_info.output_bfd, val)) 5830 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name); 5831 } 5832 else 5833 { 5834 bfd_vma val; 5835 const char *send; 5836 5837 /* We couldn't find the entry symbol. Try parsing it as a 5838 number. */ 5839 val = bfd_scan_vma (entry_symbol.name, &send, 0); 5840 if (*send == '\0') 5841 { 5842 if (!bfd_set_start_address (link_info.output_bfd, val)) 5843 einfo (_("%P%F: can't set start address\n")); 5844 } 5845 else 5846 { 5847 asection *ts; 5848 5849 /* Can't find the entry symbol, and it's not a number. Use 5850 the first address in the text section. */ 5851 ts = bfd_get_section_by_name (link_info.output_bfd, entry_section); 5852 if (ts != NULL) 5853 { 5854 if (warn) 5855 einfo (_("%P: warning: cannot find entry symbol %s;" 5856 " defaulting to %V\n"), 5857 entry_symbol.name, 5858 bfd_get_section_vma (link_info.output_bfd, ts)); 5859 if (!(bfd_set_start_address 5860 (link_info.output_bfd, 5861 bfd_get_section_vma (link_info.output_bfd, ts)))) 5862 einfo (_("%P%F: can't set start address\n")); 5863 } 5864 else 5865 { 5866 if (warn) 5867 einfo (_("%P: warning: cannot find entry symbol %s;" 5868 " not setting start address\n"), 5869 entry_symbol.name); 5870 } 5871 } 5872 } 5873 } 5874 5875 /* This is a small function used when we want to ignore errors from 5876 BFD. */ 5877 5878 static void 5879 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...) 5880 { 5881 /* Don't do anything. */ 5882 } 5883 5884 /* Check that the architecture of all the input files is compatible 5885 with the output file. Also call the backend to let it do any 5886 other checking that is needed. */ 5887 5888 static void 5889 lang_check (void) 5890 { 5891 lang_statement_union_type *file; 5892 bfd *input_bfd; 5893 const bfd_arch_info_type *compatible; 5894 5895 for (file = file_chain.head; file != NULL; file = file->input_statement.next) 5896 { 5897 #ifdef ENABLE_PLUGINS 5898 /* Don't check format of files claimed by plugin. */ 5899 if (file->input_statement.flags.claimed) 5900 continue; 5901 #endif /* ENABLE_PLUGINS */ 5902 input_bfd = file->input_statement.the_bfd; 5903 compatible 5904 = bfd_arch_get_compatible (input_bfd, link_info.output_bfd, 5905 command_line.accept_unknown_input_arch); 5906 5907 /* In general it is not possible to perform a relocatable 5908 link between differing object formats when the input 5909 file has relocations, because the relocations in the 5910 input format may not have equivalent representations in 5911 the output format (and besides BFD does not translate 5912 relocs for other link purposes than a final link). */ 5913 if ((bfd_link_relocatable (&link_info) 5914 || link_info.emitrelocations) 5915 && (compatible == NULL 5916 || (bfd_get_flavour (input_bfd) 5917 != bfd_get_flavour (link_info.output_bfd))) 5918 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0) 5919 { 5920 einfo (_("%P%F: Relocatable linking with relocations from" 5921 " format %s (%B) to format %s (%B) is not supported\n"), 5922 bfd_get_target (input_bfd), input_bfd, 5923 bfd_get_target (link_info.output_bfd), link_info.output_bfd); 5924 /* einfo with %F exits. */ 5925 } 5926 5927 if (compatible == NULL) 5928 { 5929 if (command_line.warn_mismatch) 5930 einfo (_("%P%X: %s architecture of input file `%B'" 5931 " is incompatible with %s output\n"), 5932 bfd_printable_name (input_bfd), input_bfd, 5933 bfd_printable_name (link_info.output_bfd)); 5934 } 5935 else if (bfd_count_sections (input_bfd)) 5936 { 5937 /* If the input bfd has no contents, it shouldn't set the 5938 private data of the output bfd. */ 5939 5940 bfd_error_handler_type pfn = NULL; 5941 5942 /* If we aren't supposed to warn about mismatched input 5943 files, temporarily set the BFD error handler to a 5944 function which will do nothing. We still want to call 5945 bfd_merge_private_bfd_data, since it may set up 5946 information which is needed in the output file. */ 5947 if (!command_line.warn_mismatch) 5948 pfn = bfd_set_error_handler (ignore_bfd_errors); 5949 if (!bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd)) 5950 { 5951 if (command_line.warn_mismatch) 5952 einfo (_("%P%X: failed to merge target specific data" 5953 " of file %B\n"), input_bfd); 5954 } 5955 if (!command_line.warn_mismatch) 5956 bfd_set_error_handler (pfn); 5957 } 5958 } 5959 } 5960 5961 /* Look through all the global common symbols and attach them to the 5962 correct section. The -sort-common command line switch may be used 5963 to roughly sort the entries by alignment. */ 5964 5965 static void 5966 lang_common (void) 5967 { 5968 if (command_line.inhibit_common_definition) 5969 return; 5970 if (bfd_link_relocatable (&link_info) 5971 && !command_line.force_common_definition) 5972 return; 5973 5974 if (!config.sort_common) 5975 bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL); 5976 else 5977 { 5978 unsigned int power; 5979 5980 if (config.sort_common == sort_descending) 5981 { 5982 for (power = 4; power > 0; power--) 5983 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power); 5984 5985 power = 0; 5986 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power); 5987 } 5988 else 5989 { 5990 for (power = 0; power <= 4; power++) 5991 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power); 5992 5993 power = (unsigned int) -1; 5994 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power); 5995 } 5996 } 5997 } 5998 5999 /* Place one common symbol in the correct section. */ 6000 6001 static bfd_boolean 6002 lang_one_common (struct bfd_link_hash_entry *h, void *info) 6003 { 6004 unsigned int power_of_two; 6005 bfd_vma size; 6006 asection *section; 6007 6008 if (h->type != bfd_link_hash_common) 6009 return TRUE; 6010 6011 size = h->u.c.size; 6012 power_of_two = h->u.c.p->alignment_power; 6013 6014 if (config.sort_common == sort_descending 6015 && power_of_two < *(unsigned int *) info) 6016 return TRUE; 6017 else if (config.sort_common == sort_ascending 6018 && power_of_two > *(unsigned int *) info) 6019 return TRUE; 6020 6021 section = h->u.c.p->section; 6022 if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h)) 6023 einfo (_("%P%F: Could not define common symbol `%T': %E\n"), 6024 h->root.string); 6025 6026 if (config.map_file != NULL) 6027 { 6028 static bfd_boolean header_printed; 6029 int len; 6030 char *name; 6031 char buf[50]; 6032 6033 if (!header_printed) 6034 { 6035 minfo (_("\nAllocating common symbols\n")); 6036 minfo (_("Common symbol size file\n\n")); 6037 header_printed = TRUE; 6038 } 6039 6040 name = bfd_demangle (link_info.output_bfd, h->root.string, 6041 DMGL_ANSI | DMGL_PARAMS); 6042 if (name == NULL) 6043 { 6044 minfo ("%s", h->root.string); 6045 len = strlen (h->root.string); 6046 } 6047 else 6048 { 6049 minfo ("%s", name); 6050 len = strlen (name); 6051 free (name); 6052 } 6053 6054 if (len >= 19) 6055 { 6056 print_nl (); 6057 len = 0; 6058 } 6059 while (len < 20) 6060 { 6061 print_space (); 6062 ++len; 6063 } 6064 6065 minfo ("0x"); 6066 if (size <= 0xffffffff) 6067 sprintf (buf, "%lx", (unsigned long) size); 6068 else 6069 sprintf_vma (buf, size); 6070 minfo ("%s", buf); 6071 len = strlen (buf); 6072 6073 while (len < 16) 6074 { 6075 print_space (); 6076 ++len; 6077 } 6078 6079 minfo ("%B\n", section->owner); 6080 } 6081 6082 return TRUE; 6083 } 6084 6085 /* Handle a single orphan section S, placing the orphan into an appropriate 6086 output section. The effects of the --orphan-handling command line 6087 option are handled here. */ 6088 6089 static void 6090 ldlang_place_orphan (asection *s) 6091 { 6092 if (config.orphan_handling == orphan_handling_discard) 6093 { 6094 lang_output_section_statement_type *os; 6095 os = lang_output_section_statement_lookup (DISCARD_SECTION_NAME, 0, 6096 TRUE); 6097 if (os->addr_tree == NULL 6098 && (bfd_link_relocatable (&link_info) 6099 || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)) 6100 os->addr_tree = exp_intop (0); 6101 lang_add_section (&os->children, s, NULL, os); 6102 } 6103 else 6104 { 6105 lang_output_section_statement_type *os; 6106 const char *name = s->name; 6107 int constraint = 0; 6108 6109 if (config.orphan_handling == orphan_handling_error) 6110 einfo ("%X%P: error: unplaced orphan section `%A' from `%B'.\n", 6111 s, s->owner); 6112 6113 if (config.unique_orphan_sections || unique_section_p (s, NULL)) 6114 constraint = SPECIAL; 6115 6116 os = ldemul_place_orphan (s, name, constraint); 6117 if (os == NULL) 6118 { 6119 os = lang_output_section_statement_lookup (name, constraint, TRUE); 6120 if (os->addr_tree == NULL 6121 && (bfd_link_relocatable (&link_info) 6122 || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)) 6123 os->addr_tree = exp_intop (0); 6124 lang_add_section (&os->children, s, NULL, os); 6125 } 6126 6127 if (config.orphan_handling == orphan_handling_warn) 6128 einfo ("%P: warning: orphan section `%A' from `%B' being " 6129 "placed in section `%s'.\n", 6130 s, s->owner, os->name); 6131 } 6132 } 6133 6134 /* Run through the input files and ensure that every input section has 6135 somewhere to go. If one is found without a destination then create 6136 an input request and place it into the statement tree. */ 6137 6138 static void 6139 lang_place_orphans (void) 6140 { 6141 LANG_FOR_EACH_INPUT_STATEMENT (file) 6142 { 6143 asection *s; 6144 6145 for (s = file->the_bfd->sections; s != NULL; s = s->next) 6146 { 6147 if (s->output_section == NULL) 6148 { 6149 /* This section of the file is not attached, root 6150 around for a sensible place for it to go. */ 6151 6152 if (file->flags.just_syms) 6153 bfd_link_just_syms (file->the_bfd, s, &link_info); 6154 else if ((s->flags & SEC_EXCLUDE) != 0) 6155 s->output_section = bfd_abs_section_ptr; 6156 else if (strcmp (s->name, "COMMON") == 0) 6157 { 6158 /* This is a lonely common section which must have 6159 come from an archive. We attach to the section 6160 with the wildcard. */ 6161 if (!bfd_link_relocatable (&link_info) 6162 || command_line.force_common_definition) 6163 { 6164 if (default_common_section == NULL) 6165 default_common_section 6166 = lang_output_section_statement_lookup (".bss", 0, 6167 TRUE); 6168 lang_add_section (&default_common_section->children, s, 6169 NULL, default_common_section); 6170 } 6171 } 6172 else 6173 ldlang_place_orphan (s); 6174 } 6175 } 6176 } 6177 } 6178 6179 void 6180 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert) 6181 { 6182 flagword *ptr_flags; 6183 6184 ptr_flags = invert ? &ptr->not_flags : &ptr->flags; 6185 6186 while (*flags) 6187 { 6188 switch (*flags) 6189 { 6190 /* PR 17900: An exclamation mark in the attributes reverses 6191 the sense of any of the attributes that follow. */ 6192 case '!': 6193 invert = !invert; 6194 ptr_flags = invert ? &ptr->not_flags : &ptr->flags; 6195 break; 6196 6197 case 'A': case 'a': 6198 *ptr_flags |= SEC_ALLOC; 6199 break; 6200 6201 case 'R': case 'r': 6202 *ptr_flags |= SEC_READONLY; 6203 break; 6204 6205 case 'W': case 'w': 6206 *ptr_flags |= SEC_DATA; 6207 break; 6208 6209 case 'X': case 'x': 6210 *ptr_flags |= SEC_CODE; 6211 break; 6212 6213 case 'L': case 'l': 6214 case 'I': case 'i': 6215 *ptr_flags |= SEC_LOAD; 6216 break; 6217 6218 default: 6219 einfo (_("%P%F: invalid character %c (%d) in flags\n"), 6220 *flags, *flags); 6221 break; 6222 } 6223 flags++; 6224 } 6225 } 6226 6227 /* Call a function on each input file. This function will be called 6228 on an archive, but not on the elements. */ 6229 6230 void 6231 lang_for_each_input_file (void (*func) (lang_input_statement_type *)) 6232 { 6233 lang_input_statement_type *f; 6234 6235 for (f = (lang_input_statement_type *) input_file_chain.head; 6236 f != NULL; 6237 f = (lang_input_statement_type *) f->next_real_file) 6238 func (f); 6239 } 6240 6241 /* Call a function on each file. The function will be called on all 6242 the elements of an archive which are included in the link, but will 6243 not be called on the archive file itself. */ 6244 6245 void 6246 lang_for_each_file (void (*func) (lang_input_statement_type *)) 6247 { 6248 LANG_FOR_EACH_INPUT_STATEMENT (f) 6249 { 6250 func (f); 6251 } 6252 } 6253 6254 void 6255 ldlang_add_file (lang_input_statement_type *entry) 6256 { 6257 lang_statement_append (&file_chain, 6258 (lang_statement_union_type *) entry, 6259 &entry->next); 6260 6261 /* The BFD linker needs to have a list of all input BFDs involved in 6262 a link. */ 6263 ASSERT (entry->the_bfd->link.next == NULL); 6264 ASSERT (entry->the_bfd != link_info.output_bfd); 6265 6266 *link_info.input_bfds_tail = entry->the_bfd; 6267 link_info.input_bfds_tail = &entry->the_bfd->link.next; 6268 entry->the_bfd->usrdata = entry; 6269 bfd_set_gp_size (entry->the_bfd, g_switch_value); 6270 6271 /* Look through the sections and check for any which should not be 6272 included in the link. We need to do this now, so that we can 6273 notice when the backend linker tries to report multiple 6274 definition errors for symbols which are in sections we aren't 6275 going to link. FIXME: It might be better to entirely ignore 6276 symbols which are defined in sections which are going to be 6277 discarded. This would require modifying the backend linker for 6278 each backend which might set the SEC_LINK_ONCE flag. If we do 6279 this, we should probably handle SEC_EXCLUDE in the same way. */ 6280 6281 bfd_map_over_sections (entry->the_bfd, section_already_linked, entry); 6282 } 6283 6284 void 6285 lang_add_output (const char *name, int from_script) 6286 { 6287 /* Make -o on command line override OUTPUT in script. */ 6288 if (!had_output_filename || !from_script) 6289 { 6290 output_filename = name; 6291 had_output_filename = TRUE; 6292 } 6293 } 6294 6295 static lang_output_section_statement_type *current_section; 6296 6297 static int 6298 topower (int x) 6299 { 6300 unsigned int i = 1; 6301 int l; 6302 6303 if (x < 0) 6304 return -1; 6305 6306 for (l = 0; l < 32; l++) 6307 { 6308 if (i >= (unsigned int) x) 6309 return l; 6310 i <<= 1; 6311 } 6312 6313 return 0; 6314 } 6315 6316 lang_output_section_statement_type * 6317 lang_enter_output_section_statement (const char *output_section_statement_name, 6318 etree_type *address_exp, 6319 enum section_type sectype, 6320 etree_type *align, 6321 etree_type *subalign, 6322 etree_type *ebase, 6323 int constraint, 6324 int align_with_input) 6325 { 6326 lang_output_section_statement_type *os; 6327 6328 os = lang_output_section_statement_lookup (output_section_statement_name, 6329 constraint, TRUE); 6330 current_section = os; 6331 6332 if (os->addr_tree == NULL) 6333 { 6334 os->addr_tree = address_exp; 6335 } 6336 os->sectype = sectype; 6337 if (sectype != noload_section) 6338 os->flags = SEC_NO_FLAGS; 6339 else 6340 os->flags = SEC_NEVER_LOAD; 6341 os->block_value = 1; 6342 6343 /* Make next things chain into subchain of this. */ 6344 push_stat_ptr (&os->children); 6345 6346 os->align_lma_with_input = align_with_input == ALIGN_WITH_INPUT; 6347 if (os->align_lma_with_input && align != NULL) 6348 einfo (_("%F%P:%S: error: align with input and explicit align specified\n"), 6349 NULL); 6350 6351 os->subsection_alignment = 6352 topower (exp_get_value_int (subalign, -1, "subsection alignment")); 6353 os->section_alignment = 6354 topower (exp_get_value_int (align, -1, "section alignment")); 6355 6356 os->load_base = ebase; 6357 return os; 6358 } 6359 6360 void 6361 lang_final (void) 6362 { 6363 lang_output_statement_type *new_stmt; 6364 6365 new_stmt = new_stat (lang_output_statement, stat_ptr); 6366 new_stmt->name = output_filename; 6367 } 6368 6369 /* Reset the current counters in the regions. */ 6370 6371 void 6372 lang_reset_memory_regions (void) 6373 { 6374 lang_memory_region_type *p = lang_memory_region_list; 6375 asection *o; 6376 lang_output_section_statement_type *os; 6377 6378 for (p = lang_memory_region_list; p != NULL; p = p->next) 6379 { 6380 p->current = p->origin; 6381 p->last_os = NULL; 6382 } 6383 6384 for (os = &lang_output_section_statement.head->output_section_statement; 6385 os != NULL; 6386 os = os->next) 6387 { 6388 os->processed_vma = FALSE; 6389 os->processed_lma = FALSE; 6390 } 6391 6392 for (o = link_info.output_bfd->sections; o != NULL; o = o->next) 6393 { 6394 /* Save the last size for possible use by bfd_relax_section. */ 6395 o->rawsize = o->size; 6396 o->size = 0; 6397 } 6398 } 6399 6400 /* Worker for lang_gc_sections_1. */ 6401 6402 static void 6403 gc_section_callback (lang_wild_statement_type *ptr, 6404 struct wildcard_list *sec ATTRIBUTE_UNUSED, 6405 asection *section, 6406 struct flag_info *sflag_info ATTRIBUTE_UNUSED, 6407 lang_input_statement_type *file ATTRIBUTE_UNUSED, 6408 void *data ATTRIBUTE_UNUSED) 6409 { 6410 /* If the wild pattern was marked KEEP, the member sections 6411 should be as well. */ 6412 if (ptr->keep_sections) 6413 section->flags |= SEC_KEEP; 6414 } 6415 6416 /* Iterate over sections marking them against GC. */ 6417 6418 static void 6419 lang_gc_sections_1 (lang_statement_union_type *s) 6420 { 6421 for (; s != NULL; s = s->header.next) 6422 { 6423 switch (s->header.type) 6424 { 6425 case lang_wild_statement_enum: 6426 walk_wild (&s->wild_statement, gc_section_callback, NULL); 6427 break; 6428 case lang_constructors_statement_enum: 6429 lang_gc_sections_1 (constructor_list.head); 6430 break; 6431 case lang_output_section_statement_enum: 6432 lang_gc_sections_1 (s->output_section_statement.children.head); 6433 break; 6434 case lang_group_statement_enum: 6435 lang_gc_sections_1 (s->group_statement.children.head); 6436 break; 6437 default: 6438 break; 6439 } 6440 } 6441 } 6442 6443 static void 6444 lang_gc_sections (void) 6445 { 6446 /* Keep all sections so marked in the link script. */ 6447 lang_gc_sections_1 (statement_list.head); 6448 6449 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in 6450 the special case of debug info. (See bfd/stabs.c) 6451 Twiddle the flag here, to simplify later linker code. */ 6452 if (bfd_link_relocatable (&link_info)) 6453 { 6454 LANG_FOR_EACH_INPUT_STATEMENT (f) 6455 { 6456 asection *sec; 6457 #ifdef ENABLE_PLUGINS 6458 if (f->flags.claimed) 6459 continue; 6460 #endif 6461 for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next) 6462 if ((sec->flags & SEC_DEBUGGING) == 0) 6463 sec->flags &= ~SEC_EXCLUDE; 6464 } 6465 } 6466 6467 if (link_info.gc_sections) 6468 bfd_gc_sections (link_info.output_bfd, &link_info); 6469 } 6470 6471 /* Worker for lang_find_relro_sections_1. */ 6472 6473 static void 6474 find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED, 6475 struct wildcard_list *sec ATTRIBUTE_UNUSED, 6476 asection *section, 6477 struct flag_info *sflag_info ATTRIBUTE_UNUSED, 6478 lang_input_statement_type *file ATTRIBUTE_UNUSED, 6479 void *data) 6480 { 6481 /* Discarded, excluded and ignored sections effectively have zero 6482 size. */ 6483 if (section->output_section != NULL 6484 && section->output_section->owner == link_info.output_bfd 6485 && (section->output_section->flags & SEC_EXCLUDE) == 0 6486 && !IGNORE_SECTION (section) 6487 && section->size != 0) 6488 { 6489 bfd_boolean *has_relro_section = (bfd_boolean *) data; 6490 *has_relro_section = TRUE; 6491 } 6492 } 6493 6494 /* Iterate over sections for relro sections. */ 6495 6496 static void 6497 lang_find_relro_sections_1 (lang_statement_union_type *s, 6498 bfd_boolean *has_relro_section) 6499 { 6500 if (*has_relro_section) 6501 return; 6502 6503 for (; s != NULL; s = s->header.next) 6504 { 6505 if (s == expld.dataseg.relro_end_stat) 6506 break; 6507 6508 switch (s->header.type) 6509 { 6510 case lang_wild_statement_enum: 6511 walk_wild (&s->wild_statement, 6512 find_relro_section_callback, 6513 has_relro_section); 6514 break; 6515 case lang_constructors_statement_enum: 6516 lang_find_relro_sections_1 (constructor_list.head, 6517 has_relro_section); 6518 break; 6519 case lang_output_section_statement_enum: 6520 lang_find_relro_sections_1 (s->output_section_statement.children.head, 6521 has_relro_section); 6522 break; 6523 case lang_group_statement_enum: 6524 lang_find_relro_sections_1 (s->group_statement.children.head, 6525 has_relro_section); 6526 break; 6527 default: 6528 break; 6529 } 6530 } 6531 } 6532 6533 static void 6534 lang_find_relro_sections (void) 6535 { 6536 bfd_boolean has_relro_section = FALSE; 6537 6538 /* Check all sections in the link script. */ 6539 6540 lang_find_relro_sections_1 (expld.dataseg.relro_start_stat, 6541 &has_relro_section); 6542 6543 if (!has_relro_section) 6544 link_info.relro = FALSE; 6545 } 6546 6547 /* Relax all sections until bfd_relax_section gives up. */ 6548 6549 void 6550 lang_relax_sections (bfd_boolean need_layout) 6551 { 6552 if (RELAXATION_ENABLED) 6553 { 6554 /* We may need more than one relaxation pass. */ 6555 int i = link_info.relax_pass; 6556 6557 /* The backend can use it to determine the current pass. */ 6558 link_info.relax_pass = 0; 6559 6560 while (i--) 6561 { 6562 /* Keep relaxing until bfd_relax_section gives up. */ 6563 bfd_boolean relax_again; 6564 6565 link_info.relax_trip = -1; 6566 do 6567 { 6568 link_info.relax_trip++; 6569 6570 /* Note: pe-dll.c does something like this also. If you find 6571 you need to change this code, you probably need to change 6572 pe-dll.c also. DJ */ 6573 6574 /* Do all the assignments with our current guesses as to 6575 section sizes. */ 6576 lang_do_assignments (lang_assigning_phase_enum); 6577 6578 /* We must do this after lang_do_assignments, because it uses 6579 size. */ 6580 lang_reset_memory_regions (); 6581 6582 /* Perform another relax pass - this time we know where the 6583 globals are, so can make a better guess. */ 6584 relax_again = FALSE; 6585 lang_size_sections (&relax_again, FALSE); 6586 } 6587 while (relax_again); 6588 6589 link_info.relax_pass++; 6590 } 6591 need_layout = TRUE; 6592 } 6593 6594 if (need_layout) 6595 { 6596 /* Final extra sizing to report errors. */ 6597 lang_do_assignments (lang_assigning_phase_enum); 6598 lang_reset_memory_regions (); 6599 lang_size_sections (NULL, TRUE); 6600 } 6601 } 6602 6603 #ifdef ENABLE_PLUGINS 6604 /* Find the insert point for the plugin's replacement files. We 6605 place them after the first claimed real object file, or if the 6606 first claimed object is an archive member, after the last real 6607 object file immediately preceding the archive. In the event 6608 no objects have been claimed at all, we return the first dummy 6609 object file on the list as the insert point; that works, but 6610 the callee must be careful when relinking the file_chain as it 6611 is not actually on that chain, only the statement_list and the 6612 input_file list; in that case, the replacement files must be 6613 inserted at the head of the file_chain. */ 6614 6615 static lang_input_statement_type * 6616 find_replacements_insert_point (void) 6617 { 6618 lang_input_statement_type *claim1, *lastobject; 6619 lastobject = &input_file_chain.head->input_statement; 6620 for (claim1 = &file_chain.head->input_statement; 6621 claim1 != NULL; 6622 claim1 = &claim1->next->input_statement) 6623 { 6624 if (claim1->flags.claimed) 6625 return claim1->flags.claim_archive ? lastobject : claim1; 6626 /* Update lastobject if this is a real object file. */ 6627 if (claim1->the_bfd != NULL && claim1->the_bfd->my_archive == NULL) 6628 lastobject = claim1; 6629 } 6630 /* No files were claimed by the plugin. Choose the last object 6631 file found on the list (maybe the first, dummy entry) as the 6632 insert point. */ 6633 return lastobject; 6634 } 6635 6636 /* Insert SRCLIST into DESTLIST after given element by chaining 6637 on FIELD as the next-pointer. (Counterintuitively does not need 6638 a pointer to the actual after-node itself, just its chain field.) */ 6639 6640 static void 6641 lang_list_insert_after (lang_statement_list_type *destlist, 6642 lang_statement_list_type *srclist, 6643 lang_statement_union_type **field) 6644 { 6645 *(srclist->tail) = *field; 6646 *field = srclist->head; 6647 if (destlist->tail == field) 6648 destlist->tail = srclist->tail; 6649 } 6650 6651 /* Detach new nodes added to DESTLIST since the time ORIGLIST 6652 was taken as a copy of it and leave them in ORIGLIST. */ 6653 6654 static void 6655 lang_list_remove_tail (lang_statement_list_type *destlist, 6656 lang_statement_list_type *origlist) 6657 { 6658 union lang_statement_union **savetail; 6659 /* Check that ORIGLIST really is an earlier state of DESTLIST. */ 6660 ASSERT (origlist->head == destlist->head); 6661 savetail = origlist->tail; 6662 origlist->head = *(savetail); 6663 origlist->tail = destlist->tail; 6664 destlist->tail = savetail; 6665 *savetail = NULL; 6666 } 6667 #endif /* ENABLE_PLUGINS */ 6668 6669 /* Add NAME to the list of garbage collection entry points. */ 6670 6671 void 6672 lang_add_gc_name (const char *name) 6673 { 6674 struct bfd_sym_chain *sym; 6675 6676 if (name == NULL) 6677 return; 6678 6679 sym = (struct bfd_sym_chain *) stat_alloc (sizeof (*sym)); 6680 6681 sym->next = link_info.gc_sym_list; 6682 sym->name = name; 6683 link_info.gc_sym_list = sym; 6684 } 6685 6686 /* Check relocations. */ 6687 6688 static void 6689 lang_check_relocs (void) 6690 { 6691 if (link_info.check_relocs_after_open_input) 6692 { 6693 bfd *abfd; 6694 6695 for (abfd = link_info.input_bfds; 6696 abfd != (bfd *) NULL; abfd = abfd->link.next) 6697 if (!bfd_link_check_relocs (abfd, &link_info)) 6698 { 6699 /* No object output, fail return. */ 6700 config.make_executable = FALSE; 6701 /* Note: we do not abort the loop, but rather 6702 continue the scan in case there are other 6703 bad relocations to report. */ 6704 } 6705 } 6706 } 6707 6708 void 6709 lang_process (void) 6710 { 6711 /* Finalize dynamic list. */ 6712 if (link_info.dynamic_list) 6713 lang_finalize_version_expr_head (&link_info.dynamic_list->head); 6714 6715 current_target = default_target; 6716 6717 /* Open the output file. */ 6718 lang_for_each_statement (ldlang_open_output); 6719 init_opb (); 6720 6721 ldemul_create_output_section_statements (); 6722 6723 /* Add to the hash table all undefineds on the command line. */ 6724 lang_place_undefineds (); 6725 6726 if (!bfd_section_already_linked_table_init ()) 6727 einfo (_("%P%F: Failed to create hash table\n")); 6728 6729 /* Create a bfd for each input file. */ 6730 current_target = default_target; 6731 open_input_bfds (statement_list.head, OPEN_BFD_NORMAL); 6732 6733 #ifdef ENABLE_PLUGINS 6734 if (link_info.lto_plugin_active) 6735 { 6736 lang_statement_list_type added; 6737 lang_statement_list_type files, inputfiles; 6738 6739 /* Now all files are read, let the plugin(s) decide if there 6740 are any more to be added to the link before we call the 6741 emulation's after_open hook. We create a private list of 6742 input statements for this purpose, which we will eventually 6743 insert into the global statment list after the first claimed 6744 file. */ 6745 added = *stat_ptr; 6746 /* We need to manipulate all three chains in synchrony. */ 6747 files = file_chain; 6748 inputfiles = input_file_chain; 6749 if (plugin_call_all_symbols_read ()) 6750 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"), 6751 plugin_error_plugin ()); 6752 /* Open any newly added files, updating the file chains. */ 6753 open_input_bfds (*added.tail, OPEN_BFD_NORMAL); 6754 /* Restore the global list pointer now they have all been added. */ 6755 lang_list_remove_tail (stat_ptr, &added); 6756 /* And detach the fresh ends of the file lists. */ 6757 lang_list_remove_tail (&file_chain, &files); 6758 lang_list_remove_tail (&input_file_chain, &inputfiles); 6759 /* Were any new files added? */ 6760 if (added.head != NULL) 6761 { 6762 /* If so, we will insert them into the statement list immediately 6763 after the first input file that was claimed by the plugin. */ 6764 plugin_insert = find_replacements_insert_point (); 6765 /* If a plugin adds input files without having claimed any, we 6766 don't really have a good idea where to place them. Just putting 6767 them at the start or end of the list is liable to leave them 6768 outside the crtbegin...crtend range. */ 6769 ASSERT (plugin_insert != NULL); 6770 /* Splice the new statement list into the old one. */ 6771 lang_list_insert_after (stat_ptr, &added, 6772 &plugin_insert->header.next); 6773 /* Likewise for the file chains. */ 6774 lang_list_insert_after (&input_file_chain, &inputfiles, 6775 &plugin_insert->next_real_file); 6776 /* We must be careful when relinking file_chain; we may need to 6777 insert the new files at the head of the list if the insert 6778 point chosen is the dummy first input file. */ 6779 if (plugin_insert->filename) 6780 lang_list_insert_after (&file_chain, &files, &plugin_insert->next); 6781 else 6782 lang_list_insert_after (&file_chain, &files, &file_chain.head); 6783 6784 /* Rescan archives in case new undefined symbols have appeared. */ 6785 open_input_bfds (statement_list.head, OPEN_BFD_RESCAN); 6786 } 6787 } 6788 #endif /* ENABLE_PLUGINS */ 6789 6790 /* Make sure that nobody has tried to add a symbol to this list 6791 before now. */ 6792 ASSERT (link_info.gc_sym_list == NULL); 6793 6794 link_info.gc_sym_list = &entry_symbol; 6795 6796 if (entry_symbol.name == NULL) 6797 { 6798 link_info.gc_sym_list = ldlang_undef_chain_list_head; 6799 6800 /* entry_symbol is normally initialied by a ENTRY definition in the 6801 linker script or the -e command line option. But if neither of 6802 these have been used, the target specific backend may still have 6803 provided an entry symbol via a call to lang_default_entry(). 6804 Unfortunately this value will not be processed until lang_end() 6805 is called, long after this function has finished. So detect this 6806 case here and add the target's entry symbol to the list of starting 6807 points for garbage collection resolution. */ 6808 lang_add_gc_name (entry_symbol_default); 6809 } 6810 6811 lang_add_gc_name (link_info.init_function); 6812 lang_add_gc_name (link_info.fini_function); 6813 6814 ldemul_after_open (); 6815 if (config.map_file != NULL) 6816 lang_print_asneeded (); 6817 6818 bfd_section_already_linked_table_free (); 6819 6820 /* Make sure that we're not mixing architectures. We call this 6821 after all the input files have been opened, but before we do any 6822 other processing, so that any operations merge_private_bfd_data 6823 does on the output file will be known during the rest of the 6824 link. */ 6825 lang_check (); 6826 6827 /* Handle .exports instead of a version script if we're told to do so. */ 6828 if (command_line.version_exports_section) 6829 lang_do_version_exports_section (); 6830 6831 /* Build all sets based on the information gathered from the input 6832 files. */ 6833 ldctor_build_sets (); 6834 6835 /* PR 13683: We must rerun the assignments prior to running garbage 6836 collection in order to make sure that all symbol aliases are resolved. */ 6837 lang_do_assignments (lang_mark_phase_enum); 6838 6839 lang_do_memory_regions(); 6840 expld.phase = lang_first_phase_enum; 6841 6842 /* Size up the common data. */ 6843 lang_common (); 6844 6845 /* Remove unreferenced sections if asked to. */ 6846 lang_gc_sections (); 6847 6848 /* Check relocations. */ 6849 lang_check_relocs (); 6850 6851 /* Update wild statements. */ 6852 update_wild_statements (statement_list.head); 6853 6854 /* Run through the contours of the script and attach input sections 6855 to the correct output sections. */ 6856 lang_statement_iteration++; 6857 map_input_to_output_sections (statement_list.head, NULL, NULL); 6858 6859 process_insert_statements (); 6860 6861 /* Find any sections not attached explicitly and handle them. */ 6862 lang_place_orphans (); 6863 6864 if (!bfd_link_relocatable (&link_info)) 6865 { 6866 asection *found; 6867 6868 /* Merge SEC_MERGE sections. This has to be done after GC of 6869 sections, so that GCed sections are not merged, but before 6870 assigning dynamic symbols, since removing whole input sections 6871 is hard then. */ 6872 bfd_merge_sections (link_info.output_bfd, &link_info); 6873 6874 /* Look for a text section and set the readonly attribute in it. */ 6875 found = bfd_get_section_by_name (link_info.output_bfd, ".text"); 6876 6877 if (found != NULL) 6878 { 6879 if (config.text_read_only) 6880 found->flags |= SEC_READONLY; 6881 else 6882 found->flags &= ~SEC_READONLY; 6883 } 6884 } 6885 6886 /* Do anything special before sizing sections. This is where ELF 6887 and other back-ends size dynamic sections. */ 6888 ldemul_before_allocation (); 6889 6890 /* We must record the program headers before we try to fix the 6891 section positions, since they will affect SIZEOF_HEADERS. */ 6892 lang_record_phdrs (); 6893 6894 /* Check relro sections. */ 6895 if (link_info.relro && !bfd_link_relocatable (&link_info)) 6896 lang_find_relro_sections (); 6897 6898 /* Size up the sections. */ 6899 lang_size_sections (NULL, !RELAXATION_ENABLED); 6900 6901 /* See if anything special should be done now we know how big 6902 everything is. This is where relaxation is done. */ 6903 ldemul_after_allocation (); 6904 6905 /* Fix any .startof. or .sizeof. symbols. */ 6906 lang_set_startof (); 6907 6908 /* Do all the assignments, now that we know the final resting places 6909 of all the symbols. */ 6910 lang_do_assignments (lang_final_phase_enum); 6911 6912 ldemul_finish (); 6913 6914 /* Make sure that the section addresses make sense. */ 6915 if (command_line.check_section_addresses) 6916 lang_check_section_addresses (); 6917 6918 /* Check any required symbols are known. */ 6919 ldlang_check_require_defined_symbols (); 6920 6921 lang_end (); 6922 } 6923 6924 /* EXPORTED TO YACC */ 6925 6926 void 6927 lang_add_wild (struct wildcard_spec *filespec, 6928 struct wildcard_list *section_list, 6929 bfd_boolean keep_sections) 6930 { 6931 struct wildcard_list *curr, *next; 6932 lang_wild_statement_type *new_stmt; 6933 6934 /* Reverse the list as the parser puts it back to front. */ 6935 for (curr = section_list, section_list = NULL; 6936 curr != NULL; 6937 section_list = curr, curr = next) 6938 { 6939 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0) 6940 placed_commons = TRUE; 6941 6942 next = curr->next; 6943 curr->next = section_list; 6944 } 6945 6946 if (filespec != NULL && filespec->name != NULL) 6947 { 6948 if (strcmp (filespec->name, "*") == 0) 6949 filespec->name = NULL; 6950 else if (!wildcardp (filespec->name)) 6951 lang_has_input_file = TRUE; 6952 } 6953 6954 new_stmt = new_stat (lang_wild_statement, stat_ptr); 6955 new_stmt->filename = NULL; 6956 new_stmt->filenames_sorted = FALSE; 6957 new_stmt->section_flag_list = NULL; 6958 if (filespec != NULL) 6959 { 6960 new_stmt->filename = filespec->name; 6961 new_stmt->filenames_sorted = filespec->sorted == by_name; 6962 new_stmt->section_flag_list = filespec->section_flag_list; 6963 } 6964 new_stmt->section_list = section_list; 6965 new_stmt->keep_sections = keep_sections; 6966 lang_list_init (&new_stmt->children); 6967 analyze_walk_wild_section_handler (new_stmt); 6968 } 6969 6970 void 6971 lang_section_start (const char *name, etree_type *address, 6972 const segment_type *segment) 6973 { 6974 lang_address_statement_type *ad; 6975 6976 ad = new_stat (lang_address_statement, stat_ptr); 6977 ad->section_name = name; 6978 ad->address = address; 6979 ad->segment = segment; 6980 } 6981 6982 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called 6983 because of a -e argument on the command line, or zero if this is 6984 called by ENTRY in a linker script. Command line arguments take 6985 precedence. */ 6986 6987 void 6988 lang_add_entry (const char *name, bfd_boolean cmdline) 6989 { 6990 if (entry_symbol.name == NULL 6991 || cmdline 6992 || !entry_from_cmdline) 6993 { 6994 entry_symbol.name = name; 6995 entry_from_cmdline = cmdline; 6996 } 6997 } 6998 6999 /* Set the default start symbol to NAME. .em files should use this, 7000 not lang_add_entry, to override the use of "start" if neither the 7001 linker script nor the command line specifies an entry point. NAME 7002 must be permanently allocated. */ 7003 void 7004 lang_default_entry (const char *name) 7005 { 7006 entry_symbol_default = name; 7007 } 7008 7009 void 7010 lang_add_target (const char *name) 7011 { 7012 lang_target_statement_type *new_stmt; 7013 7014 new_stmt = new_stat (lang_target_statement, stat_ptr); 7015 new_stmt->target = name; 7016 } 7017 7018 void 7019 lang_add_map (const char *name) 7020 { 7021 while (*name) 7022 { 7023 switch (*name) 7024 { 7025 case 'F': 7026 map_option_f = TRUE; 7027 break; 7028 } 7029 name++; 7030 } 7031 } 7032 7033 void 7034 lang_add_fill (fill_type *fill) 7035 { 7036 lang_fill_statement_type *new_stmt; 7037 7038 new_stmt = new_stat (lang_fill_statement, stat_ptr); 7039 new_stmt->fill = fill; 7040 } 7041 7042 void 7043 lang_add_data (int type, union etree_union *exp) 7044 { 7045 lang_data_statement_type *new_stmt; 7046 7047 new_stmt = new_stat (lang_data_statement, stat_ptr); 7048 new_stmt->exp = exp; 7049 new_stmt->type = type; 7050 } 7051 7052 /* Create a new reloc statement. RELOC is the BFD relocation type to 7053 generate. HOWTO is the corresponding howto structure (we could 7054 look this up, but the caller has already done so). SECTION is the 7055 section to generate a reloc against, or NAME is the name of the 7056 symbol to generate a reloc against. Exactly one of SECTION and 7057 NAME must be NULL. ADDEND is an expression for the addend. */ 7058 7059 void 7060 lang_add_reloc (bfd_reloc_code_real_type reloc, 7061 reloc_howto_type *howto, 7062 asection *section, 7063 const char *name, 7064 union etree_union *addend) 7065 { 7066 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr); 7067 7068 p->reloc = reloc; 7069 p->howto = howto; 7070 p->section = section; 7071 p->name = name; 7072 p->addend_exp = addend; 7073 7074 p->addend_value = 0; 7075 p->output_section = NULL; 7076 p->output_offset = 0; 7077 } 7078 7079 lang_assignment_statement_type * 7080 lang_add_assignment (etree_type *exp) 7081 { 7082 lang_assignment_statement_type *new_stmt; 7083 7084 new_stmt = new_stat (lang_assignment_statement, stat_ptr); 7085 new_stmt->exp = exp; 7086 return new_stmt; 7087 } 7088 7089 void 7090 lang_add_attribute (enum statement_enum attribute) 7091 { 7092 new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr); 7093 } 7094 7095 void 7096 lang_startup (const char *name) 7097 { 7098 if (first_file->filename != NULL) 7099 { 7100 einfo (_("%P%F: multiple STARTUP files\n")); 7101 } 7102 first_file->filename = name; 7103 first_file->local_sym_name = name; 7104 first_file->flags.real = TRUE; 7105 } 7106 7107 void 7108 lang_float (bfd_boolean maybe) 7109 { 7110 lang_float_flag = maybe; 7111 } 7112 7113 7114 /* Work out the load- and run-time regions from a script statement, and 7115 store them in *LMA_REGION and *REGION respectively. 7116 7117 MEMSPEC is the name of the run-time region, or the value of 7118 DEFAULT_MEMORY_REGION if the statement didn't specify one. 7119 LMA_MEMSPEC is the name of the load-time region, or null if the 7120 statement didn't specify one.HAVE_LMA_P is TRUE if the statement 7121 had an explicit load address. 7122 7123 It is an error to specify both a load region and a load address. */ 7124 7125 static void 7126 lang_get_regions (lang_memory_region_type **region, 7127 lang_memory_region_type **lma_region, 7128 const char *memspec, 7129 const char *lma_memspec, 7130 bfd_boolean have_lma, 7131 bfd_boolean have_vma) 7132 { 7133 *lma_region = lang_memory_region_lookup (lma_memspec, FALSE); 7134 7135 /* If no runtime region or VMA has been specified, but the load region 7136 has been specified, then use the load region for the runtime region 7137 as well. */ 7138 if (lma_memspec != NULL 7139 && !have_vma 7140 && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0) 7141 *region = *lma_region; 7142 else 7143 *region = lang_memory_region_lookup (memspec, FALSE); 7144 7145 if (have_lma && lma_memspec != 0) 7146 einfo (_("%X%P:%S: section has both a load address and a load region\n"), 7147 NULL); 7148 } 7149 7150 void 7151 lang_leave_output_section_statement (fill_type *fill, const char *memspec, 7152 lang_output_section_phdr_list *phdrs, 7153 const char *lma_memspec) 7154 { 7155 lang_get_regions (¤t_section->region, 7156 ¤t_section->lma_region, 7157 memspec, lma_memspec, 7158 current_section->load_base != NULL, 7159 current_section->addr_tree != NULL); 7160 7161 /* If this section has no load region or base, but uses the same 7162 region as the previous section, then propagate the previous 7163 section's load region. */ 7164 7165 if (current_section->lma_region == NULL 7166 && current_section->load_base == NULL 7167 && current_section->addr_tree == NULL 7168 && current_section->region == current_section->prev->region) 7169 current_section->lma_region = current_section->prev->lma_region; 7170 7171 current_section->fill = fill; 7172 current_section->phdrs = phdrs; 7173 pop_stat_ptr (); 7174 } 7175 7176 /* Create an absolute symbol with the given name with the value of the 7177 address of first byte of the section named. 7178 7179 If the symbol already exists, then do nothing. */ 7180 7181 void 7182 lang_abs_symbol_at_beginning_of (const char *secname, const char *name) 7183 { 7184 struct bfd_link_hash_entry *h; 7185 7186 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE); 7187 if (h == NULL) 7188 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); 7189 7190 if (h->type == bfd_link_hash_new 7191 || h->type == bfd_link_hash_undefined) 7192 { 7193 asection *sec; 7194 7195 h->type = bfd_link_hash_defined; 7196 7197 sec = bfd_get_section_by_name (link_info.output_bfd, secname); 7198 if (sec == NULL) 7199 h->u.def.value = 0; 7200 else 7201 h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec); 7202 7203 h->u.def.section = bfd_abs_section_ptr; 7204 } 7205 } 7206 7207 /* Create an absolute symbol with the given name with the value of the 7208 address of the first byte after the end of the section named. 7209 7210 If the symbol already exists, then do nothing. */ 7211 7212 void 7213 lang_abs_symbol_at_end_of (const char *secname, const char *name) 7214 { 7215 struct bfd_link_hash_entry *h; 7216 7217 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE); 7218 if (h == NULL) 7219 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); 7220 7221 if (h->type == bfd_link_hash_new 7222 || h->type == bfd_link_hash_undefined) 7223 { 7224 asection *sec; 7225 7226 h->type = bfd_link_hash_defined; 7227 7228 sec = bfd_get_section_by_name (link_info.output_bfd, secname); 7229 if (sec == NULL) 7230 h->u.def.value = 0; 7231 else 7232 h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec) 7233 + TO_ADDR (sec->size)); 7234 7235 h->u.def.section = bfd_abs_section_ptr; 7236 } 7237 } 7238 7239 void 7240 lang_statement_append (lang_statement_list_type *list, 7241 lang_statement_union_type *element, 7242 lang_statement_union_type **field) 7243 { 7244 *(list->tail) = element; 7245 list->tail = field; 7246 } 7247 7248 /* Set the output format type. -oformat overrides scripts. */ 7249 7250 void 7251 lang_add_output_format (const char *format, 7252 const char *big, 7253 const char *little, 7254 int from_script) 7255 { 7256 if (output_target == NULL || !from_script) 7257 { 7258 if (command_line.endian == ENDIAN_BIG 7259 && big != NULL) 7260 format = big; 7261 else if (command_line.endian == ENDIAN_LITTLE 7262 && little != NULL) 7263 format = little; 7264 7265 output_target = format; 7266 } 7267 } 7268 7269 void 7270 lang_add_insert (const char *where, int is_before) 7271 { 7272 lang_insert_statement_type *new_stmt; 7273 7274 new_stmt = new_stat (lang_insert_statement, stat_ptr); 7275 new_stmt->where = where; 7276 new_stmt->is_before = is_before; 7277 saved_script_handle = previous_script_handle; 7278 } 7279 7280 /* Enter a group. This creates a new lang_group_statement, and sets 7281 stat_ptr to build new statements within the group. */ 7282 7283 void 7284 lang_enter_group (void) 7285 { 7286 lang_group_statement_type *g; 7287 7288 g = new_stat (lang_group_statement, stat_ptr); 7289 lang_list_init (&g->children); 7290 push_stat_ptr (&g->children); 7291 } 7292 7293 /* Leave a group. This just resets stat_ptr to start writing to the 7294 regular list of statements again. Note that this will not work if 7295 groups can occur inside anything else which can adjust stat_ptr, 7296 but currently they can't. */ 7297 7298 void 7299 lang_leave_group (void) 7300 { 7301 pop_stat_ptr (); 7302 } 7303 7304 /* Add a new program header. This is called for each entry in a PHDRS 7305 command in a linker script. */ 7306 7307 void 7308 lang_new_phdr (const char *name, 7309 etree_type *type, 7310 bfd_boolean filehdr, 7311 bfd_boolean phdrs, 7312 etree_type *at, 7313 etree_type *flags) 7314 { 7315 struct lang_phdr *n, **pp; 7316 bfd_boolean hdrs; 7317 7318 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr)); 7319 n->next = NULL; 7320 n->name = name; 7321 n->type = exp_get_value_int (type, 0, "program header type"); 7322 n->filehdr = filehdr; 7323 n->phdrs = phdrs; 7324 n->at = at; 7325 n->flags = flags; 7326 7327 hdrs = n->type == 1 && (phdrs || filehdr); 7328 7329 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next) 7330 if (hdrs 7331 && (*pp)->type == 1 7332 && !((*pp)->filehdr || (*pp)->phdrs)) 7333 { 7334 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported" 7335 " when prior PT_LOAD headers lack them\n"), NULL); 7336 hdrs = FALSE; 7337 } 7338 7339 *pp = n; 7340 } 7341 7342 /* Record the program header information in the output BFD. FIXME: We 7343 should not be calling an ELF specific function here. */ 7344 7345 static void 7346 lang_record_phdrs (void) 7347 { 7348 unsigned int alc; 7349 asection **secs; 7350 lang_output_section_phdr_list *last; 7351 struct lang_phdr *l; 7352 lang_output_section_statement_type *os; 7353 7354 alc = 10; 7355 secs = (asection **) xmalloc (alc * sizeof (asection *)); 7356 last = NULL; 7357 7358 for (l = lang_phdr_list; l != NULL; l = l->next) 7359 { 7360 unsigned int c; 7361 flagword flags; 7362 bfd_vma at; 7363 7364 c = 0; 7365 for (os = &lang_output_section_statement.head->output_section_statement; 7366 os != NULL; 7367 os = os->next) 7368 { 7369 lang_output_section_phdr_list *pl; 7370 7371 if (os->constraint < 0) 7372 continue; 7373 7374 pl = os->phdrs; 7375 if (pl != NULL) 7376 last = pl; 7377 else 7378 { 7379 if (os->sectype == noload_section 7380 || os->bfd_section == NULL 7381 || (os->bfd_section->flags & SEC_ALLOC) == 0) 7382 continue; 7383 7384 /* Don't add orphans to PT_INTERP header. */ 7385 if (l->type == 3) 7386 continue; 7387 7388 if (last == NULL) 7389 { 7390 lang_output_section_statement_type *tmp_os; 7391 7392 /* If we have not run across a section with a program 7393 header assigned to it yet, then scan forwards to find 7394 one. This prevents inconsistencies in the linker's 7395 behaviour when a script has specified just a single 7396 header and there are sections in that script which are 7397 not assigned to it, and which occur before the first 7398 use of that header. See here for more details: 7399 http://sourceware.org/ml/binutils/2007-02/msg00291.html */ 7400 for (tmp_os = os; tmp_os; tmp_os = tmp_os->next) 7401 if (tmp_os->phdrs) 7402 { 7403 last = tmp_os->phdrs; 7404 break; 7405 } 7406 if (last == NULL) 7407 einfo (_("%F%P: no sections assigned to phdrs\n")); 7408 } 7409 pl = last; 7410 } 7411 7412 if (os->bfd_section == NULL) 7413 continue; 7414 7415 for (; pl != NULL; pl = pl->next) 7416 { 7417 if (strcmp (pl->name, l->name) == 0) 7418 { 7419 if (c >= alc) 7420 { 7421 alc *= 2; 7422 secs = (asection **) xrealloc (secs, 7423 alc * sizeof (asection *)); 7424 } 7425 secs[c] = os->bfd_section; 7426 ++c; 7427 pl->used = TRUE; 7428 } 7429 } 7430 } 7431 7432 if (l->flags == NULL) 7433 flags = 0; 7434 else 7435 flags = exp_get_vma (l->flags, 0, "phdr flags"); 7436 7437 if (l->at == NULL) 7438 at = 0; 7439 else 7440 at = exp_get_vma (l->at, 0, "phdr load address"); 7441 7442 if (!bfd_record_phdr (link_info.output_bfd, l->type, 7443 l->flags != NULL, flags, l->at != NULL, 7444 at, l->filehdr, l->phdrs, c, secs)) 7445 einfo (_("%F%P: bfd_record_phdr failed: %E\n")); 7446 } 7447 7448 free (secs); 7449 7450 /* Make sure all the phdr assignments succeeded. */ 7451 for (os = &lang_output_section_statement.head->output_section_statement; 7452 os != NULL; 7453 os = os->next) 7454 { 7455 lang_output_section_phdr_list *pl; 7456 7457 if (os->constraint < 0 7458 || os->bfd_section == NULL) 7459 continue; 7460 7461 for (pl = os->phdrs; 7462 pl != NULL; 7463 pl = pl->next) 7464 if (!pl->used && strcmp (pl->name, "NONE") != 0) 7465 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"), 7466 os->name, pl->name); 7467 } 7468 } 7469 7470 /* Record a list of sections which may not be cross referenced. */ 7471 7472 void 7473 lang_add_nocrossref (lang_nocrossref_type *l) 7474 { 7475 struct lang_nocrossrefs *n; 7476 7477 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n); 7478 n->next = nocrossref_list; 7479 n->list = l; 7480 n->onlyfirst = FALSE; 7481 nocrossref_list = n; 7482 7483 /* Set notice_all so that we get informed about all symbols. */ 7484 link_info.notice_all = TRUE; 7485 } 7486 7487 /* Record a section that cannot be referenced from a list of sections. */ 7488 7489 void 7490 lang_add_nocrossref_to (lang_nocrossref_type *l) 7491 { 7492 lang_add_nocrossref (l); 7493 nocrossref_list->onlyfirst = TRUE; 7494 } 7495 7496 /* Overlay handling. We handle overlays with some static variables. */ 7498 7499 /* The overlay virtual address. */ 7500 static etree_type *overlay_vma; 7501 /* And subsection alignment. */ 7502 static etree_type *overlay_subalign; 7503 7504 /* An expression for the maximum section size seen so far. */ 7505 static etree_type *overlay_max; 7506 7507 /* A list of all the sections in this overlay. */ 7508 7509 struct overlay_list { 7510 struct overlay_list *next; 7511 lang_output_section_statement_type *os; 7512 }; 7513 7514 static struct overlay_list *overlay_list; 7515 7516 /* Start handling an overlay. */ 7517 7518 void 7519 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign) 7520 { 7521 /* The grammar should prevent nested overlays from occurring. */ 7522 ASSERT (overlay_vma == NULL 7523 && overlay_subalign == NULL 7524 && overlay_max == NULL); 7525 7526 overlay_vma = vma_expr; 7527 overlay_subalign = subalign; 7528 } 7529 7530 /* Start a section in an overlay. We handle this by calling 7531 lang_enter_output_section_statement with the correct VMA. 7532 lang_leave_overlay sets up the LMA and memory regions. */ 7533 7534 void 7535 lang_enter_overlay_section (const char *name) 7536 { 7537 struct overlay_list *n; 7538 etree_type *size; 7539 7540 lang_enter_output_section_statement (name, overlay_vma, overlay_section, 7541 0, overlay_subalign, 0, 0, 0); 7542 7543 /* If this is the first section, then base the VMA of future 7544 sections on this one. This will work correctly even if `.' is 7545 used in the addresses. */ 7546 if (overlay_list == NULL) 7547 overlay_vma = exp_nameop (ADDR, name); 7548 7549 /* Remember the section. */ 7550 n = (struct overlay_list *) xmalloc (sizeof *n); 7551 n->os = current_section; 7552 n->next = overlay_list; 7553 overlay_list = n; 7554 7555 size = exp_nameop (SIZEOF, name); 7556 7557 /* Arrange to work out the maximum section end address. */ 7558 if (overlay_max == NULL) 7559 overlay_max = size; 7560 else 7561 overlay_max = exp_binop (MAX_K, overlay_max, size); 7562 } 7563 7564 /* Finish a section in an overlay. There isn't any special to do 7565 here. */ 7566 7567 void 7568 lang_leave_overlay_section (fill_type *fill, 7569 lang_output_section_phdr_list *phdrs) 7570 { 7571 const char *name; 7572 char *clean, *s2; 7573 const char *s1; 7574 char *buf; 7575 7576 name = current_section->name; 7577 7578 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory 7579 region and that no load-time region has been specified. It doesn't 7580 really matter what we say here, since lang_leave_overlay will 7581 override it. */ 7582 lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0); 7583 7584 /* Define the magic symbols. */ 7585 7586 clean = (char *) xmalloc (strlen (name) + 1); 7587 s2 = clean; 7588 for (s1 = name; *s1 != '\0'; s1++) 7589 if (ISALNUM (*s1) || *s1 == '_') 7590 *s2++ = *s1; 7591 *s2 = '\0'; 7592 7593 buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_"); 7594 sprintf (buf, "__load_start_%s", clean); 7595 lang_add_assignment (exp_provide (buf, 7596 exp_nameop (LOADADDR, name), 7597 FALSE)); 7598 7599 buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_"); 7600 sprintf (buf, "__load_stop_%s", clean); 7601 lang_add_assignment (exp_provide (buf, 7602 exp_binop ('+', 7603 exp_nameop (LOADADDR, name), 7604 exp_nameop (SIZEOF, name)), 7605 FALSE)); 7606 7607 free (clean); 7608 } 7609 7610 /* Finish an overlay. If there are any overlay wide settings, this 7611 looks through all the sections in the overlay and sets them. */ 7612 7613 void 7614 lang_leave_overlay (etree_type *lma_expr, 7615 int nocrossrefs, 7616 fill_type *fill, 7617 const char *memspec, 7618 lang_output_section_phdr_list *phdrs, 7619 const char *lma_memspec) 7620 { 7621 lang_memory_region_type *region; 7622 lang_memory_region_type *lma_region; 7623 struct overlay_list *l; 7624 lang_nocrossref_type *nocrossref; 7625 7626 lang_get_regions (®ion, &lma_region, 7627 memspec, lma_memspec, 7628 lma_expr != NULL, FALSE); 7629 7630 nocrossref = NULL; 7631 7632 /* After setting the size of the last section, set '.' to end of the 7633 overlay region. */ 7634 if (overlay_list != NULL) 7635 { 7636 overlay_list->os->update_dot = 1; 7637 overlay_list->os->update_dot_tree 7638 = exp_assign (".", exp_binop ('+', overlay_vma, overlay_max), FALSE); 7639 } 7640 7641 l = overlay_list; 7642 while (l != NULL) 7643 { 7644 struct overlay_list *next; 7645 7646 if (fill != NULL && l->os->fill == NULL) 7647 l->os->fill = fill; 7648 7649 l->os->region = region; 7650 l->os->lma_region = lma_region; 7651 7652 /* The first section has the load address specified in the 7653 OVERLAY statement. The rest are worked out from that. 7654 The base address is not needed (and should be null) if 7655 an LMA region was specified. */ 7656 if (l->next == 0) 7657 { 7658 l->os->load_base = lma_expr; 7659 l->os->sectype = normal_section; 7660 } 7661 if (phdrs != NULL && l->os->phdrs == NULL) 7662 l->os->phdrs = phdrs; 7663 7664 if (nocrossrefs) 7665 { 7666 lang_nocrossref_type *nc; 7667 7668 nc = (lang_nocrossref_type *) xmalloc (sizeof *nc); 7669 nc->name = l->os->name; 7670 nc->next = nocrossref; 7671 nocrossref = nc; 7672 } 7673 7674 next = l->next; 7675 free (l); 7676 l = next; 7677 } 7678 7679 if (nocrossref != NULL) 7680 lang_add_nocrossref (nocrossref); 7681 7682 overlay_vma = NULL; 7683 overlay_list = NULL; 7684 overlay_max = NULL; 7685 } 7686 7687 /* Version handling. This is only useful for ELF. */ 7689 7690 /* If PREV is NULL, return first version pattern matching particular symbol. 7691 If PREV is non-NULL, return first version pattern matching particular 7692 symbol after PREV (previously returned by lang_vers_match). */ 7693 7694 static struct bfd_elf_version_expr * 7695 lang_vers_match (struct bfd_elf_version_expr_head *head, 7696 struct bfd_elf_version_expr *prev, 7697 const char *sym) 7698 { 7699 const char *c_sym; 7700 const char *cxx_sym = sym; 7701 const char *java_sym = sym; 7702 struct bfd_elf_version_expr *expr = NULL; 7703 enum demangling_styles curr_style; 7704 7705 curr_style = CURRENT_DEMANGLING_STYLE; 7706 cplus_demangle_set_style (no_demangling); 7707 c_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_NO_OPTS); 7708 if (!c_sym) 7709 c_sym = sym; 7710 cplus_demangle_set_style (curr_style); 7711 7712 if (head->mask & BFD_ELF_VERSION_CXX_TYPE) 7713 { 7714 cxx_sym = bfd_demangle (link_info.output_bfd, sym, 7715 DMGL_PARAMS | DMGL_ANSI); 7716 if (!cxx_sym) 7717 cxx_sym = sym; 7718 } 7719 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE) 7720 { 7721 java_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_JAVA); 7722 if (!java_sym) 7723 java_sym = sym; 7724 } 7725 7726 if (head->htab && (prev == NULL || prev->literal)) 7727 { 7728 struct bfd_elf_version_expr e; 7729 7730 switch (prev ? prev->mask : 0) 7731 { 7732 case 0: 7733 if (head->mask & BFD_ELF_VERSION_C_TYPE) 7734 { 7735 e.pattern = c_sym; 7736 expr = (struct bfd_elf_version_expr *) 7737 htab_find ((htab_t) head->htab, &e); 7738 while (expr && strcmp (expr->pattern, c_sym) == 0) 7739 if (expr->mask == BFD_ELF_VERSION_C_TYPE) 7740 goto out_ret; 7741 else 7742 expr = expr->next; 7743 } 7744 /* Fallthrough */ 7745 case BFD_ELF_VERSION_C_TYPE: 7746 if (head->mask & BFD_ELF_VERSION_CXX_TYPE) 7747 { 7748 e.pattern = cxx_sym; 7749 expr = (struct bfd_elf_version_expr *) 7750 htab_find ((htab_t) head->htab, &e); 7751 while (expr && strcmp (expr->pattern, cxx_sym) == 0) 7752 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE) 7753 goto out_ret; 7754 else 7755 expr = expr->next; 7756 } 7757 /* Fallthrough */ 7758 case BFD_ELF_VERSION_CXX_TYPE: 7759 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE) 7760 { 7761 e.pattern = java_sym; 7762 expr = (struct bfd_elf_version_expr *) 7763 htab_find ((htab_t) head->htab, &e); 7764 while (expr && strcmp (expr->pattern, java_sym) == 0) 7765 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE) 7766 goto out_ret; 7767 else 7768 expr = expr->next; 7769 } 7770 /* Fallthrough */ 7771 default: 7772 break; 7773 } 7774 } 7775 7776 /* Finally, try the wildcards. */ 7777 if (prev == NULL || prev->literal) 7778 expr = head->remaining; 7779 else 7780 expr = prev->next; 7781 for (; expr; expr = expr->next) 7782 { 7783 const char *s; 7784 7785 if (!expr->pattern) 7786 continue; 7787 7788 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0') 7789 break; 7790 7791 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE) 7792 s = java_sym; 7793 else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE) 7794 s = cxx_sym; 7795 else 7796 s = c_sym; 7797 if (fnmatch (expr->pattern, s, 0) == 0) 7798 break; 7799 } 7800 7801 out_ret: 7802 if (c_sym != sym) 7803 free ((char *) c_sym); 7804 if (cxx_sym != sym) 7805 free ((char *) cxx_sym); 7806 if (java_sym != sym) 7807 free ((char *) java_sym); 7808 return expr; 7809 } 7810 7811 /* Return NULL if the PATTERN argument is a glob pattern, otherwise, 7812 return a pointer to the symbol name with any backslash quotes removed. */ 7813 7814 static const char * 7815 realsymbol (const char *pattern) 7816 { 7817 const char *p; 7818 bfd_boolean changed = FALSE, backslash = FALSE; 7819 char *s, *symbol = (char *) xmalloc (strlen (pattern) + 1); 7820 7821 for (p = pattern, s = symbol; *p != '\0'; ++p) 7822 { 7823 /* It is a glob pattern only if there is no preceding 7824 backslash. */ 7825 if (backslash) 7826 { 7827 /* Remove the preceding backslash. */ 7828 *(s - 1) = *p; 7829 backslash = FALSE; 7830 changed = TRUE; 7831 } 7832 else 7833 { 7834 if (*p == '?' || *p == '*' || *p == '[') 7835 { 7836 free (symbol); 7837 return NULL; 7838 } 7839 7840 *s++ = *p; 7841 backslash = *p == '\\'; 7842 } 7843 } 7844 7845 if (changed) 7846 { 7847 *s = '\0'; 7848 return symbol; 7849 } 7850 else 7851 { 7852 free (symbol); 7853 return pattern; 7854 } 7855 } 7856 7857 /* This is called for each variable name or match expression. NEW_NAME is 7858 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob 7859 pattern to be matched against symbol names. */ 7860 7861 struct bfd_elf_version_expr * 7862 lang_new_vers_pattern (struct bfd_elf_version_expr *orig, 7863 const char *new_name, 7864 const char *lang, 7865 bfd_boolean literal_p) 7866 { 7867 struct bfd_elf_version_expr *ret; 7868 7869 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret); 7870 ret->next = orig; 7871 ret->symver = 0; 7872 ret->script = 0; 7873 ret->literal = TRUE; 7874 ret->pattern = literal_p ? new_name : realsymbol (new_name); 7875 if (ret->pattern == NULL) 7876 { 7877 ret->pattern = new_name; 7878 ret->literal = FALSE; 7879 } 7880 7881 if (lang == NULL || strcasecmp (lang, "C") == 0) 7882 ret->mask = BFD_ELF_VERSION_C_TYPE; 7883 else if (strcasecmp (lang, "C++") == 0) 7884 ret->mask = BFD_ELF_VERSION_CXX_TYPE; 7885 else if (strcasecmp (lang, "Java") == 0) 7886 ret->mask = BFD_ELF_VERSION_JAVA_TYPE; 7887 else 7888 { 7889 einfo (_("%X%P: unknown language `%s' in version information\n"), 7890 lang); 7891 ret->mask = BFD_ELF_VERSION_C_TYPE; 7892 } 7893 7894 return ldemul_new_vers_pattern (ret); 7895 } 7896 7897 /* This is called for each set of variable names and match 7898 expressions. */ 7899 7900 struct bfd_elf_version_tree * 7901 lang_new_vers_node (struct bfd_elf_version_expr *globals, 7902 struct bfd_elf_version_expr *locals) 7903 { 7904 struct bfd_elf_version_tree *ret; 7905 7906 ret = (struct bfd_elf_version_tree *) xcalloc (1, sizeof *ret); 7907 ret->globals.list = globals; 7908 ret->locals.list = locals; 7909 ret->match = lang_vers_match; 7910 ret->name_indx = (unsigned int) -1; 7911 return ret; 7912 } 7913 7914 /* This static variable keeps track of version indices. */ 7915 7916 static int version_index; 7917 7918 static hashval_t 7919 version_expr_head_hash (const void *p) 7920 { 7921 const struct bfd_elf_version_expr *e = 7922 (const struct bfd_elf_version_expr *) p; 7923 7924 return htab_hash_string (e->pattern); 7925 } 7926 7927 static int 7928 version_expr_head_eq (const void *p1, const void *p2) 7929 { 7930 const struct bfd_elf_version_expr *e1 = 7931 (const struct bfd_elf_version_expr *) p1; 7932 const struct bfd_elf_version_expr *e2 = 7933 (const struct bfd_elf_version_expr *) p2; 7934 7935 return strcmp (e1->pattern, e2->pattern) == 0; 7936 } 7937 7938 static void 7939 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head) 7940 { 7941 size_t count = 0; 7942 struct bfd_elf_version_expr *e, *next; 7943 struct bfd_elf_version_expr **list_loc, **remaining_loc; 7944 7945 for (e = head->list; e; e = e->next) 7946 { 7947 if (e->literal) 7948 count++; 7949 head->mask |= e->mask; 7950 } 7951 7952 if (count) 7953 { 7954 head->htab = htab_create (count * 2, version_expr_head_hash, 7955 version_expr_head_eq, NULL); 7956 list_loc = &head->list; 7957 remaining_loc = &head->remaining; 7958 for (e = head->list; e; e = next) 7959 { 7960 next = e->next; 7961 if (!e->literal) 7962 { 7963 *remaining_loc = e; 7964 remaining_loc = &e->next; 7965 } 7966 else 7967 { 7968 void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT); 7969 7970 if (*loc) 7971 { 7972 struct bfd_elf_version_expr *e1, *last; 7973 7974 e1 = (struct bfd_elf_version_expr *) *loc; 7975 last = NULL; 7976 do 7977 { 7978 if (e1->mask == e->mask) 7979 { 7980 last = NULL; 7981 break; 7982 } 7983 last = e1; 7984 e1 = e1->next; 7985 } 7986 while (e1 && strcmp (e1->pattern, e->pattern) == 0); 7987 7988 if (last == NULL) 7989 { 7990 /* This is a duplicate. */ 7991 /* FIXME: Memory leak. Sometimes pattern is not 7992 xmalloced alone, but in larger chunk of memory. */ 7993 /* free (e->pattern); */ 7994 free (e); 7995 } 7996 else 7997 { 7998 e->next = last->next; 7999 last->next = e; 8000 } 8001 } 8002 else 8003 { 8004 *loc = e; 8005 *list_loc = e; 8006 list_loc = &e->next; 8007 } 8008 } 8009 } 8010 *remaining_loc = NULL; 8011 *list_loc = head->remaining; 8012 } 8013 else 8014 head->remaining = head->list; 8015 } 8016 8017 /* This is called when we know the name and dependencies of the 8018 version. */ 8019 8020 void 8021 lang_register_vers_node (const char *name, 8022 struct bfd_elf_version_tree *version, 8023 struct bfd_elf_version_deps *deps) 8024 { 8025 struct bfd_elf_version_tree *t, **pp; 8026 struct bfd_elf_version_expr *e1; 8027 8028 if (name == NULL) 8029 name = ""; 8030 8031 if (link_info.version_info != NULL 8032 && (name[0] == '\0' || link_info.version_info->name[0] == '\0')) 8033 { 8034 einfo (_("%X%P: anonymous version tag cannot be combined" 8035 " with other version tags\n")); 8036 free (version); 8037 return; 8038 } 8039 8040 /* Make sure this node has a unique name. */ 8041 for (t = link_info.version_info; t != NULL; t = t->next) 8042 if (strcmp (t->name, name) == 0) 8043 einfo (_("%X%P: duplicate version tag `%s'\n"), name); 8044 8045 lang_finalize_version_expr_head (&version->globals); 8046 lang_finalize_version_expr_head (&version->locals); 8047 8048 /* Check the global and local match names, and make sure there 8049 aren't any duplicates. */ 8050 8051 for (e1 = version->globals.list; e1 != NULL; e1 = e1->next) 8052 { 8053 for (t = link_info.version_info; t != NULL; t = t->next) 8054 { 8055 struct bfd_elf_version_expr *e2; 8056 8057 if (t->locals.htab && e1->literal) 8058 { 8059 e2 = (struct bfd_elf_version_expr *) 8060 htab_find ((htab_t) t->locals.htab, e1); 8061 while (e2 && strcmp (e1->pattern, e2->pattern) == 0) 8062 { 8063 if (e1->mask == e2->mask) 8064 einfo (_("%X%P: duplicate expression `%s'" 8065 " in version information\n"), e1->pattern); 8066 e2 = e2->next; 8067 } 8068 } 8069 else if (!e1->literal) 8070 for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next) 8071 if (strcmp (e1->pattern, e2->pattern) == 0 8072 && e1->mask == e2->mask) 8073 einfo (_("%X%P: duplicate expression `%s'" 8074 " in version information\n"), e1->pattern); 8075 } 8076 } 8077 8078 for (e1 = version->locals.list; e1 != NULL; e1 = e1->next) 8079 { 8080 for (t = link_info.version_info; t != NULL; t = t->next) 8081 { 8082 struct bfd_elf_version_expr *e2; 8083 8084 if (t->globals.htab && e1->literal) 8085 { 8086 e2 = (struct bfd_elf_version_expr *) 8087 htab_find ((htab_t) t->globals.htab, e1); 8088 while (e2 && strcmp (e1->pattern, e2->pattern) == 0) 8089 { 8090 if (e1->mask == e2->mask) 8091 einfo (_("%X%P: duplicate expression `%s'" 8092 " in version information\n"), 8093 e1->pattern); 8094 e2 = e2->next; 8095 } 8096 } 8097 else if (!e1->literal) 8098 for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next) 8099 if (strcmp (e1->pattern, e2->pattern) == 0 8100 && e1->mask == e2->mask) 8101 einfo (_("%X%P: duplicate expression `%s'" 8102 " in version information\n"), e1->pattern); 8103 } 8104 } 8105 8106 version->deps = deps; 8107 version->name = name; 8108 if (name[0] != '\0') 8109 { 8110 ++version_index; 8111 version->vernum = version_index; 8112 } 8113 else 8114 version->vernum = 0; 8115 8116 for (pp = &link_info.version_info; *pp != NULL; pp = &(*pp)->next) 8117 ; 8118 *pp = version; 8119 } 8120 8121 /* This is called when we see a version dependency. */ 8122 8123 struct bfd_elf_version_deps * 8124 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name) 8125 { 8126 struct bfd_elf_version_deps *ret; 8127 struct bfd_elf_version_tree *t; 8128 8129 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret); 8130 ret->next = list; 8131 8132 for (t = link_info.version_info; t != NULL; t = t->next) 8133 { 8134 if (strcmp (t->name, name) == 0) 8135 { 8136 ret->version_needed = t; 8137 return ret; 8138 } 8139 } 8140 8141 einfo (_("%X%P: unable to find version dependency `%s'\n"), name); 8142 8143 ret->version_needed = NULL; 8144 return ret; 8145 } 8146 8147 static void 8148 lang_do_version_exports_section (void) 8149 { 8150 struct bfd_elf_version_expr *greg = NULL, *lreg; 8151 8152 LANG_FOR_EACH_INPUT_STATEMENT (is) 8153 { 8154 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports"); 8155 char *contents, *p; 8156 bfd_size_type len; 8157 8158 if (sec == NULL) 8159 continue; 8160 8161 len = sec->size; 8162 contents = (char *) xmalloc (len); 8163 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len)) 8164 einfo (_("%X%P: unable to read .exports section contents\n"), sec); 8165 8166 p = contents; 8167 while (p < contents + len) 8168 { 8169 greg = lang_new_vers_pattern (greg, p, NULL, FALSE); 8170 p = strchr (p, '\0') + 1; 8171 } 8172 8173 /* Do not free the contents, as we used them creating the regex. */ 8174 8175 /* Do not include this section in the link. */ 8176 sec->flags |= SEC_EXCLUDE | SEC_KEEP; 8177 } 8178 8179 lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE); 8180 lang_register_vers_node (command_line.version_exports_section, 8181 lang_new_vers_node (greg, lreg), NULL); 8182 } 8183 8184 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */ 8185 8186 static void 8187 lang_do_memory_regions (void) 8188 { 8189 lang_memory_region_type *r = lang_memory_region_list; 8190 8191 for (; r != NULL; r = r->next) 8192 { 8193 if (r->origin_exp) 8194 { 8195 exp_fold_tree_no_dot (r->origin_exp); 8196 if (expld.result.valid_p) 8197 { 8198 r->origin = expld.result.value; 8199 r->current = r->origin; 8200 } 8201 else 8202 einfo (_("%F%P: invalid origin for memory region %s\n"), 8203 r->name_list.name); 8204 } 8205 if (r->length_exp) 8206 { 8207 exp_fold_tree_no_dot (r->length_exp); 8208 if (expld.result.valid_p) 8209 r->length = expld.result.value; 8210 else 8211 einfo (_("%F%P: invalid length for memory region %s\n"), 8212 r->name_list.name); 8213 } 8214 } 8215 } 8216 8217 void 8218 lang_add_unique (const char *name) 8219 { 8220 struct unique_sections *ent; 8221 8222 for (ent = unique_section_list; ent; ent = ent->next) 8223 if (strcmp (ent->name, name) == 0) 8224 return; 8225 8226 ent = (struct unique_sections *) xmalloc (sizeof *ent); 8227 ent->name = xstrdup (name); 8228 ent->next = unique_section_list; 8229 unique_section_list = ent; 8230 } 8231 8232 /* Append the list of dynamic symbols to the existing one. */ 8233 8234 void 8235 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic) 8236 { 8237 if (link_info.dynamic_list) 8238 { 8239 struct bfd_elf_version_expr *tail; 8240 for (tail = dynamic; tail->next != NULL; tail = tail->next) 8241 ; 8242 tail->next = link_info.dynamic_list->head.list; 8243 link_info.dynamic_list->head.list = dynamic; 8244 } 8245 else 8246 { 8247 struct bfd_elf_dynamic_list *d; 8248 8249 d = (struct bfd_elf_dynamic_list *) xcalloc (1, sizeof *d); 8250 d->head.list = dynamic; 8251 d->match = lang_vers_match; 8252 link_info.dynamic_list = d; 8253 } 8254 } 8255 8256 /* Append the list of C++ typeinfo dynamic symbols to the existing 8257 one. */ 8258 8259 void 8260 lang_append_dynamic_list_cpp_typeinfo (void) 8261 { 8262 const char *symbols[] = 8263 { 8264 "typeinfo name for*", 8265 "typeinfo for*" 8266 }; 8267 struct bfd_elf_version_expr *dynamic = NULL; 8268 unsigned int i; 8269 8270 for (i = 0; i < ARRAY_SIZE (symbols); i++) 8271 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++", 8272 FALSE); 8273 8274 lang_append_dynamic_list (dynamic); 8275 } 8276 8277 /* Append the list of C++ operator new and delete dynamic symbols to the 8278 existing one. */ 8279 8280 void 8281 lang_append_dynamic_list_cpp_new (void) 8282 { 8283 const char *symbols[] = 8284 { 8285 "operator new*", 8286 "operator delete*" 8287 }; 8288 struct bfd_elf_version_expr *dynamic = NULL; 8289 unsigned int i; 8290 8291 for (i = 0; i < ARRAY_SIZE (symbols); i++) 8292 dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++", 8293 FALSE); 8294 8295 lang_append_dynamic_list (dynamic); 8296 } 8297 8298 /* Scan a space and/or comma separated string of features. */ 8299 8300 void 8301 lang_ld_feature (char *str) 8302 { 8303 char *p, *q; 8304 8305 p = str; 8306 while (*p) 8307 { 8308 char sep; 8309 while (*p == ',' || ISSPACE (*p)) 8310 ++p; 8311 if (!*p) 8312 break; 8313 q = p + 1; 8314 while (*q && *q != ',' && !ISSPACE (*q)) 8315 ++q; 8316 sep = *q; 8317 *q = 0; 8318 if (strcasecmp (p, "SANE_EXPR") == 0) 8319 config.sane_expr = TRUE; 8320 else 8321 einfo (_("%X%P: unknown feature `%s'\n"), p); 8322 *q = sep; 8323 p = q; 8324 } 8325 } 8326 8327 /* Pretty print memory amount. */ 8328 8329 static void 8330 lang_print_memory_size (bfd_vma sz) 8331 { 8332 if ((sz & 0x3fffffff) == 0) 8333 printf ("%10" BFD_VMA_FMT "u GB", sz >> 30); 8334 else if ((sz & 0xfffff) == 0) 8335 printf ("%10" BFD_VMA_FMT "u MB", sz >> 20); 8336 else if ((sz & 0x3ff) == 0) 8337 printf ("%10" BFD_VMA_FMT "u KB", sz >> 10); 8338 else 8339 printf (" %10" BFD_VMA_FMT "u B", sz); 8340 } 8341 8342 /* Implement --print-memory-usage: disply per region memory usage. */ 8343 8344 void 8345 lang_print_memory_usage (void) 8346 { 8347 lang_memory_region_type *r; 8348 8349 printf ("Memory region Used Size Region Size %%age Used\n"); 8350 for (r = lang_memory_region_list; r->next != NULL; r = r->next) 8351 { 8352 bfd_vma used_length = r->current - r->origin; 8353 double percent; 8354 8355 printf ("%16s: ",r->name_list.name); 8356 lang_print_memory_size (used_length); 8357 lang_print_memory_size ((bfd_vma) r->length); 8358 8359 percent = used_length * 100.0 / r->length; 8360 8361 printf (" %6.2f%%\n", percent); 8362 } 8363 } 8364
