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