ldlang.c revision 60484
1/* Linker command language support. 2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 3 Free Software Foundation, Inc. 4 5This file is part of GLD, the Gnu Linker. 6 7GLD is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GLD is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GLD; see the file COPYING. If not, write to the Free 19Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2002111-1307, USA. */ 21 22#include "bfd.h" 23#include "sysdep.h" 24#include "libiberty.h" 25#include "obstack.h" 26#include "bfdlink.h" 27 28#include "ld.h" 29#include "ldmain.h" 30#include "ldgram.h" 31#include "ldexp.h" 32#include "ldlang.h" 33#include "ldemul.h" 34#include "ldlex.h" 35#include "ldmisc.h" 36#include "ldctor.h" 37#include "ldfile.h" 38#include "fnmatch.h" 39#include "demangle.h" 40 41#include <ctype.h> 42 43/* FORWARDS */ 44static lang_statement_union_type *new_statement PARAMS ((enum statement_enum, 45 size_t, 46 lang_statement_list_type*)); 47 48 49/* LOCALS */ 50static struct obstack stat_obstack; 51 52#define obstack_chunk_alloc xmalloc 53#define obstack_chunk_free free 54static CONST char *startup_file; 55static lang_statement_list_type input_file_chain; 56static boolean placed_commons = false; 57static lang_output_section_statement_type *default_common_section; 58static boolean map_option_f; 59static bfd_vma print_dot; 60static lang_input_statement_type *first_file; 61static lang_statement_list_type lang_output_section_statement; 62static CONST char *current_target; 63static CONST char *output_target; 64static lang_statement_list_type statement_list; 65static struct lang_phdr *lang_phdr_list; 66 67static void lang_for_each_statement_worker 68 PARAMS ((void (*func) (lang_statement_union_type *), 69 lang_statement_union_type *s)); 70static lang_input_statement_type *new_afile 71 PARAMS ((const char *name, lang_input_file_enum_type file_type, 72 const char *target, boolean add_to_list)); 73static void init_os PARAMS ((lang_output_section_statement_type *s)); 74static void exp_init_os PARAMS ((etree_type *)); 75static void section_already_linked PARAMS ((bfd *, asection *, PTR)); 76static struct bfd_hash_entry *already_linked_newfunc 77 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, 78 const char *string)); 79static void already_linked_table_init PARAMS ((void)); 80static void already_linked_table_free PARAMS ((void)); 81static boolean wildcardp PARAMS ((const char *)); 82static lang_statement_union_type *wild_sort 83 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *, 84 asection *)); 85static lang_input_statement_type *lookup_name PARAMS ((const char *name)); 86static void load_symbols PARAMS ((lang_input_statement_type *entry, 87 lang_statement_list_type *)); 88static void wild PARAMS ((lang_wild_statement_type *s, 89 const char *section, const char *file, 90 const char *target, 91 lang_output_section_statement_type *output)); 92static bfd *open_output PARAMS ((const char *name)); 93static void ldlang_open_output PARAMS ((lang_statement_union_type *statement)); 94static void open_input_bfds 95 PARAMS ((lang_statement_union_type *statement, boolean)); 96static void lang_reasonable_defaults PARAMS ((void)); 97static void lang_place_undefineds PARAMS ((void)); 98static void map_input_to_output_sections 99 PARAMS ((lang_statement_union_type *s, 100 const char *target, 101 lang_output_section_statement_type *output_section_statement)); 102static void print_output_section_statement 103 PARAMS ((lang_output_section_statement_type *output_section_statement)); 104static void print_assignment 105 PARAMS ((lang_assignment_statement_type *assignment, 106 lang_output_section_statement_type *output_section)); 107static void print_input_statement PARAMS ((lang_input_statement_type *statm)); 108static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR)); 109static void print_input_section PARAMS ((lang_input_section_type *in)); 110static void print_fill_statement PARAMS ((lang_fill_statement_type *fill)); 111static void print_data_statement PARAMS ((lang_data_statement_type *data)); 112static void print_address_statement PARAMS ((lang_address_statement_type *)); 113static void print_reloc_statement PARAMS ((lang_reloc_statement_type *reloc)); 114static void print_padding_statement PARAMS ((lang_padding_statement_type *s)); 115static void print_wild_statement 116 PARAMS ((lang_wild_statement_type *w, 117 lang_output_section_statement_type *os)); 118static void print_group 119 PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *)); 120static void print_statement PARAMS ((lang_statement_union_type *s, 121 lang_output_section_statement_type *os)); 122static void print_statement_list PARAMS ((lang_statement_union_type *s, 123 lang_output_section_statement_type *os)); 124static void print_statements PARAMS ((void)); 125static bfd_vma insert_pad PARAMS ((lang_statement_union_type **this_ptr, 126 fill_type fill, unsigned int power, 127 asection *output_section_statement, 128 bfd_vma dot)); 129static bfd_vma size_input_section 130 PARAMS ((lang_statement_union_type **this_ptr, 131 lang_output_section_statement_type *output_section_statement, 132 fill_type fill, bfd_vma dot, boolean relax)); 133static void lang_finish PARAMS ((void)); 134static void ignore_bfd_errors PARAMS ((const char *, ...)); 135static void lang_check PARAMS ((void)); 136static void lang_common PARAMS ((void)); 137static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR)); 138static void lang_place_orphans PARAMS ((void)); 139static int topower PARAMS ((int)); 140static void lang_set_startof PARAMS ((void)); 141static void reset_memory_regions PARAMS ((void)); 142static void lang_record_phdrs PARAMS ((void)); 143static void lang_gc_wild 144 PARAMS ((lang_wild_statement_type *, const char *, const char *)); 145static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *)); 146static void lang_gc_sections PARAMS ((void)); 147static void lang_do_version_exports_section PARAMS ((void)); 148static void lang_check_section_addresses PARAMS ((void)); 149 150typedef void (*callback_t) PARAMS ((lang_wild_statement_type *, 151 asection *, lang_input_statement_type *, 152 void *)); 153static void walk_wild_section 154 PARAMS ((lang_wild_statement_type *, const char *, 155 lang_input_statement_type *, callback_t, void *)); 156static void walk_wild_file 157 PARAMS ((lang_wild_statement_type *, const char *, 158 lang_input_statement_type *, callback_t, void *)); 159 160static int get_target PARAMS ((const bfd_target *, void *)); 161static void stricpy PARAMS ((char *, char *)); 162static void strcut PARAMS ((char *, char *)); 163static int name_compare PARAMS ((char *, char *)); 164static int closest_target_match PARAMS ((const bfd_target *, void *)); 165static char * get_first_input_target PARAMS ((void)); 166 167/* EXPORTS */ 168lang_output_section_statement_type *abs_output_section; 169lang_statement_list_type *stat_ptr = &statement_list; 170lang_statement_list_type file_chain = { NULL, NULL }; 171const char *entry_symbol = NULL; 172boolean entry_from_cmdline; 173boolean lang_has_input_file = false; 174boolean had_output_filename = false; 175boolean lang_float_flag = false; 176boolean delete_output_file_on_failure = false; 177struct lang_nocrossrefs *nocrossref_list; 178 179etree_type *base; /* Relocation base - or null */ 180 181 182#if defined(__STDC__) || defined(ALMOST_STDC) 183#define cat(a,b) a##b 184#else 185#define cat(a,b) a/**/b 186#endif 187 188#define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y) 189 190#define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma) 191 192#define outside_symbol_address(q) ((q)->value + outside_section_address(q->section)) 193 194#define SECTION_NAME_MAP_LENGTH (16) 195 196PTR 197stat_alloc (size) 198 size_t size; 199{ 200 return obstack_alloc (&stat_obstack, size); 201} 202 203/*---------------------------------------------------------------------- 204 Generic traversal routines for finding matching sections. 205*/ 206 207static void 208walk_wild_section (ptr, section, file, callback, data) 209 lang_wild_statement_type *ptr; 210 const char *section; 211 lang_input_statement_type *file; 212 callback_t callback; 213 void *data; 214{ 215 /* Don't process sections from files which were excluded. */ 216 if (ptr->exclude_filename_list != NULL) 217 { 218 struct name_list *list_tmp; 219 for (list_tmp = ptr->exclude_filename_list; list_tmp; list_tmp = list_tmp->next) 220 { 221 boolean match; 222 223 if (wildcardp (list_tmp->name)) 224 match = fnmatch (list_tmp->name, file->filename, 0) == 0 ? true : false; 225 else 226 match = strcmp (list_tmp->name, file->filename) == 0 ? true : false; 227 228 if (match) 229 return; 230 } 231 } 232 233 if (file->just_syms_flag == false) 234 { 235 register asection *s; 236 boolean wildcard; 237 238 if (section == NULL) 239 wildcard = false; 240 else 241 wildcard = wildcardp (section); 242 243 for (s = file->the_bfd->sections; s != NULL; s = s->next) 244 { 245 boolean match; 246 247 if (section == NULL) 248 match = true; 249 else 250 { 251 const char *name; 252 253 name = bfd_get_section_name (file->the_bfd, s); 254 if (wildcard) 255 match = fnmatch (section, name, 0) == 0 ? true : false; 256 else 257 match = strcmp (section, name) == 0 ? true : false; 258 } 259 260 if (match) 261 (*callback) (ptr, s, file, data); 262 } 263 } 264} 265 266/* Handle a wild statement for a single file F. */ 267 268static void 269walk_wild_file (s, section, f, callback, data) 270 lang_wild_statement_type *s; 271 const char *section; 272 lang_input_statement_type *f; 273 callback_t callback; 274 void *data; 275{ 276 if (f->the_bfd == NULL 277 || ! bfd_check_format (f->the_bfd, bfd_archive)) 278 walk_wild_section (s, section, f, callback, data); 279 else 280 { 281 bfd *member; 282 283 /* This is an archive file. We must map each member of the 284 archive separately. */ 285 member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL); 286 while (member != NULL) 287 { 288 /* When lookup_name is called, it will call the add_symbols 289 entry point for the archive. For each element of the 290 archive which is included, BFD will call ldlang_add_file, 291 which will set the usrdata field of the member to the 292 lang_input_statement. */ 293 if (member->usrdata != NULL) 294 { 295 walk_wild_section (s, section, 296 (lang_input_statement_type *) member->usrdata, 297 callback, data); 298 } 299 300 member = bfd_openr_next_archived_file (f->the_bfd, member); 301 } 302 } 303} 304 305static void 306walk_wild (s, section, file, callback, data) 307 lang_wild_statement_type *s; 308 const char *section; 309 const char *file; 310 callback_t callback; 311 void *data; 312{ 313 if (file == (char *) NULL) 314 { 315 /* Perform the iteration over all files in the list. */ 316 LANG_FOR_EACH_INPUT_STATEMENT (f) 317 { 318 walk_wild_file (s, section, f, callback, data); 319 } 320 } 321 else if (wildcardp (file)) 322 { 323 LANG_FOR_EACH_INPUT_STATEMENT (f) 324 { 325 if (fnmatch (file, f->filename, FNM_FILE_NAME) == 0) 326 walk_wild_file (s, section, f, callback, data); 327 } 328 } 329 else 330 { 331 lang_input_statement_type *f; 332 333 /* Perform the iteration over a single file. */ 334 f = lookup_name (file); 335 walk_wild_file (s, section, f, callback, data); 336 } 337} 338 339/*---------------------------------------------------------------------- 340 lang_for_each_statement walks the parse tree and calls the provided 341 function for each node 342*/ 343 344static void 345lang_for_each_statement_worker (func, s) 346 void (*func) PARAMS ((lang_statement_union_type *)); 347 lang_statement_union_type *s; 348{ 349 for (; s != (lang_statement_union_type *) NULL; s = s->next) 350 { 351 func (s); 352 353 switch (s->header.type) 354 { 355 case lang_constructors_statement_enum: 356 lang_for_each_statement_worker (func, constructor_list.head); 357 break; 358 case lang_output_section_statement_enum: 359 lang_for_each_statement_worker 360 (func, 361 s->output_section_statement.children.head); 362 break; 363 case lang_wild_statement_enum: 364 lang_for_each_statement_worker 365 (func, 366 s->wild_statement.children.head); 367 break; 368 case lang_group_statement_enum: 369 lang_for_each_statement_worker (func, 370 s->group_statement.children.head); 371 break; 372 case lang_data_statement_enum: 373 case lang_reloc_statement_enum: 374 case lang_object_symbols_statement_enum: 375 case lang_output_statement_enum: 376 case lang_target_statement_enum: 377 case lang_input_section_enum: 378 case lang_input_statement_enum: 379 case lang_assignment_statement_enum: 380 case lang_padding_statement_enum: 381 case lang_address_statement_enum: 382 case lang_fill_statement_enum: 383 break; 384 default: 385 FAIL (); 386 break; 387 } 388 } 389} 390 391void 392lang_for_each_statement (func) 393 void (*func) PARAMS ((lang_statement_union_type *)); 394{ 395 lang_for_each_statement_worker (func, 396 statement_list.head); 397} 398 399/*----------------------------------------------------------------------*/ 400void 401lang_list_init (list) 402 lang_statement_list_type *list; 403{ 404 list->head = (lang_statement_union_type *) NULL; 405 list->tail = &list->head; 406} 407 408/*---------------------------------------------------------------------- 409 410 build a new statement node for the parse tree 411 412 */ 413 414static 415lang_statement_union_type * 416new_statement (type, size, list) 417 enum statement_enum type; 418 size_t size; 419 lang_statement_list_type * list; 420{ 421 lang_statement_union_type *new = (lang_statement_union_type *) 422 stat_alloc (size); 423 424 new->header.type = type; 425 new->header.next = (lang_statement_union_type *) NULL; 426 lang_statement_append (list, new, &new->header.next); 427 return new; 428} 429 430/* 431 Build a new input file node for the language. There are several ways 432 in which we treat an input file, eg, we only look at symbols, or 433 prefix it with a -l etc. 434 435 We can be supplied with requests for input files more than once; 436 they may, for example be split over serveral lines like foo.o(.text) 437 foo.o(.data) etc, so when asked for a file we check that we havn't 438 got it already so we don't duplicate the bfd. 439 440 */ 441static lang_input_statement_type * 442new_afile (name, file_type, target, add_to_list) 443 CONST char *name; 444 lang_input_file_enum_type file_type; 445 CONST char *target; 446 boolean add_to_list; 447{ 448 lang_input_statement_type *p; 449 450 if (add_to_list) 451 p = new_stat (lang_input_statement, stat_ptr); 452 else 453 { 454 p = ((lang_input_statement_type *) 455 stat_alloc (sizeof (lang_input_statement_type))); 456 p->header.next = NULL; 457 } 458 459 lang_has_input_file = true; 460 p->target = target; 461 switch (file_type) 462 { 463 case lang_input_file_is_symbols_only_enum: 464 p->filename = name; 465 p->is_archive = false; 466 p->real = true; 467 p->local_sym_name = name; 468 p->just_syms_flag = true; 469 p->search_dirs_flag = false; 470 break; 471 case lang_input_file_is_fake_enum: 472 p->filename = name; 473 p->is_archive = false; 474 p->real = false; 475 p->local_sym_name = name; 476 p->just_syms_flag = false; 477 p->search_dirs_flag = false; 478 break; 479 case lang_input_file_is_l_enum: 480 p->is_archive = true; 481 p->filename = name; 482 p->real = true; 483 p->local_sym_name = concat ("-l", name, (const char *) NULL); 484 p->just_syms_flag = false; 485 p->search_dirs_flag = true; 486 break; 487 case lang_input_file_is_marker_enum: 488 p->filename = name; 489 p->is_archive = false; 490 p->real = false; 491 p->local_sym_name = name; 492 p->just_syms_flag = false; 493 p->search_dirs_flag = true; 494 break; 495 case lang_input_file_is_search_file_enum: 496 p->filename = name; 497 p->is_archive = false; 498 p->real = true; 499 p->local_sym_name = name; 500 p->just_syms_flag = false; 501 p->search_dirs_flag = true; 502 break; 503 case lang_input_file_is_file_enum: 504 p->filename = name; 505 p->is_archive = false; 506 p->real = true; 507 p->local_sym_name = name; 508 p->just_syms_flag = false; 509 p->search_dirs_flag = false; 510 break; 511 default: 512 FAIL (); 513 } 514 p->the_bfd = (bfd *) NULL; 515 p->asymbols = (asymbol **) NULL; 516 p->next_real_file = (lang_statement_union_type *) NULL; 517 p->next = (lang_statement_union_type *) NULL; 518 p->symbol_count = 0; 519 p->dynamic = config.dynamic_link; 520 p->whole_archive = whole_archive; 521 p->loaded = false; 522 lang_statement_append (&input_file_chain, 523 (lang_statement_union_type *) p, 524 &p->next_real_file); 525 return p; 526} 527 528lang_input_statement_type * 529lang_add_input_file (name, file_type, target) 530 CONST char *name; 531 lang_input_file_enum_type file_type; 532 CONST char *target; 533{ 534 lang_has_input_file = true; 535 return new_afile (name, file_type, target, true); 536} 537 538/* Build enough state so that the parser can build its tree */ 539void 540lang_init () 541{ 542 obstack_begin (&stat_obstack, 1000); 543 544 stat_ptr = &statement_list; 545 546 lang_list_init (stat_ptr); 547 548 lang_list_init (&input_file_chain); 549 lang_list_init (&lang_output_section_statement); 550 lang_list_init (&file_chain); 551 first_file = lang_add_input_file ((char *) NULL, 552 lang_input_file_is_marker_enum, 553 (char *) NULL); 554 abs_output_section = lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME); 555 556 abs_output_section->bfd_section = bfd_abs_section_ptr; 557 558} 559 560/*---------------------------------------------------------------------- 561 A region is an area of memory declared with the 562 MEMORY { name:org=exp, len=exp ... } 563 syntax. 564 565 We maintain a list of all the regions here 566 567 If no regions are specified in the script, then the default is used 568 which is created when looked up to be the entire data space 569*/ 570 571static lang_memory_region_type *lang_memory_region_list; 572static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list; 573 574lang_memory_region_type * 575lang_memory_region_lookup (name) 576 CONST char *CONST name; 577{ 578 lang_memory_region_type *p; 579 580 for (p = lang_memory_region_list; 581 p != (lang_memory_region_type *) NULL; 582 p = p->next) 583 { 584 if (strcmp (p->name, name) == 0) 585 { 586 return p; 587 } 588 } 589 590#if 0 591 /* This code used to always use the first region in the list as the 592 default region. I changed it to instead use a region 593 encompassing all of memory as the default region. This permits 594 NOLOAD sections to work reasonably without requiring a region. 595 People should specify what region they mean, if they really want 596 a region. */ 597 if (strcmp (name, "*default*") == 0) 598 { 599 if (lang_memory_region_list != (lang_memory_region_type *) NULL) 600 { 601 return lang_memory_region_list; 602 } 603 } 604#endif 605 606 { 607 lang_memory_region_type *new = 608 (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type)); 609 610 new->name = buystring (name); 611 new->next = (lang_memory_region_type *) NULL; 612 613 *lang_memory_region_list_tail = new; 614 lang_memory_region_list_tail = &new->next; 615 new->origin = 0; 616 new->flags = 0; 617 new->not_flags = 0; 618 new->length = ~(bfd_size_type)0; 619 new->current = 0; 620 new->had_full_message = false; 621 622 return new; 623 } 624} 625 626 627lang_memory_region_type * 628lang_memory_default (section) 629 asection *section; 630{ 631 lang_memory_region_type *p; 632 633 flagword sec_flags = section->flags; 634 635 /* Override SEC_DATA to mean a writable section. */ 636 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC) 637 sec_flags |= SEC_DATA; 638 639 for (p = lang_memory_region_list; 640 p != (lang_memory_region_type *) NULL; 641 p = p->next) 642 { 643 if ((p->flags & sec_flags) != 0 644 && (p->not_flags & sec_flags) == 0) 645 { 646 return p; 647 } 648 } 649 return lang_memory_region_lookup ("*default*"); 650} 651 652lang_output_section_statement_type * 653lang_output_section_find (name) 654 CONST char *CONST name; 655{ 656 lang_statement_union_type *u; 657 lang_output_section_statement_type *lookup; 658 659 for (u = lang_output_section_statement.head; 660 u != (lang_statement_union_type *) NULL; 661 u = lookup->next) 662 { 663 lookup = &u->output_section_statement; 664 if (strcmp (name, lookup->name) == 0) 665 { 666 return lookup; 667 } 668 } 669 return (lang_output_section_statement_type *) NULL; 670} 671 672lang_output_section_statement_type * 673lang_output_section_statement_lookup (name) 674 CONST char *CONST name; 675{ 676 lang_output_section_statement_type *lookup; 677 678 lookup = lang_output_section_find (name); 679 if (lookup == (lang_output_section_statement_type *) NULL) 680 { 681 682 lookup = (lang_output_section_statement_type *) 683 new_stat (lang_output_section_statement, stat_ptr); 684 lookup->region = (lang_memory_region_type *) NULL; 685 lookup->lma_region = (lang_memory_region_type *) NULL; 686 lookup->fill = 0; 687 lookup->block_value = 1; 688 lookup->name = name; 689 690 lookup->next = (lang_statement_union_type *) NULL; 691 lookup->bfd_section = (asection *) NULL; 692 lookup->processed = false; 693 lookup->sectype = normal_section; 694 lookup->addr_tree = (etree_type *) NULL; 695 lang_list_init (&lookup->children); 696 697 lookup->memspec = (CONST char *) NULL; 698 lookup->flags = 0; 699 lookup->subsection_alignment = -1; 700 lookup->section_alignment = -1; 701 lookup->load_base = (union etree_union *) NULL; 702 lookup->phdrs = NULL; 703 704 lang_statement_append (&lang_output_section_statement, 705 (lang_statement_union_type *) lookup, 706 &lookup->next); 707 } 708 return lookup; 709} 710 711static void 712lang_map_flags (flag) 713 flagword flag; 714{ 715 if (flag & SEC_ALLOC) 716 minfo ("a"); 717 718 if (flag & SEC_CODE) 719 minfo ("x"); 720 721 if (flag & SEC_READONLY) 722 minfo ("r"); 723 724 if (flag & SEC_DATA) 725 minfo ("w"); 726 727 if (flag & SEC_LOAD) 728 minfo ("l"); 729} 730 731void 732lang_map () 733{ 734 lang_memory_region_type *m; 735 736 minfo (_("\nMemory Configuration\n\n")); 737 fprintf (config.map_file, "%-16s %-18s %-18s %s\n", 738 _("Name"), _("Origin"), _("Length"), _("Attributes")); 739 740 for (m = lang_memory_region_list; 741 m != (lang_memory_region_type *) NULL; 742 m = m->next) 743 { 744 char buf[100]; 745 int len; 746 747 fprintf (config.map_file, "%-16s ", m->name); 748 749 sprintf_vma (buf, m->origin); 750 minfo ("0x%s ", buf); 751 len = strlen (buf); 752 while (len < 16) 753 { 754 print_space (); 755 ++len; 756 } 757 758 minfo ("0x%V", m->length); 759 if (m->flags || m->not_flags) 760 { 761#ifndef BFD64 762 minfo (" "); 763#endif 764 if (m->flags) 765 { 766 print_space (); 767 lang_map_flags (m->flags); 768 } 769 770 if (m->not_flags) 771 { 772 minfo (" !"); 773 lang_map_flags (m->not_flags); 774 } 775 } 776 777 print_nl (); 778 } 779 780 fprintf (config.map_file, _("\nLinker script and memory map\n\n")); 781 782 print_statements (); 783} 784 785/* Initialize an output section. */ 786 787static void 788init_os (s) 789 lang_output_section_statement_type *s; 790{ 791 section_userdata_type *new; 792 793 if (s->bfd_section != NULL) 794 return; 795 796 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0) 797 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME); 798 799 new = ((section_userdata_type *) 800 stat_alloc (sizeof (section_userdata_type))); 801 802 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name); 803 if (s->bfd_section == (asection *) NULL) 804 s->bfd_section = bfd_make_section (output_bfd, s->name); 805 if (s->bfd_section == (asection *) NULL) 806 { 807 einfo (_("%P%F: output format %s cannot represent section called %s\n"), 808 output_bfd->xvec->name, s->name); 809 } 810 s->bfd_section->output_section = s->bfd_section; 811 812 /* We initialize an output sections output offset to minus its own */ 813 /* vma to allow us to output a section through itself */ 814 s->bfd_section->output_offset = 0; 815 get_userdata (s->bfd_section) = (PTR) new; 816 817 /* If there is a base address, make sure that any sections it might 818 mention are initialized. */ 819 if (s->addr_tree != NULL) 820 exp_init_os (s->addr_tree); 821} 822 823/* Make sure that all output sections mentioned in an expression are 824 initialized. */ 825 826static void 827exp_init_os (exp) 828 etree_type *exp; 829{ 830 switch (exp->type.node_class) 831 { 832 case etree_assign: 833 exp_init_os (exp->assign.src); 834 break; 835 836 case etree_binary: 837 exp_init_os (exp->binary.lhs); 838 exp_init_os (exp->binary.rhs); 839 break; 840 841 case etree_trinary: 842 exp_init_os (exp->trinary.cond); 843 exp_init_os (exp->trinary.lhs); 844 exp_init_os (exp->trinary.rhs); 845 break; 846 847 case etree_unary: 848 exp_init_os (exp->unary.child); 849 break; 850 851 case etree_name: 852 switch (exp->type.node_code) 853 { 854 case ADDR: 855 case LOADADDR: 856 case SIZEOF: 857 { 858 lang_output_section_statement_type *os; 859 860 os = lang_output_section_find (exp->name.name); 861 if (os != NULL && os->bfd_section == NULL) 862 init_os (os); 863 } 864 } 865 break; 866 867 default: 868 break; 869 } 870} 871 872/* Sections marked with the SEC_LINK_ONCE flag should only be linked 873 once into the output. This routine checks each section, and 874 arrange to discard it if a section of the same name has already 875 been linked. If the section has COMDAT information, then it uses 876 that to decide whether the section should be included. This code 877 assumes that all relevant sections have the SEC_LINK_ONCE flag set; 878 that is, it does not depend solely upon the section name. 879 section_already_linked is called via bfd_map_over_sections. */ 880 881/* This is the shape of the elements inside the already_linked hash 882 table. It maps a name onto a list of already_linked elements with 883 the same name. It's possible to get more than one element in a 884 list if the COMDAT sections have different names. */ 885 886struct already_linked_hash_entry 887{ 888 struct bfd_hash_entry root; 889 struct already_linked *entry; 890}; 891 892struct already_linked 893{ 894 struct already_linked *next; 895 asection *sec; 896}; 897 898/* The hash table. */ 899 900static struct bfd_hash_table already_linked_table; 901 902/*ARGSUSED*/ 903static void 904section_already_linked (abfd, sec, data) 905 bfd *abfd; 906 asection *sec; 907 PTR data; 908{ 909 lang_input_statement_type *entry = (lang_input_statement_type *) data; 910 flagword flags; 911 const char *name; 912 struct already_linked *l; 913 struct already_linked_hash_entry *already_linked_list; 914 915 /* If we are only reading symbols from this object, then we want to 916 discard all sections. */ 917 if (entry->just_syms_flag) 918 { 919 sec->output_section = bfd_abs_section_ptr; 920 sec->output_offset = sec->vma; 921 return; 922 } 923 924 flags = bfd_get_section_flags (abfd, sec); 925 926 if ((flags & SEC_LINK_ONCE) == 0) 927 return; 928 929 /* FIXME: When doing a relocateable link, we may have trouble 930 copying relocations in other sections that refer to local symbols 931 in the section being discarded. Those relocations will have to 932 be converted somehow; as of this writing I'm not sure that any of 933 the backends handle that correctly. 934 935 It is tempting to instead not discard link once sections when 936 doing a relocateable link (technically, they should be discarded 937 whenever we are building constructors). However, that fails, 938 because the linker winds up combining all the link once sections 939 into a single large link once section, which defeats the purpose 940 of having link once sections in the first place. 941 942 Also, not merging link once sections in a relocateable link 943 causes trouble for MIPS ELF, which relies in link once semantics 944 to handle the .reginfo section correctly. */ 945 946 name = bfd_get_section_name (abfd, sec); 947 948 already_linked_list = 949 ((struct already_linked_hash_entry *) 950 bfd_hash_lookup (&already_linked_table, name, true, false)); 951 952 for (l = already_linked_list->entry; l != NULL; l = l->next) 953 { 954 if (sec->comdat == NULL 955 || l->sec->comdat == NULL 956 || strcmp (sec->comdat->name, l->sec->comdat->name) == 0) 957 { 958 /* The section has already been linked. See if we should 959 issue a warning. */ 960 switch (flags & SEC_LINK_DUPLICATES) 961 { 962 default: 963 abort (); 964 965 case SEC_LINK_DUPLICATES_DISCARD: 966 break; 967 968 case SEC_LINK_DUPLICATES_ONE_ONLY: 969 if (sec->comdat == NULL) 970 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"), 971 abfd, name); 972 else 973 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"), 974 abfd, name, sec->comdat->name); 975 break; 976 977 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 978 /* FIXME: We should really dig out the contents of both 979 sections and memcmp them. The COFF/PE spec says that 980 the Microsoft linker does not implement this 981 correctly, so I'm not going to bother doing it 982 either. */ 983 /* Fall through. */ 984 case SEC_LINK_DUPLICATES_SAME_SIZE: 985 if (bfd_section_size (abfd, sec) 986 != bfd_section_size (l->sec->owner, l->sec)) 987 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"), 988 abfd, name); 989 break; 990 } 991 992 /* Set the output_section field so that wild_doit does not 993 create a lang_input_section structure for this section. 994 Since there might be a symbol in the section being 995 discarded, we must retain a pointer to the section which 996 we are really going to use. */ 997 sec->output_section = bfd_abs_section_ptr; 998 if (sec->comdat != NULL) 999 sec->comdat->sec = l->sec; 1000 1001 return; 1002 } 1003 } 1004 1005 /* This is the first section with this name. Record it. Allocate 1006 the memory from the same obstack as the hash table is kept in. */ 1007 1008 l = ((struct already_linked *) 1009 bfd_hash_allocate (&already_linked_table, sizeof *l)); 1010 1011 l->sec = sec; 1012 l->next = already_linked_list->entry; 1013 already_linked_list->entry = l; 1014} 1015 1016/* Support routines for the hash table used by section_already_linked, 1017 initialize the table, fill in an entry and remove the table. */ 1018 1019static struct bfd_hash_entry * 1020already_linked_newfunc (entry, table, string) 1021 struct bfd_hash_entry *entry ATTRIBUTE_UNUSED; 1022 struct bfd_hash_table *table; 1023 const char *string ATTRIBUTE_UNUSED; 1024{ 1025 struct already_linked_hash_entry *ret = 1026 bfd_hash_allocate (table, sizeof (struct already_linked_hash_entry)); 1027 1028 ret->entry = NULL; 1029 1030 return (struct bfd_hash_entry *) ret; 1031} 1032 1033static void 1034already_linked_table_init () 1035{ 1036 if (! bfd_hash_table_init_n (&already_linked_table, 1037 already_linked_newfunc, 1038 42)) 1039 einfo (_("%P%F: Failed to create hash table\n")); 1040} 1041 1042static void 1043already_linked_table_free () 1044{ 1045 bfd_hash_table_free (&already_linked_table); 1046} 1047 1048/* The wild routines. 1049 1050 These expand statements like *(.text) and foo.o to a list of 1051 explicit actions, like foo.o(.text), bar.o(.text) and 1052 foo.o(.text, .data). */ 1053 1054/* Return true if the PATTERN argument is a wildcard pattern. 1055 Although backslashes are treated specially if a pattern contains 1056 wildcards, we do not consider the mere presence of a backslash to 1057 be enough to cause the the pattern to be treated as a wildcard. 1058 That lets us handle DOS filenames more naturally. */ 1059 1060static boolean 1061wildcardp (pattern) 1062 const char *pattern; 1063{ 1064 const char *s; 1065 1066 for (s = pattern; *s != '\0'; ++s) 1067 if (*s == '?' 1068 || *s == '*' 1069 || *s == '[') 1070 return true; 1071 return false; 1072} 1073 1074/* Add SECTION to the output section OUTPUT. Do this by creating a 1075 lang_input_section statement which is placed at PTR. FILE is the 1076 input file which holds SECTION. */ 1077 1078void 1079wild_doit (ptr, section, output, file) 1080 lang_statement_list_type *ptr; 1081 asection *section; 1082 lang_output_section_statement_type *output; 1083 lang_input_statement_type *file; 1084{ 1085 flagword flags; 1086 boolean discard; 1087 1088 flags = bfd_get_section_flags (section->owner, section); 1089 1090 discard = false; 1091 1092 /* If we are doing a final link, discard sections marked with 1093 SEC_EXCLUDE. */ 1094 if (! link_info.relocateable 1095 && (flags & SEC_EXCLUDE) != 0) 1096 discard = true; 1097 1098 /* Discard input sections which are assigned to a section named 1099 DISCARD_SECTION_NAME. */ 1100 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0) 1101 discard = true; 1102 1103 /* Discard debugging sections if we are stripping debugging 1104 information. */ 1105 if ((link_info.strip == strip_debugger || link_info.strip == strip_all) 1106 && (flags & SEC_DEBUGGING) != 0) 1107 discard = true; 1108 1109 if (discard) 1110 { 1111 if (section->output_section == NULL) 1112 { 1113 /* This prevents future calls from assigning this section. */ 1114 section->output_section = bfd_abs_section_ptr; 1115 } 1116 return; 1117 } 1118 1119 if (section->output_section == NULL) 1120 { 1121 boolean first; 1122 lang_input_section_type *new; 1123 flagword flags; 1124 1125 if (output->bfd_section == NULL) 1126 { 1127 init_os (output); 1128 first = true; 1129 } 1130 else 1131 first = false; 1132 1133 /* Add a section reference to the list */ 1134 new = new_stat (lang_input_section, ptr); 1135 1136 new->section = section; 1137 new->ifile = file; 1138 section->output_section = output->bfd_section; 1139 1140 flags = section->flags; 1141 1142 /* We don't copy the SEC_NEVER_LOAD flag from an input section 1143 to an output section, because we want to be able to include a 1144 SEC_NEVER_LOAD section in the middle of an otherwise loaded 1145 section (I don't know why we want to do this, but we do). 1146 build_link_order in ldwrite.c handles this case by turning 1147 the embedded SEC_NEVER_LOAD section into a fill. */ 1148 1149 flags &= ~ SEC_NEVER_LOAD; 1150 1151 /* If final link, don't copy the SEC_LINK_ONCE flags, they've 1152 already been processed. One reason to do this is that on pe 1153 format targets, .text$foo sections go into .text and it's odd 1154 to see .text with SEC_LINK_ONCE set. */ 1155 1156 if (! link_info.relocateable) 1157 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES); 1158 1159 /* If this is not the first input section, and the SEC_READONLY 1160 flag is not currently set, then don't set it just because the 1161 input section has it set. */ 1162 1163 if (! first && (section->output_section->flags & SEC_READONLY) == 0) 1164 flags &= ~ SEC_READONLY; 1165 1166 section->output_section->flags |= flags; 1167 1168 /* If SEC_READONLY is not set in the input section, then clear 1169 it from the output section. */ 1170 if ((section->flags & SEC_READONLY) == 0) 1171 section->output_section->flags &= ~SEC_READONLY; 1172 1173 switch (output->sectype) 1174 { 1175 case normal_section: 1176 break; 1177 case dsect_section: 1178 case copy_section: 1179 case info_section: 1180 case overlay_section: 1181 output->bfd_section->flags &= ~SEC_ALLOC; 1182 break; 1183 case noload_section: 1184 output->bfd_section->flags &= ~SEC_LOAD; 1185 output->bfd_section->flags |= SEC_NEVER_LOAD; 1186 break; 1187 } 1188 1189 /* Copy over SEC_SMALL_DATA. */ 1190 if (section->flags & SEC_SMALL_DATA) 1191 section->output_section->flags |= SEC_SMALL_DATA; 1192 1193 if (section->alignment_power > output->bfd_section->alignment_power) 1194 output->bfd_section->alignment_power = section->alignment_power; 1195 1196 /* If supplied an aligment, then force it. */ 1197 if (output->section_alignment != -1) 1198 output->bfd_section->alignment_power = output->section_alignment; 1199 } 1200} 1201 1202/* Handle wildcard sorting. This returns the lang_input_section which 1203 should follow the one we are going to create for SECTION and FILE, 1204 based on the sorting requirements of WILD. It returns NULL if the 1205 new section should just go at the end of the current list. */ 1206 1207static lang_statement_union_type * 1208wild_sort (wild, file, section) 1209 lang_wild_statement_type *wild; 1210 lang_input_statement_type *file; 1211 asection *section; 1212{ 1213 const char *section_name; 1214 lang_statement_union_type *l; 1215 1216 if (! wild->filenames_sorted && ! wild->sections_sorted) 1217 return NULL; 1218 1219 section_name = bfd_get_section_name (file->the_bfd, section); 1220 for (l = wild->children.head; l != NULL; l = l->next) 1221 { 1222 lang_input_section_type *ls; 1223 1224 if (l->header.type != lang_input_section_enum) 1225 continue; 1226 ls = &l->input_section; 1227 1228 /* Sorting by filename takes precedence over sorting by section 1229 name. */ 1230 1231 if (wild->filenames_sorted) 1232 { 1233 const char *fn, *ln; 1234 boolean fa, la; 1235 int i; 1236 1237 /* The PE support for the .idata section as generated by 1238 dlltool assumes that files will be sorted by the name of 1239 the archive and then the name of the file within the 1240 archive. */ 1241 1242 if (file->the_bfd != NULL 1243 && bfd_my_archive (file->the_bfd) != NULL) 1244 { 1245 fn = bfd_get_filename (bfd_my_archive (file->the_bfd)); 1246 fa = true; 1247 } 1248 else 1249 { 1250 fn = file->filename; 1251 fa = false; 1252 } 1253 1254 if (ls->ifile->the_bfd != NULL 1255 && bfd_my_archive (ls->ifile->the_bfd) != NULL) 1256 { 1257 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd)); 1258 la = true; 1259 } 1260 else 1261 { 1262 ln = ls->ifile->filename; 1263 la = false; 1264 } 1265 1266 i = strcmp (fn, ln); 1267 if (i > 0) 1268 continue; 1269 else if (i < 0) 1270 break; 1271 1272 if (fa || la) 1273 { 1274 if (fa) 1275 fn = file->filename; 1276 if (la) 1277 ln = ls->ifile->filename; 1278 1279 i = strcmp (fn, ln); 1280 if (i > 0) 1281 continue; 1282 else if (i < 0) 1283 break; 1284 } 1285 } 1286 1287 /* Here either the files are not sorted by name, or we are 1288 looking at the sections for this file. */ 1289 1290 if (wild->sections_sorted) 1291 { 1292 if (strcmp (section_name, 1293 bfd_get_section_name (ls->ifile->the_bfd, 1294 ls->section)) 1295 < 0) 1296 break; 1297 } 1298 } 1299 1300 return l; 1301} 1302 1303/* Expand a wild statement for a particular FILE. SECTION may be 1304 NULL, in which case it is a wild card. */ 1305 1306static void 1307output_section_callback (ptr, section, file, output) 1308 lang_wild_statement_type *ptr; 1309 asection *section; 1310 lang_input_statement_type *file; 1311 void *output; 1312{ 1313 lang_statement_union_type *before; 1314 1315 /* If the wild pattern was marked KEEP, the member sections 1316 should be as well. */ 1317 if (ptr->keep_sections) 1318 section->flags |= SEC_KEEP; 1319 1320 before = wild_sort (ptr, file, section); 1321 1322 /* Here BEFORE points to the lang_input_section which 1323 should follow the one we are about to add. If BEFORE 1324 is NULL, then the section should just go at the end 1325 of the current list. */ 1326 1327 if (before == NULL) 1328 wild_doit (&ptr->children, section, 1329 (lang_output_section_statement_type *) output, 1330 file); 1331 else 1332 { 1333 lang_statement_list_type list; 1334 lang_statement_union_type **pp; 1335 1336 lang_list_init (&list); 1337 wild_doit (&list, section, 1338 (lang_output_section_statement_type *) output, 1339 file); 1340 1341 /* If we are discarding the section, LIST.HEAD will 1342 be NULL. */ 1343 if (list.head != NULL) 1344 { 1345 ASSERT (list.head->next == NULL); 1346 1347 for (pp = &ptr->children.head; 1348 *pp != before; 1349 pp = &(*pp)->next) 1350 ASSERT (*pp != NULL); 1351 1352 list.head->next = *pp; 1353 *pp = list.head; 1354 } 1355 } 1356} 1357 1358/* This is passed a file name which must have been seen already and 1359 added to the statement tree. We will see if it has been opened 1360 already and had its symbols read. If not then we'll read it. */ 1361 1362static lang_input_statement_type * 1363lookup_name (name) 1364 const char *name; 1365{ 1366 lang_input_statement_type *search; 1367 1368 for (search = (lang_input_statement_type *) input_file_chain.head; 1369 search != (lang_input_statement_type *) NULL; 1370 search = (lang_input_statement_type *) search->next_real_file) 1371 { 1372 if (search->filename == (char *) NULL && name == (char *) NULL) 1373 return search; 1374 if (search->filename != (char *) NULL 1375 && name != (char *) NULL 1376 && strcmp (search->filename, name) == 0) 1377 break; 1378 } 1379 1380 if (search == (lang_input_statement_type *) NULL) 1381 search = new_afile (name, lang_input_file_is_file_enum, default_target, 1382 false); 1383 1384 /* If we have already added this file, or this file is not real 1385 (FIXME: can that ever actually happen?) or the name is NULL 1386 (FIXME: can that ever actually happen?) don't add this file. */ 1387 if (search->loaded 1388 || ! search->real 1389 || search->filename == (const char *) NULL) 1390 return search; 1391 1392 load_symbols (search, (lang_statement_list_type *) NULL); 1393 1394 return search; 1395} 1396 1397/* Get the symbols for an input file. */ 1398 1399static void 1400load_symbols (entry, place) 1401 lang_input_statement_type *entry; 1402 lang_statement_list_type *place; 1403{ 1404 char **matching; 1405 1406 if (entry->loaded) 1407 return; 1408 1409 ldfile_open_file (entry); 1410 1411 if (! bfd_check_format (entry->the_bfd, bfd_archive) 1412 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching)) 1413 { 1414 bfd_error_type err; 1415 lang_statement_list_type *hold; 1416 1417 err = bfd_get_error (); 1418 if (err == bfd_error_file_ambiguously_recognized) 1419 { 1420 char **p; 1421 1422 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd); 1423 einfo (_("%B: matching formats:"), entry->the_bfd); 1424 for (p = matching; *p != NULL; p++) 1425 einfo (" %s", *p); 1426 einfo ("%F\n"); 1427 } 1428 else if (err != bfd_error_file_not_recognized 1429 || place == NULL) 1430 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd); 1431 1432 bfd_close (entry->the_bfd); 1433 entry->the_bfd = NULL; 1434 1435 /* See if the emulation has some special knowledge. */ 1436 1437 if (ldemul_unrecognized_file (entry)) 1438 return; 1439 1440 /* Try to interpret the file as a linker script. */ 1441 1442 ldfile_open_command_file (entry->filename); 1443 1444 hold = stat_ptr; 1445 stat_ptr = place; 1446 1447 ldfile_assumed_script = true; 1448 parser_input = input_script; 1449 yyparse (); 1450 ldfile_assumed_script = false; 1451 1452 stat_ptr = hold; 1453 1454 return; 1455 } 1456 1457 if (ldemul_recognized_file (entry)) 1458 return; 1459 1460 /* We don't call ldlang_add_file for an archive. Instead, the 1461 add_symbols entry point will call ldlang_add_file, via the 1462 add_archive_element callback, for each element of the archive 1463 which is used. */ 1464 switch (bfd_get_format (entry->the_bfd)) 1465 { 1466 default: 1467 break; 1468 1469 case bfd_object: 1470 ldlang_add_file (entry); 1471 if (trace_files || trace_file_tries) 1472 info_msg ("%I\n", entry); 1473 break; 1474 1475 case bfd_archive: 1476 if (entry->whole_archive) 1477 { 1478 bfd *member = bfd_openr_next_archived_file (entry->the_bfd, 1479 (bfd *) NULL); 1480 while (member != NULL) 1481 { 1482 if (! bfd_check_format (member, bfd_object)) 1483 einfo (_("%F%B: object %B in archive is not object\n"), 1484 entry->the_bfd, member); 1485 if (! ((*link_info.callbacks->add_archive_element) 1486 (&link_info, member, "--whole-archive"))) 1487 abort (); 1488 if (! bfd_link_add_symbols (member, &link_info)) 1489 einfo (_("%F%B: could not read symbols: %E\n"), member); 1490 member = bfd_openr_next_archived_file (entry->the_bfd, 1491 member); 1492 } 1493 1494 entry->loaded = true; 1495 1496 return; 1497 } 1498 } 1499 1500 if (! bfd_link_add_symbols (entry->the_bfd, &link_info)) 1501 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd); 1502 1503 entry->loaded = true; 1504} 1505 1506 1507 1508/* Handle a wild statement. SECTION or FILE or both may be NULL, 1509 indicating that it is a wildcard. Separate lang_input_section 1510 statements are created for each part of the expansion; they are 1511 added after the wild statement S. OUTPUT is the output section. */ 1512 1513static void 1514wild (s, section, file, target, output) 1515 lang_wild_statement_type *s; 1516 const char *section; 1517 const char *file; 1518 const char *target ATTRIBUTE_UNUSED; 1519 lang_output_section_statement_type *output; 1520{ 1521 walk_wild (s, section, file, output_section_callback, (void *) output); 1522 1523 if (section != (char *) NULL 1524 && strcmp (section, "COMMON") == 0 1525 && default_common_section == NULL) 1526 { 1527 /* Remember the section that common is going to in case we later 1528 get something which doesn't know where to put it. */ 1529 default_common_section = output; 1530 } 1531} 1532 1533/* Return true iff target is the sought target. */ 1534static int 1535get_target (target, data) 1536 const bfd_target * target; 1537 void * data; 1538{ 1539 const char * sought = (const char *) data; 1540 1541 return strcmp (target->name, sought) == 0; 1542} 1543 1544/* Like strcpy() but convert to lower case as well. */ 1545static void 1546stricpy (dest, src) 1547 char * dest; 1548 char * src; 1549{ 1550 char c; 1551 1552 while ((c = * src ++) != 0) 1553 { 1554 if (isupper ((unsigned char) c)) 1555 c = tolower (c); 1556 1557 * dest ++ = c; 1558 } 1559 1560 * dest = 0; 1561} 1562 1563/* Remove the first occurance of needle (if any) in haystack 1564 from haystack. */ 1565static void 1566strcut (haystack, needle) 1567 char * haystack; 1568 char * needle; 1569{ 1570 haystack = strstr (haystack, needle); 1571 1572 if (haystack) 1573 { 1574 char * src; 1575 1576 for (src = haystack + strlen (needle); * src;) 1577 * haystack ++ = * src ++; 1578 1579 * haystack = 0; 1580 } 1581} 1582 1583/* Compare two target format name strings. 1584 Return a value indicating how "similar" they are. */ 1585static int 1586name_compare (first, second) 1587 char * first; 1588 char * second; 1589{ 1590 char * copy1; 1591 char * copy2; 1592 int result; 1593 1594 copy1 = xmalloc (strlen (first) + 1); 1595 copy2 = xmalloc (strlen (second) + 1); 1596 1597 /* Convert the names to lower case. */ 1598 stricpy (copy1, first); 1599 stricpy (copy2, second); 1600 1601 /* Remove and endian strings from the name. */ 1602 strcut (copy1, "big"); 1603 strcut (copy1, "little"); 1604 strcut (copy2, "big"); 1605 strcut (copy2, "little"); 1606 1607 /* Return a value based on how many characters match, 1608 starting from the beginning. If both strings are 1609 the same then return 10 * their length. */ 1610 for (result = 0; copy1 [result] == copy2 [result]; result ++) 1611 if (copy1 [result] == 0) 1612 { 1613 result *= 10; 1614 break; 1615 } 1616 1617 free (copy1); 1618 free (copy2); 1619 1620 return result; 1621} 1622 1623/* Set by closest_target_match() below. */ 1624static const bfd_target * winner; 1625 1626/* Scan all the valid bfd targets looking for one that has the endianness 1627 requirement that was specified on the command line, and is the nearest 1628 match to the original output target. */ 1629static int 1630closest_target_match (target, data) 1631 const bfd_target * target; 1632 void * data; 1633{ 1634 const bfd_target * original = (const bfd_target *) data; 1635 1636 if (command_line.endian == ENDIAN_BIG && target->byteorder != BFD_ENDIAN_BIG) 1637 return 0; 1638 1639 if (command_line.endian == ENDIAN_LITTLE && target->byteorder != BFD_ENDIAN_LITTLE) 1640 return 0; 1641 1642 /* Must be the same flavour. */ 1643 if (target->flavour != original->flavour) 1644 return 0; 1645 1646 /* If we have not found a potential winner yet, then record this one. */ 1647 if (winner == NULL) 1648 { 1649 winner = target; 1650 return 0; 1651 } 1652 1653 /* Oh dear, we now have two potential candidates for a successful match. 1654 Compare their names and choose the better one. */ 1655 if (name_compare (target->name, original->name) > name_compare (winner->name, original->name)) 1656 winner = target; 1657 1658 /* Keep on searching until wqe have checked them all. */ 1659 return 0; 1660} 1661 1662/* Return the BFD target format of the first input file. */ 1663static char * 1664get_first_input_target () 1665{ 1666 char * target = NULL; 1667 1668 LANG_FOR_EACH_INPUT_STATEMENT (s) 1669 { 1670 if (s->header.type == lang_input_statement_enum 1671 && s->real) 1672 { 1673 ldfile_open_file (s); 1674 1675 if (s->the_bfd != NULL 1676 && bfd_check_format (s->the_bfd, bfd_object)) 1677 { 1678 target = bfd_get_target (s->the_bfd); 1679 1680 if (target != NULL) 1681 break; 1682 } 1683 } 1684 } 1685 1686 return target; 1687} 1688 1689/* Open the output file. */ 1690 1691static bfd * 1692open_output (name) 1693 const char * name; 1694{ 1695 bfd * output; 1696 1697 /* Has the user told us which output format to use ? */ 1698 if (output_target == (char *) NULL) 1699 { 1700 /* No - has the current target been set to something other than the default ? */ 1701 if (current_target != default_target) 1702 output_target = current_target; 1703 1704 /* No - can we determine the format of the first input file ? */ 1705 else 1706 { 1707 output_target = get_first_input_target (); 1708 1709 /* Failed - use the default output target. */ 1710 if (output_target == NULL) 1711 output_target = default_target; 1712 } 1713 } 1714 1715 /* Has the user requested a particular endianness on the command line ? */ 1716 if (command_line.endian != ENDIAN_UNSET) 1717 { 1718 const bfd_target * target; 1719 enum bfd_endian desired_endian; 1720 1721 /* Get the chosen target. */ 1722 target = bfd_search_for_target (get_target, (void *) output_target); 1723 1724 if (command_line.endian == ENDIAN_BIG) 1725 desired_endian = BFD_ENDIAN_BIG; 1726 else 1727 desired_endian = BFD_ENDIAN_LITTLE; 1728 1729 /* See if the target has the wrong endianness. This should not happen 1730 if the linker script has provided big and little endian alternatives, 1731 but some scrips don't do this. */ 1732 if (target->byteorder != desired_endian) 1733 { 1734 /* If it does, then see if the target provides 1735 an alternative with the correct endianness. */ 1736 if (target->alternative_target != NULL 1737 && (target->alternative_target->byteorder == desired_endian)) 1738 output_target = target->alternative_target->name; 1739 else 1740 { 1741 /* Try to find a target as similar as possible to the default 1742 target, but which has the desired endian characteristic. */ 1743 (void) bfd_search_for_target (closest_target_match, (void *) target); 1744 1745 /* Oh dear - we could not find any targets that satisfy our requirements. */ 1746 if (winner == NULL) 1747 einfo (_("%P: warning: could not find any targets that match endianness requirement\n")); 1748 else 1749 output_target = winner->name; 1750 } 1751 } 1752 } 1753 1754 output = bfd_openw (name, output_target); 1755 1756 if (output == (bfd *) NULL) 1757 { 1758 if (bfd_get_error () == bfd_error_invalid_target) 1759 einfo (_("%P%F: target %s not found\n"), output_target); 1760 1761 einfo (_("%P%F: cannot open output file %s: %E\n"), name); 1762 } 1763 1764 delete_output_file_on_failure = true; 1765 1766 /* output->flags |= D_PAGED;*/ 1767 1768 if (! bfd_set_format (output, bfd_object)) 1769 einfo (_("%P%F:%s: can not make object file: %E\n"), name); 1770 if (! bfd_set_arch_mach (output, 1771 ldfile_output_architecture, 1772 ldfile_output_machine)) 1773 einfo (_("%P%F:%s: can not set architecture: %E\n"), name); 1774 1775 link_info.hash = bfd_link_hash_table_create (output); 1776 if (link_info.hash == (struct bfd_link_hash_table *) NULL) 1777 einfo (_("%P%F: can not create link hash table: %E\n")); 1778 1779 bfd_set_gp_size (output, g_switch_value); 1780 return output; 1781} 1782 1783static void 1784ldlang_open_output (statement) 1785 lang_statement_union_type * statement; 1786{ 1787 switch (statement->header.type) 1788 { 1789 case lang_output_statement_enum: 1790 ASSERT (output_bfd == (bfd *) NULL); 1791 output_bfd = open_output (statement->output_statement.name); 1792 ldemul_set_output_arch (); 1793 if (config.magic_demand_paged && !link_info.relocateable) 1794 output_bfd->flags |= D_PAGED; 1795 else 1796 output_bfd->flags &= ~D_PAGED; 1797 if (config.text_read_only) 1798 output_bfd->flags |= WP_TEXT; 1799 else 1800 output_bfd->flags &= ~WP_TEXT; 1801 if (link_info.traditional_format) 1802 output_bfd->flags |= BFD_TRADITIONAL_FORMAT; 1803 else 1804 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT; 1805 break; 1806 1807 case lang_target_statement_enum: 1808 current_target = statement->target_statement.target; 1809 break; 1810 default: 1811 break; 1812 } 1813} 1814 1815/* Open all the input files. */ 1816 1817static void 1818open_input_bfds (s, force) 1819 lang_statement_union_type *s; 1820 boolean force; 1821{ 1822 for (; s != (lang_statement_union_type *) NULL; s = s->next) 1823 { 1824 switch (s->header.type) 1825 { 1826 case lang_constructors_statement_enum: 1827 open_input_bfds (constructor_list.head, force); 1828 break; 1829 case lang_output_section_statement_enum: 1830 open_input_bfds (s->output_section_statement.children.head, force); 1831 break; 1832 case lang_wild_statement_enum: 1833 /* Maybe we should load the file's symbols */ 1834 if (s->wild_statement.filename 1835 && ! wildcardp (s->wild_statement.filename)) 1836 (void) lookup_name (s->wild_statement.filename); 1837 open_input_bfds (s->wild_statement.children.head, force); 1838 break; 1839 case lang_group_statement_enum: 1840 { 1841 struct bfd_link_hash_entry *undefs; 1842 1843 /* We must continually search the entries in the group 1844 until no new symbols are added to the list of undefined 1845 symbols. */ 1846 1847 do 1848 { 1849 undefs = link_info.hash->undefs_tail; 1850 open_input_bfds (s->group_statement.children.head, true); 1851 } 1852 while (undefs != link_info.hash->undefs_tail); 1853 } 1854 break; 1855 case lang_target_statement_enum: 1856 current_target = s->target_statement.target; 1857 break; 1858 case lang_input_statement_enum: 1859 if (s->input_statement.real) 1860 { 1861 lang_statement_list_type add; 1862 1863 s->input_statement.target = current_target; 1864 1865 /* If we are being called from within a group, and this 1866 is an archive which has already been searched, then 1867 force it to be researched. */ 1868 if (force 1869 && s->input_statement.loaded 1870 && bfd_check_format (s->input_statement.the_bfd, 1871 bfd_archive)) 1872 s->input_statement.loaded = false; 1873 1874 lang_list_init (&add); 1875 1876 load_symbols (&s->input_statement, &add); 1877 1878 if (add.head != NULL) 1879 { 1880 *add.tail = s->next; 1881 s->next = add.head; 1882 } 1883 } 1884 break; 1885 default: 1886 break; 1887 } 1888 } 1889} 1890 1891/* If there are [COMMONS] statements, put a wild one into the bss section */ 1892 1893static void 1894lang_reasonable_defaults () 1895{ 1896#if 0 1897 lang_output_section_statement_lookup (".text"); 1898 lang_output_section_statement_lookup (".data"); 1899 1900 default_common_section = 1901 lang_output_section_statement_lookup (".bss"); 1902 1903 1904 if (placed_commons == false) 1905 { 1906 lang_wild_statement_type *new = 1907 new_stat (lang_wild_statement, 1908 &default_common_section->children); 1909 1910 new->section_name = "COMMON"; 1911 new->filename = (char *) NULL; 1912 lang_list_init (&new->children); 1913 } 1914#endif 1915 1916} 1917 1918/* 1919 Add the supplied name to the symbol table as an undefined reference. 1920 Remove items from the chain as we open input bfds 1921 */ 1922typedef struct ldlang_undef_chain_list 1923{ 1924 struct ldlang_undef_chain_list *next; 1925 char *name; 1926} ldlang_undef_chain_list_type; 1927 1928static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head; 1929 1930void 1931ldlang_add_undef (name) 1932 CONST char *CONST name; 1933{ 1934 ldlang_undef_chain_list_type *new = 1935 ((ldlang_undef_chain_list_type *) 1936 stat_alloc (sizeof (ldlang_undef_chain_list_type))); 1937 1938 new->next = ldlang_undef_chain_list_head; 1939 ldlang_undef_chain_list_head = new; 1940 1941 new->name = buystring (name); 1942} 1943 1944/* Run through the list of undefineds created above and place them 1945 into the linker hash table as undefined symbols belonging to the 1946 script file. 1947*/ 1948static void 1949lang_place_undefineds () 1950{ 1951 ldlang_undef_chain_list_type *ptr; 1952 1953 for (ptr = ldlang_undef_chain_list_head; 1954 ptr != (ldlang_undef_chain_list_type *) NULL; 1955 ptr = ptr->next) 1956 { 1957 struct bfd_link_hash_entry *h; 1958 1959 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true); 1960 if (h == (struct bfd_link_hash_entry *) NULL) 1961 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); 1962 if (h->type == bfd_link_hash_new) 1963 { 1964 h->type = bfd_link_hash_undefined; 1965 h->u.undef.abfd = NULL; 1966 bfd_link_add_undef (link_info.hash, h); 1967 } 1968 } 1969} 1970 1971/* Open input files and attatch to output sections */ 1972static void 1973map_input_to_output_sections (s, target, output_section_statement) 1974 lang_statement_union_type * s; 1975 CONST char *target; 1976 lang_output_section_statement_type * output_section_statement; 1977{ 1978 for (; s != (lang_statement_union_type *) NULL; s = s->next) 1979 { 1980 switch (s->header.type) 1981 { 1982 1983 1984 case lang_wild_statement_enum: 1985 wild (&s->wild_statement, s->wild_statement.section_name, 1986 s->wild_statement.filename, target, 1987 output_section_statement); 1988 1989 break; 1990 case lang_constructors_statement_enum: 1991 map_input_to_output_sections (constructor_list.head, 1992 target, 1993 output_section_statement); 1994 break; 1995 case lang_output_section_statement_enum: 1996 map_input_to_output_sections (s->output_section_statement.children.head, 1997 target, 1998 &s->output_section_statement); 1999 break; 2000 case lang_output_statement_enum: 2001 break; 2002 case lang_target_statement_enum: 2003 target = s->target_statement.target; 2004 break; 2005 case lang_group_statement_enum: 2006 map_input_to_output_sections (s->group_statement.children.head, 2007 target, 2008 output_section_statement); 2009 break; 2010 case lang_fill_statement_enum: 2011 case lang_input_section_enum: 2012 case lang_object_symbols_statement_enum: 2013 case lang_data_statement_enum: 2014 case lang_reloc_statement_enum: 2015 case lang_padding_statement_enum: 2016 case lang_input_statement_enum: 2017 if (output_section_statement != NULL 2018 && output_section_statement->bfd_section == NULL) 2019 init_os (output_section_statement); 2020 break; 2021 case lang_assignment_statement_enum: 2022 if (output_section_statement != NULL 2023 && output_section_statement->bfd_section == NULL) 2024 init_os (output_section_statement); 2025 2026 /* Make sure that any sections mentioned in the assignment 2027 are initialized. */ 2028 exp_init_os (s->assignment_statement.exp); 2029 break; 2030 case lang_afile_asection_pair_statement_enum: 2031 FAIL (); 2032 break; 2033 case lang_address_statement_enum: 2034 /* Mark the specified section with the supplied address */ 2035 { 2036 lang_output_section_statement_type *os = 2037 lang_output_section_statement_lookup 2038 (s->address_statement.section_name); 2039 2040 if (os->bfd_section == NULL) 2041 init_os (os); 2042 os->addr_tree = s->address_statement.address; 2043 } 2044 break; 2045 } 2046 } 2047} 2048 2049static void 2050print_output_section_statement (output_section_statement) 2051 lang_output_section_statement_type * output_section_statement; 2052{ 2053 asection *section = output_section_statement->bfd_section; 2054 int len; 2055 2056 if (output_section_statement != abs_output_section) 2057 { 2058 minfo ("\n%s", output_section_statement->name); 2059 2060 if (section != NULL) 2061 { 2062 print_dot = section->vma; 2063 2064 len = strlen (output_section_statement->name); 2065 if (len >= SECTION_NAME_MAP_LENGTH - 1) 2066 { 2067 print_nl (); 2068 len = 0; 2069 } 2070 while (len < SECTION_NAME_MAP_LENGTH) 2071 { 2072 print_space (); 2073 ++len; 2074 } 2075 2076 minfo ("0x%V %W", section->vma, section->_raw_size); 2077 2078 if (output_section_statement->load_base != NULL) 2079 { 2080 bfd_vma addr; 2081 2082 addr = exp_get_abs_int (output_section_statement->load_base, 0, 2083 "load base", lang_final_phase_enum); 2084 minfo (_(" load address 0x%V"), addr); 2085 } 2086 } 2087 2088 print_nl (); 2089 } 2090 2091 print_statement_list (output_section_statement->children.head, 2092 output_section_statement); 2093} 2094 2095static void 2096print_assignment (assignment, output_section) 2097 lang_assignment_statement_type * assignment; 2098 lang_output_section_statement_type * output_section; 2099{ 2100 int i; 2101 etree_value_type result; 2102 2103 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) 2104 print_space (); 2105 2106 result = exp_fold_tree (assignment->exp->assign.src, output_section, 2107 lang_final_phase_enum, print_dot, &print_dot); 2108 if (result.valid_p) 2109 minfo ("0x%V", result.value + result.section->bfd_section->vma); 2110 else 2111 { 2112 minfo ("*undef* "); 2113#ifdef BFD64 2114 minfo (" "); 2115#endif 2116 } 2117 2118 minfo (" "); 2119 2120 exp_print_tree (assignment->exp); 2121 2122 print_nl (); 2123} 2124 2125static void 2126print_input_statement (statm) 2127 lang_input_statement_type * statm; 2128{ 2129 if (statm->filename != (char *) NULL) 2130 { 2131 fprintf (config.map_file, "LOAD %s\n", statm->filename); 2132 } 2133} 2134 2135/* Print all symbols defined in a particular section. This is called 2136 via bfd_link_hash_traverse. */ 2137 2138static boolean 2139print_one_symbol (hash_entry, ptr) 2140 struct bfd_link_hash_entry *hash_entry; 2141 PTR ptr; 2142{ 2143 asection *sec = (asection *) ptr; 2144 2145 if ((hash_entry->type == bfd_link_hash_defined 2146 || hash_entry->type == bfd_link_hash_defweak) 2147 && sec == hash_entry->u.def.section) 2148 { 2149 int i; 2150 2151 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) 2152 print_space (); 2153 minfo ("0x%V ", 2154 (hash_entry->u.def.value 2155 + hash_entry->u.def.section->output_offset 2156 + hash_entry->u.def.section->output_section->vma)); 2157 2158 minfo (" %T\n", hash_entry->root.string); 2159 } 2160 2161 return true; 2162} 2163 2164/* Print information about an input section to the map file. */ 2165 2166static void 2167print_input_section (in) 2168 lang_input_section_type * in; 2169{ 2170 asection *i = in->section; 2171 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size; 2172 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 2173 ldfile_output_machine); 2174 if (size != 0) 2175 { 2176 print_space (); 2177 2178 minfo ("%s", i->name); 2179 2180 if (i->output_section != NULL) 2181 { 2182 int len; 2183 2184 len = 1 + strlen (i->name); 2185 if (len >= SECTION_NAME_MAP_LENGTH - 1) 2186 { 2187 print_nl (); 2188 len = 0; 2189 } 2190 while (len < SECTION_NAME_MAP_LENGTH) 2191 { 2192 print_space (); 2193 ++len; 2194 } 2195 2196 minfo ("0x%V %W %B\n", 2197 i->output_section->vma + i->output_offset, size / opb, 2198 i->owner); 2199 2200 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size) 2201 { 2202 len = SECTION_NAME_MAP_LENGTH + 3; 2203#ifdef BFD64 2204 len += 16; 2205#else 2206 len += 8; 2207#endif 2208 while (len > 0) 2209 { 2210 print_space (); 2211 --len; 2212 } 2213 2214 minfo (_("%W (size before relaxing)\n"), i->_raw_size); 2215 } 2216 2217 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i); 2218 2219 print_dot = i->output_section->vma + i->output_offset + size / opb; 2220 } 2221 } 2222} 2223 2224static void 2225print_fill_statement (fill) 2226 lang_fill_statement_type * fill; 2227{ 2228 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill); 2229} 2230 2231static void 2232print_data_statement (data) 2233 lang_data_statement_type * data; 2234{ 2235 int i; 2236 bfd_vma addr; 2237 bfd_size_type size; 2238 const char *name; 2239 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 2240 ldfile_output_machine); 2241 2242 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) 2243 print_space (); 2244 2245 addr = data->output_vma; 2246 if (data->output_section != NULL) 2247 addr += data->output_section->vma; 2248 2249 switch (data->type) 2250 { 2251 default: 2252 abort (); 2253 case BYTE: 2254 size = BYTE_SIZE; 2255 name = "BYTE"; 2256 break; 2257 case SHORT: 2258 size = SHORT_SIZE; 2259 name = "SHORT"; 2260 break; 2261 case LONG: 2262 size = LONG_SIZE; 2263 name = "LONG"; 2264 break; 2265 case QUAD: 2266 size = QUAD_SIZE; 2267 name = "QUAD"; 2268 break; 2269 case SQUAD: 2270 size = QUAD_SIZE; 2271 name = "SQUAD"; 2272 break; 2273 } 2274 2275 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value); 2276 2277 if (data->exp->type.node_class != etree_value) 2278 { 2279 print_space (); 2280 exp_print_tree (data->exp); 2281 } 2282 2283 print_nl (); 2284 2285 print_dot = addr + size / opb; 2286 2287} 2288 2289/* Print an address statement. These are generated by options like 2290 -Ttext. */ 2291 2292static void 2293print_address_statement (address) 2294 lang_address_statement_type *address; 2295{ 2296 minfo (_("Address of section %s set to "), address->section_name); 2297 exp_print_tree (address->address); 2298 print_nl (); 2299} 2300 2301/* Print a reloc statement. */ 2302 2303static void 2304print_reloc_statement (reloc) 2305 lang_reloc_statement_type *reloc; 2306{ 2307 int i; 2308 bfd_vma addr; 2309 bfd_size_type size; 2310 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 2311 ldfile_output_machine); 2312 2313 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) 2314 print_space (); 2315 2316 addr = reloc->output_vma; 2317 if (reloc->output_section != NULL) 2318 addr += reloc->output_section->vma; 2319 2320 size = bfd_get_reloc_size (reloc->howto); 2321 2322 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name); 2323 2324 if (reloc->name != NULL) 2325 minfo ("%s+", reloc->name); 2326 else 2327 minfo ("%s+", reloc->section->name); 2328 2329 exp_print_tree (reloc->addend_exp); 2330 2331 print_nl (); 2332 2333 print_dot = addr + size / opb; 2334} 2335 2336static void 2337print_padding_statement (s) 2338 lang_padding_statement_type *s; 2339{ 2340 int len; 2341 bfd_vma addr; 2342 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 2343 ldfile_output_machine); 2344 2345 minfo (" *fill*"); 2346 2347 len = sizeof " *fill*" - 1; 2348 while (len < SECTION_NAME_MAP_LENGTH) 2349 { 2350 print_space (); 2351 ++len; 2352 } 2353 2354 addr = s->output_offset; 2355 if (s->output_section != NULL) 2356 addr += s->output_section->vma; 2357 minfo ("0x%V %W", addr, s->size); 2358 2359 if (s->fill != 0) 2360 minfo (" %u", s->fill); 2361 2362 print_nl (); 2363 2364 print_dot = addr + s->size / opb; 2365} 2366 2367static void 2368print_wild_statement (w, os) 2369 lang_wild_statement_type * w; 2370 lang_output_section_statement_type * os; 2371{ 2372 print_space (); 2373 2374 if (w->filenames_sorted) 2375 minfo ("SORT("); 2376 if (w->exclude_filename_list != NULL) 2377 { 2378 name_list *tmp; 2379 minfo ("EXCLUDE_FILE ( %s", w->exclude_filename_list->name); 2380 for (tmp=w->exclude_filename_list->next; tmp; tmp = tmp->next) 2381 minfo (", %s", tmp->name); 2382 minfo (")"); 2383 } 2384 if (w->filename != NULL) 2385 minfo ("%s", w->filename); 2386 else 2387 minfo ("*"); 2388 if (w->filenames_sorted) 2389 minfo (")"); 2390 2391 minfo ("("); 2392 if (w->sections_sorted) 2393 minfo ("SORT("); 2394 if (w->section_name != NULL) 2395 minfo ("%s", w->section_name); 2396 else 2397 minfo ("*"); 2398 if (w->sections_sorted) 2399 minfo (")"); 2400 minfo (")"); 2401 2402 print_nl (); 2403 2404 print_statement_list (w->children.head, os); 2405} 2406 2407/* Print a group statement. */ 2408 2409static void 2410print_group (s, os) 2411 lang_group_statement_type *s; 2412 lang_output_section_statement_type *os; 2413{ 2414 fprintf (config.map_file, "START GROUP\n"); 2415 print_statement_list (s->children.head, os); 2416 fprintf (config.map_file, "END GROUP\n"); 2417} 2418 2419/* Print the list of statements in S. 2420 This can be called for any statement type. */ 2421 2422static void 2423print_statement_list (s, os) 2424 lang_statement_union_type *s; 2425 lang_output_section_statement_type *os; 2426{ 2427 while (s != NULL) 2428 { 2429 print_statement (s, os); 2430 s = s->next; 2431 } 2432} 2433 2434/* Print the first statement in statement list S. 2435 This can be called for any statement type. */ 2436 2437static void 2438print_statement (s, os) 2439 lang_statement_union_type *s; 2440 lang_output_section_statement_type *os; 2441{ 2442 switch (s->header.type) 2443 { 2444 default: 2445 fprintf (config.map_file, _("Fail with %d\n"), s->header.type); 2446 FAIL (); 2447 break; 2448 case lang_constructors_statement_enum: 2449 if (constructor_list.head != NULL) 2450 { 2451 if (constructors_sorted) 2452 minfo (" SORT (CONSTRUCTORS)\n"); 2453 else 2454 minfo (" CONSTRUCTORS\n"); 2455 print_statement_list (constructor_list.head, os); 2456 } 2457 break; 2458 case lang_wild_statement_enum: 2459 print_wild_statement (&s->wild_statement, os); 2460 break; 2461 case lang_address_statement_enum: 2462 print_address_statement (&s->address_statement); 2463 break; 2464 case lang_object_symbols_statement_enum: 2465 minfo (" CREATE_OBJECT_SYMBOLS\n"); 2466 break; 2467 case lang_fill_statement_enum: 2468 print_fill_statement (&s->fill_statement); 2469 break; 2470 case lang_data_statement_enum: 2471 print_data_statement (&s->data_statement); 2472 break; 2473 case lang_reloc_statement_enum: 2474 print_reloc_statement (&s->reloc_statement); 2475 break; 2476 case lang_input_section_enum: 2477 print_input_section (&s->input_section); 2478 break; 2479 case lang_padding_statement_enum: 2480 print_padding_statement (&s->padding_statement); 2481 break; 2482 case lang_output_section_statement_enum: 2483 print_output_section_statement (&s->output_section_statement); 2484 break; 2485 case lang_assignment_statement_enum: 2486 print_assignment (&s->assignment_statement, os); 2487 break; 2488 case lang_target_statement_enum: 2489 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target); 2490 break; 2491 case lang_output_statement_enum: 2492 minfo ("OUTPUT(%s", s->output_statement.name); 2493 if (output_target != NULL) 2494 minfo (" %s", output_target); 2495 minfo (")\n"); 2496 break; 2497 case lang_input_statement_enum: 2498 print_input_statement (&s->input_statement); 2499 break; 2500 case lang_group_statement_enum: 2501 print_group (&s->group_statement, os); 2502 break; 2503 case lang_afile_asection_pair_statement_enum: 2504 FAIL (); 2505 break; 2506 } 2507} 2508 2509static void 2510print_statements () 2511{ 2512 print_statement_list (statement_list.head, abs_output_section); 2513} 2514 2515/* Print the first N statements in statement list S to STDERR. 2516 If N == 0, nothing is printed. 2517 If N < 0, the entire list is printed. 2518 Intended to be called from GDB. */ 2519 2520void 2521dprint_statement (s, n) 2522 lang_statement_union_type * s; 2523 int n; 2524{ 2525 FILE *map_save = config.map_file; 2526 2527 config.map_file = stderr; 2528 2529 if (n < 0) 2530 print_statement_list (s, abs_output_section); 2531 else 2532 { 2533 while (s && --n >= 0) 2534 { 2535 print_statement (s, abs_output_section); 2536 s = s->next; 2537 } 2538 } 2539 2540 config.map_file = map_save; 2541} 2542 2543static bfd_vma 2544insert_pad (this_ptr, fill, power, output_section_statement, dot) 2545 lang_statement_union_type ** this_ptr; 2546 fill_type fill; 2547 unsigned int power; 2548 asection * output_section_statement; 2549 bfd_vma dot; 2550{ 2551 /* Align this section first to the 2552 input sections requirement, then 2553 to the output section's requirement. 2554 If this alignment is > than any seen before, 2555 then record it too. Perform the alignment by 2556 inserting a magic 'padding' statement. 2557 */ 2558 2559 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 2560 ldfile_output_machine); 2561 unsigned int alignment_needed = align_power (dot, power) - dot; 2562 2563 if (alignment_needed != 0) 2564 { 2565 lang_statement_union_type *new = 2566 ((lang_statement_union_type *) 2567 stat_alloc (sizeof (lang_padding_statement_type))); 2568 2569 /* Link into existing chain */ 2570 new->header.next = *this_ptr; 2571 *this_ptr = new; 2572 new->header.type = lang_padding_statement_enum; 2573 new->padding_statement.output_section = output_section_statement; 2574 new->padding_statement.output_offset = 2575 dot - output_section_statement->vma; 2576 new->padding_statement.fill = fill; 2577 new->padding_statement.size = alignment_needed * opb; 2578 } 2579 2580 2581 /* Remember the most restrictive alignment */ 2582 if (power > output_section_statement->alignment_power) 2583 { 2584 output_section_statement->alignment_power = power; 2585 } 2586 output_section_statement->_raw_size += alignment_needed * opb; 2587 2588 return dot + alignment_needed; 2589} 2590 2591/* Work out how much this section will move the dot point */ 2592static bfd_vma 2593size_input_section (this_ptr, output_section_statement, fill, dot, relax) 2594 lang_statement_union_type ** this_ptr; 2595 lang_output_section_statement_type * output_section_statement; 2596 fill_type fill; 2597 bfd_vma dot; 2598 boolean relax ATTRIBUTE_UNUSED; 2599{ 2600 lang_input_section_type *is = &((*this_ptr)->input_section); 2601 asection *i = is->section; 2602 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 2603 ldfile_output_machine); 2604 2605 if (is->ifile->just_syms_flag == false) 2606 { 2607 if (output_section_statement->subsection_alignment != -1) 2608 i->alignment_power = 2609 output_section_statement->subsection_alignment; 2610 2611 dot = insert_pad (this_ptr, fill, i->alignment_power, 2612 output_section_statement->bfd_section, dot); 2613 2614 /* Remember where in the output section this input section goes */ 2615 2616 i->output_offset = dot - output_section_statement->bfd_section->vma; 2617 2618 /* Mark how big the output section must be to contain this now 2619 */ 2620 if (i->_cooked_size != 0) 2621 dot += i->_cooked_size / opb; 2622 else 2623 dot += i->_raw_size / opb; 2624 output_section_statement->bfd_section->_raw_size = 2625 (dot - output_section_statement->bfd_section->vma) * opb; 2626 } 2627 else 2628 { 2629 i->output_offset = i->vma - output_section_statement->bfd_section->vma; 2630 } 2631 2632 return dot; 2633} 2634 2635#define IGNORE_SECTION(bfd, s) \ 2636 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) != (SEC_ALLOC | SEC_LOAD)) \ 2637 || bfd_section_size (bfd, s) == 0) 2638 2639/* Check to see if any allocated sections overlap with other allocated 2640 sections. This can happen when the linker script specifically specifies 2641 the output section addresses of the two sections. */ 2642static void 2643lang_check_section_addresses () 2644{ 2645 asection * s; 2646 unsigned opb = bfd_octets_per_byte (output_bfd); 2647 2648 /* Scan all sections in the output list. */ 2649 for (s = output_bfd->sections; s != NULL; s = s->next) 2650 { 2651 asection * os; 2652 2653 /* Ignore sections which are not loaded or which have no contents. */ 2654 if (IGNORE_SECTION (output_bfd, s)) 2655 continue; 2656 2657 /* Once we reach section 's' stop our seach. This prevents two 2658 warning messages from being produced, one for 'section A overlaps 2659 section B' and one for 'section B overlaps section A'. */ 2660 for (os = output_bfd->sections; os != s; os = os->next) 2661 { 2662 bfd_vma s_start; 2663 bfd_vma s_end; 2664 bfd_vma os_start; 2665 bfd_vma os_end; 2666 2667 /* Only consider loadable sections with real contents. */ 2668 if (IGNORE_SECTION (output_bfd, os)) 2669 continue; 2670 2671 /* We must check the sections' LMA addresses not their 2672 VMA addresses because overlay sections can have 2673 overlapping VMAs but they must have distinct LMAs. */ 2674 s_start = bfd_section_lma (output_bfd, s); 2675 os_start = bfd_section_lma (output_bfd, os); 2676 s_end = s_start + bfd_section_size (output_bfd, s) / opb - 1; 2677 os_end = os_start + bfd_section_size (output_bfd, os) / opb - 1; 2678 2679 /* Look for an overlap. */ 2680 if ((s_end < os_start) || (s_start > os_end)) 2681 continue; 2682 2683 einfo ( 2684_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"), 2685 s->name, s_start, s_end, os->name, os_start, os_end); 2686 2687 /* Once we have found one overlap for this section, 2688 stop looking for others. */ 2689 break; 2690 } 2691 } 2692} 2693 2694/* This variable indicates whether bfd_relax_section should be called 2695 again. */ 2696 2697static boolean relax_again; 2698 2699/* Make sure the new address is within the region. We explicitly permit the 2700 current address to be at the exact end of the region when the address is 2701 non-zero, in case the region is at the end of addressable memory and the 2702 calculation wraps around. */ 2703 2704static void 2705os_region_check (os, region, tree, base) 2706 lang_output_section_statement_type *os; 2707 struct memory_region_struct *region; 2708 etree_type *tree; 2709 bfd_vma base; 2710{ 2711 if ((region->current < region->origin 2712 || (region->current - region->origin > region->length)) 2713 && ((region->current != region->origin + region->length) 2714 || base == 0)) 2715 { 2716 if (tree != (etree_type *) NULL) 2717 { 2718 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"), 2719 region->current, 2720 os->bfd_section->owner, 2721 os->bfd_section->name, 2722 region->name); 2723 } 2724 else 2725 { 2726 einfo (_("%X%P: region %s is full (%B section %s)\n"), 2727 region->name, 2728 os->bfd_section->owner, 2729 os->bfd_section->name); 2730 } 2731 /* Reset the region pointer. */ 2732 region->current = region->origin; 2733 } 2734} 2735 2736/* Set the sizes for all the output sections. */ 2737 2738bfd_vma 2739lang_size_sections (s, output_section_statement, prev, fill, dot, relax) 2740 lang_statement_union_type * s; 2741 lang_output_section_statement_type * output_section_statement; 2742 lang_statement_union_type ** prev; 2743 fill_type fill; 2744 bfd_vma dot; 2745 boolean relax; 2746{ 2747 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 2748 ldfile_output_machine); 2749 2750 /* Size up the sections from their constituent parts. */ 2751 for (; s != (lang_statement_union_type *) NULL; s = s->next) 2752 { 2753 switch (s->header.type) 2754 { 2755 case lang_output_section_statement_enum: 2756 { 2757 bfd_vma after; 2758 lang_output_section_statement_type *os = &s->output_section_statement; 2759 2760 if (os->bfd_section == NULL) 2761 /* This section was never actually created. */ 2762 break; 2763 2764 /* If this is a COFF shared library section, use the size and 2765 address from the input section. FIXME: This is COFF 2766 specific; it would be cleaner if there were some other way 2767 to do this, but nothing simple comes to mind. */ 2768 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0) 2769 { 2770 asection * input; 2771 2772 if (os->children.head == NULL 2773 || os->children.head->next != NULL 2774 || os->children.head->header.type != lang_input_section_enum) 2775 einfo (_("%P%X: Internal error on COFF shared library section %s\n"), 2776 os->name); 2777 2778 input = os->children.head->input_section.section; 2779 bfd_set_section_vma (os->bfd_section->owner, 2780 os->bfd_section, 2781 bfd_section_vma (input->owner, input)); 2782 os->bfd_section->_raw_size = input->_raw_size; 2783 break; 2784 } 2785 2786 if (bfd_is_abs_section (os->bfd_section)) 2787 { 2788 /* No matter what happens, an abs section starts at zero. */ 2789 ASSERT (os->bfd_section->vma == 0); 2790 } 2791 else 2792 { 2793 if (os->addr_tree == (etree_type *) NULL) 2794 { 2795 /* No address specified for this section, get one 2796 from the region specification. */ 2797 if (os->region == (lang_memory_region_type *) NULL 2798 || (((bfd_get_section_flags (output_bfd, os->bfd_section) 2799 & (SEC_ALLOC | SEC_LOAD)) != 0) 2800 && os->region->name[0] == '*' 2801 && strcmp (os->region->name, "*default*") == 0)) 2802 { 2803 os->region = lang_memory_default (os->bfd_section); 2804 } 2805 2806 /* If a loadable section is using the default memory 2807 region, and some non default memory regions were 2808 defined, issue a warning. */ 2809 if ((bfd_get_section_flags (output_bfd, os->bfd_section) 2810 & (SEC_ALLOC | SEC_LOAD)) != 0 2811 && ! link_info.relocateable 2812 && strcmp (os->region->name, "*default*") == 0 2813 && lang_memory_region_list != NULL 2814 && (strcmp (lang_memory_region_list->name, "*default*") != 0 2815 || lang_memory_region_list->next != NULL)) 2816 einfo (_("%P: warning: no memory region specified for section `%s'\n"), 2817 bfd_get_section_name (output_bfd, os->bfd_section)); 2818 2819 dot = os->region->current; 2820 2821 if (os->section_alignment == -1) 2822 { 2823 bfd_vma olddot; 2824 2825 olddot = dot; 2826 dot = align_power (dot, os->bfd_section->alignment_power); 2827 2828 if (dot != olddot && config.warn_section_align) 2829 einfo (_("%P: warning: changing start of section %s by %u bytes\n"), 2830 os->name, (unsigned int) (dot - olddot)); 2831 } 2832 } 2833 else 2834 { 2835 etree_value_type r; 2836 2837 r = exp_fold_tree (os->addr_tree, 2838 abs_output_section, 2839 lang_allocating_phase_enum, 2840 dot, &dot); 2841 if (r.valid_p == false) 2842 { 2843 einfo (_("%F%S: non constant address expression for section %s\n"), 2844 os->name); 2845 } 2846 dot = r.value + r.section->bfd_section->vma; 2847 } 2848 2849 /* The section starts here. 2850 First, align to what the section needs. */ 2851 2852 if (os->section_alignment != -1) 2853 dot = align_power (dot, os->section_alignment); 2854 2855 bfd_set_section_vma (0, os->bfd_section, dot); 2856 2857 os->bfd_section->output_offset = 0; 2858 } 2859 2860 (void) lang_size_sections (os->children.head, os, &os->children.head, 2861 os->fill, dot, relax); 2862 2863 /* put the section within the requested block size, or align at 2864 the block boundary */ 2865 after = ALIGN_N (os->bfd_section->vma 2866 + os->bfd_section->_raw_size / opb, 2867 /* The coercion here is important, see ld.h. */ 2868 (bfd_vma) os->block_value); 2869 2870 if (bfd_is_abs_section (os->bfd_section)) 2871 ASSERT (after == os->bfd_section->vma); 2872 else 2873 os->bfd_section->_raw_size = 2874 (after - os->bfd_section->vma) * opb; 2875 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb; 2876 os->processed = true; 2877 2878 /* Update dot in the region ? 2879 We only do this if the section is going to be allocated, 2880 since unallocated sections do not contribute to the region's 2881 overall size in memory. 2882 2883 If the SEC_NEVER_LOAD bit is not set, it will affect the 2884 addresses of sections after it. We have to update 2885 dot. */ 2886 if (os->region != (lang_memory_region_type *) NULL 2887 && ((bfd_get_section_flags (output_bfd, os->bfd_section) 2888 & SEC_NEVER_LOAD) == 0 2889 || (bfd_get_section_flags (output_bfd, os->bfd_section) 2890 & (SEC_ALLOC | SEC_LOAD)))) 2891 { 2892 os->region->current = dot; 2893 2894 /* Make sure the new address is within the region. */ 2895 os_region_check (os, os->region, os->addr_tree, 2896 os->bfd_section->vma); 2897 2898 /* if there's no load address specified, use the run region as 2899 the load region */ 2900 if (os->lma_region == NULL && os->load_base == NULL) 2901 os->lma_region = os->region; 2902 2903 if (os->lma_region != NULL) 2904 { 2905 if (os->load_base != NULL) 2906 { 2907 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n")); 2908 } 2909 else 2910 { 2911 /* don't allocate twice */ 2912 if (os->lma_region != os->region) 2913 { 2914 /* set load_base, which will be handled later */ 2915 os->load_base = exp_intop (os->lma_region->current); 2916 os->lma_region->current += 2917 os->bfd_section->_raw_size / opb; 2918 os_region_check (os, os->lma_region, NULL, 2919 os->bfd_section->lma); 2920 } 2921 } 2922 } 2923 } 2924 } 2925 break; 2926 2927 case lang_constructors_statement_enum: 2928 dot = lang_size_sections (constructor_list.head, 2929 output_section_statement, 2930 &s->wild_statement.children.head, 2931 fill, 2932 dot, relax); 2933 break; 2934 2935 case lang_data_statement_enum: 2936 { 2937 unsigned int size = 0; 2938 2939 s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma; 2940 s->data_statement.output_section = 2941 output_section_statement->bfd_section; 2942 2943 switch (s->data_statement.type) 2944 { 2945 default: 2946 abort(); 2947 case QUAD: 2948 case SQUAD: 2949 size = QUAD_SIZE; 2950 break; 2951 case LONG: 2952 size = LONG_SIZE; 2953 break; 2954 case SHORT: 2955 size = SHORT_SIZE; 2956 break; 2957 case BYTE: 2958 size = BYTE_SIZE; 2959 break; 2960 } 2961 if (size < opb) 2962 size = opb; 2963 dot += size / opb; 2964 output_section_statement->bfd_section->_raw_size += size; 2965 /* The output section gets contents, and then we inspect for 2966 any flags set in the input script which override any ALLOC. */ 2967 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS; 2968 if (!(output_section_statement->flags & SEC_NEVER_LOAD)) { 2969 output_section_statement->bfd_section->flags |= SEC_ALLOC | SEC_LOAD; 2970 } 2971 } 2972 break; 2973 2974 case lang_reloc_statement_enum: 2975 { 2976 int size; 2977 2978 s->reloc_statement.output_vma = 2979 dot - output_section_statement->bfd_section->vma; 2980 s->reloc_statement.output_section = 2981 output_section_statement->bfd_section; 2982 size = bfd_get_reloc_size (s->reloc_statement.howto); 2983 dot += size / opb; 2984 output_section_statement->bfd_section->_raw_size += size; 2985 } 2986 break; 2987 2988 case lang_wild_statement_enum: 2989 2990 dot = lang_size_sections (s->wild_statement.children.head, 2991 output_section_statement, 2992 &s->wild_statement.children.head, 2993 2994 fill, dot, relax); 2995 2996 break; 2997 2998 case lang_object_symbols_statement_enum: 2999 link_info.create_object_symbols_section = 3000 output_section_statement->bfd_section; 3001 break; 3002 case lang_output_statement_enum: 3003 case lang_target_statement_enum: 3004 break; 3005 case lang_input_section_enum: 3006 { 3007 asection *i; 3008 3009 i = (*prev)->input_section.section; 3010 if (! relax) 3011 { 3012 if (i->_cooked_size == 0) 3013 i->_cooked_size = i->_raw_size; 3014 } 3015 else 3016 { 3017 boolean again; 3018 3019 if (! bfd_relax_section (i->owner, i, &link_info, &again)) 3020 einfo (_("%P%F: can't relax section: %E\n")); 3021 if (again) 3022 relax_again = true; 3023 } 3024 dot = size_input_section (prev, 3025 output_section_statement, 3026 output_section_statement->fill, 3027 dot, relax); 3028 } 3029 break; 3030 case lang_input_statement_enum: 3031 break; 3032 case lang_fill_statement_enum: 3033 s->fill_statement.output_section = output_section_statement->bfd_section; 3034 3035 fill = s->fill_statement.fill; 3036 break; 3037 case lang_assignment_statement_enum: 3038 { 3039 bfd_vma newdot = dot; 3040 3041 exp_fold_tree (s->assignment_statement.exp, 3042 output_section_statement, 3043 lang_allocating_phase_enum, 3044 dot, 3045 &newdot); 3046 3047 if (newdot != dot) 3048 { 3049 /* The assignment changed dot. Insert a pad. */ 3050 if (output_section_statement == abs_output_section) 3051 { 3052 /* If we don't have an output section, then just adjust 3053 the default memory address. */ 3054 lang_memory_region_lookup ("*default*")->current = newdot; 3055 } 3056 else if (!relax) 3057 { 3058 lang_statement_union_type *new = 3059 ((lang_statement_union_type *) 3060 stat_alloc (sizeof (lang_padding_statement_type))); 3061 3062 /* Link into existing chain. */ 3063 new->header.next = *prev; 3064 *prev = new; 3065 new->header.type = lang_padding_statement_enum; 3066 new->padding_statement.output_section = 3067 output_section_statement->bfd_section; 3068 new->padding_statement.output_offset = 3069 dot - output_section_statement->bfd_section->vma; 3070 new->padding_statement.fill = fill; 3071 new->padding_statement.size = (newdot - dot) * opb; 3072 output_section_statement->bfd_section->_raw_size += 3073 new->padding_statement.size; 3074 } 3075 3076 dot = newdot; 3077 } 3078 } 3079 break; 3080 3081 case lang_padding_statement_enum: 3082 /* If we are relaxing, and this is not the first pass, some 3083 padding statements may have been inserted during previous 3084 passes. We may have to move the padding statement to a new 3085 location if dot has a different value at this point in this 3086 pass than it did at this point in the previous pass. */ 3087 s->padding_statement.output_offset = 3088 dot - output_section_statement->bfd_section->vma; 3089 dot += s->padding_statement.size / opb; 3090 output_section_statement->bfd_section->_raw_size += 3091 s->padding_statement.size; 3092 break; 3093 3094 case lang_group_statement_enum: 3095 dot = lang_size_sections (s->group_statement.children.head, 3096 output_section_statement, 3097 &s->group_statement.children.head, 3098 fill, dot, relax); 3099 break; 3100 3101 default: 3102 FAIL (); 3103 break; 3104 3105 /* This can only get here when relaxing is turned on. */ 3106 3107 case lang_address_statement_enum: 3108 break; 3109 } 3110 prev = &s->header.next; 3111 } 3112 return dot; 3113} 3114 3115bfd_vma 3116lang_do_assignments (s, output_section_statement, fill, dot) 3117 lang_statement_union_type * s; 3118 lang_output_section_statement_type * output_section_statement; 3119 fill_type fill; 3120 bfd_vma dot; 3121{ 3122 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 3123 ldfile_output_machine); 3124 3125 for (; s != (lang_statement_union_type *) NULL; s = s->next) 3126 { 3127 switch (s->header.type) 3128 { 3129 case lang_constructors_statement_enum: 3130 dot = lang_do_assignments (constructor_list.head, 3131 output_section_statement, 3132 fill, 3133 dot); 3134 break; 3135 3136 case lang_output_section_statement_enum: 3137 { 3138 lang_output_section_statement_type *os = 3139 &(s->output_section_statement); 3140 3141 if (os->bfd_section != NULL) 3142 { 3143 dot = os->bfd_section->vma; 3144 (void) lang_do_assignments (os->children.head, os, 3145 os->fill, dot); 3146 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb; 3147 3148 } 3149 if (os->load_base) 3150 { 3151 /* If nothing has been placed into the output section then 3152 it won't have a bfd_section. */ 3153 if (os->bfd_section) 3154 { 3155 os->bfd_section->lma 3156 = exp_get_abs_int(os->load_base, 0,"load base", lang_final_phase_enum); 3157 } 3158 } 3159 } 3160 break; 3161 case lang_wild_statement_enum: 3162 3163 dot = lang_do_assignments (s->wild_statement.children.head, 3164 output_section_statement, 3165 fill, dot); 3166 3167 break; 3168 3169 case lang_object_symbols_statement_enum: 3170 case lang_output_statement_enum: 3171 case lang_target_statement_enum: 3172#if 0 3173 case lang_common_statement_enum: 3174#endif 3175 break; 3176 case lang_data_statement_enum: 3177 { 3178 etree_value_type value; 3179 3180 value = exp_fold_tree (s->data_statement.exp, 3181 abs_output_section, 3182 lang_final_phase_enum, dot, &dot); 3183 s->data_statement.value = value.value; 3184 if (value.valid_p == false) 3185 einfo (_("%F%P: invalid data statement\n")); 3186 } 3187 { 3188 unsigned int size; 3189 switch (s->data_statement.type) 3190 { 3191 default: 3192 abort(); 3193 case QUAD: 3194 case SQUAD: 3195 size = QUAD_SIZE; 3196 break; 3197 case LONG: 3198 size = LONG_SIZE; 3199 break; 3200 case SHORT: 3201 size = SHORT_SIZE; 3202 break; 3203 case BYTE: 3204 size = BYTE_SIZE; 3205 break; 3206 } 3207 if (size < opb) 3208 size = opb; 3209 dot += size / opb; 3210 } 3211 break; 3212 3213 case lang_reloc_statement_enum: 3214 { 3215 etree_value_type value; 3216 3217 value = exp_fold_tree (s->reloc_statement.addend_exp, 3218 abs_output_section, 3219 lang_final_phase_enum, dot, &dot); 3220 s->reloc_statement.addend_value = value.value; 3221 if (value.valid_p == false) 3222 einfo (_("%F%P: invalid reloc statement\n")); 3223 } 3224 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb; 3225 break; 3226 3227 case lang_input_section_enum: 3228 { 3229 asection *in = s->input_section.section; 3230 3231 if (in->_cooked_size != 0) 3232 dot += in->_cooked_size / opb; 3233 else 3234 dot += in->_raw_size / opb; 3235 } 3236 break; 3237 3238 case lang_input_statement_enum: 3239 break; 3240 case lang_fill_statement_enum: 3241 fill = s->fill_statement.fill; 3242 break; 3243 case lang_assignment_statement_enum: 3244 { 3245 exp_fold_tree (s->assignment_statement.exp, 3246 output_section_statement, 3247 lang_final_phase_enum, 3248 dot, 3249 &dot); 3250 } 3251 3252 break; 3253 case lang_padding_statement_enum: 3254 dot += s->padding_statement.size / opb; 3255 break; 3256 3257 case lang_group_statement_enum: 3258 dot = lang_do_assignments (s->group_statement.children.head, 3259 output_section_statement, 3260 fill, dot); 3261 3262 break; 3263 3264 default: 3265 FAIL (); 3266 break; 3267 case lang_address_statement_enum: 3268 break; 3269 } 3270 3271 } 3272 return dot; 3273} 3274 3275/* Fix any .startof. or .sizeof. symbols. When the assemblers see the 3276 operator .startof. (section_name), it produces an undefined symbol 3277 .startof.section_name. Similarly, when it sees 3278 .sizeof. (section_name), it produces an undefined symbol 3279 .sizeof.section_name. For all the output sections, we look for 3280 such symbols, and set them to the correct value. */ 3281 3282static void 3283lang_set_startof () 3284{ 3285 asection *s; 3286 3287 if (link_info.relocateable) 3288 return; 3289 3290 for (s = output_bfd->sections; s != NULL; s = s->next) 3291 { 3292 const char *secname; 3293 char *buf; 3294 struct bfd_link_hash_entry *h; 3295 3296 secname = bfd_get_section_name (output_bfd, s); 3297 buf = xmalloc (10 + strlen (secname)); 3298 3299 sprintf (buf, ".startof.%s", secname); 3300 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true); 3301 if (h != NULL && h->type == bfd_link_hash_undefined) 3302 { 3303 h->type = bfd_link_hash_defined; 3304 h->u.def.value = bfd_get_section_vma (output_bfd, s); 3305 h->u.def.section = bfd_abs_section_ptr; 3306 } 3307 3308 sprintf (buf, ".sizeof.%s", secname); 3309 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true); 3310 if (h != NULL && h->type == bfd_link_hash_undefined) 3311 { 3312 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 3313 ldfile_output_machine); 3314 h->type = bfd_link_hash_defined; 3315 if (s->_cooked_size != 0) 3316 h->u.def.value = s->_cooked_size / opb; 3317 else 3318 h->u.def.value = s->_raw_size / opb; 3319 h->u.def.section = bfd_abs_section_ptr; 3320 } 3321 3322 free (buf); 3323 } 3324} 3325 3326static void 3327lang_finish () 3328{ 3329 struct bfd_link_hash_entry *h; 3330 boolean warn; 3331 3332 if (link_info.relocateable || link_info.shared) 3333 warn = false; 3334 else 3335 warn = true; 3336 3337 if (entry_symbol == (char *) NULL) 3338 { 3339 /* No entry has been specified. Look for start, but don't warn 3340 if we don't find it. */ 3341 entry_symbol = "start"; 3342 warn = false; 3343 } 3344 3345 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true); 3346 if (h != (struct bfd_link_hash_entry *) NULL 3347 && (h->type == bfd_link_hash_defined 3348 || h->type == bfd_link_hash_defweak) 3349 && h->u.def.section->output_section != NULL) 3350 { 3351 bfd_vma val; 3352 3353 val = (h->u.def.value 3354 + bfd_get_section_vma (output_bfd, 3355 h->u.def.section->output_section) 3356 + h->u.def.section->output_offset); 3357 if (! bfd_set_start_address (output_bfd, val)) 3358 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol); 3359 } 3360 else 3361 { 3362 bfd_vma val; 3363 CONST char *send; 3364 3365 /* We couldn't find the entry symbol. Try parsing it as a 3366 number. */ 3367 val = bfd_scan_vma (entry_symbol, &send, 0); 3368 if (*send == '\0') 3369 { 3370 if (! bfd_set_start_address (output_bfd, val)) 3371 einfo (_("%P%F: can't set start address\n")); 3372 } 3373 else 3374 { 3375 asection *ts; 3376 3377 /* Can't find the entry symbol, and it's not a number. Use 3378 the first address in the text section. */ 3379 ts = bfd_get_section_by_name (output_bfd, ".text"); 3380 if (ts != (asection *) NULL) 3381 { 3382 if (warn) 3383 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"), 3384 entry_symbol, bfd_get_section_vma (output_bfd, ts)); 3385 if (! bfd_set_start_address (output_bfd, 3386 bfd_get_section_vma (output_bfd, 3387 ts))) 3388 einfo (_("%P%F: can't set start address\n")); 3389 } 3390 else 3391 { 3392 if (warn) 3393 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"), 3394 entry_symbol); 3395 } 3396 } 3397 } 3398} 3399 3400/* This is a small function used when we want to ignore errors from 3401 BFD. */ 3402 3403static void 3404#ifdef ANSI_PROTOTYPES 3405ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...) 3406#else 3407ignore_bfd_errors (s) 3408 const char *s ATTRIBUTE_UNUSED; 3409#endif 3410{ 3411 /* Don't do anything. */ 3412} 3413 3414/* Check that the architecture of all the input files is compatible 3415 with the output file. Also call the backend to let it do any 3416 other checking that is needed. */ 3417 3418static void 3419lang_check () 3420{ 3421 lang_statement_union_type *file; 3422 bfd *input_bfd; 3423 CONST bfd_arch_info_type *compatible; 3424 3425 for (file = file_chain.head; 3426 file != (lang_statement_union_type *) NULL; 3427 file = file->input_statement.next) 3428 { 3429 input_bfd = file->input_statement.the_bfd; 3430 compatible = bfd_arch_get_compatible (input_bfd, 3431 output_bfd); 3432 if (compatible == NULL) 3433 { 3434 if (command_line.warn_mismatch) 3435 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"), 3436 bfd_printable_name (input_bfd), input_bfd, 3437 bfd_printable_name (output_bfd)); 3438 } 3439 else 3440 { 3441 bfd_error_handler_type pfn = NULL; 3442 3443 /* If we aren't supposed to warn about mismatched input 3444 files, temporarily set the BFD error handler to a 3445 function which will do nothing. We still want to call 3446 bfd_merge_private_bfd_data, since it may set up 3447 information which is needed in the output file. */ 3448 if (! command_line.warn_mismatch) 3449 pfn = bfd_set_error_handler (ignore_bfd_errors); 3450 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd)) 3451 { 3452 if (command_line.warn_mismatch) 3453 einfo (_("%E%X: failed to merge target specific data of file %B\n"), 3454 input_bfd); 3455 } 3456 if (! command_line.warn_mismatch) 3457 bfd_set_error_handler (pfn); 3458 } 3459 } 3460} 3461 3462/* Look through all the global common symbols and attach them to the 3463 correct section. The -sort-common command line switch may be used 3464 to roughly sort the entries by size. */ 3465 3466static void 3467lang_common () 3468{ 3469 if (link_info.relocateable 3470 && ! command_line.force_common_definition) 3471 return; 3472 3473 if (! config.sort_common) 3474 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL); 3475 else 3476 { 3477 int power; 3478 3479 for (power = 4; power >= 0; power--) 3480 bfd_link_hash_traverse (link_info.hash, lang_one_common, 3481 (PTR) &power); 3482 } 3483} 3484 3485/* Place one common symbol in the correct section. */ 3486 3487static boolean 3488lang_one_common (h, info) 3489 struct bfd_link_hash_entry *h; 3490 PTR info; 3491{ 3492 unsigned int power_of_two; 3493 bfd_vma size; 3494 asection *section; 3495 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, 3496 ldfile_output_machine); 3497 3498 if (h->type != bfd_link_hash_common) 3499 return true; 3500 3501 size = h->u.c.size; 3502 power_of_two = h->u.c.p->alignment_power; 3503 3504 if (config.sort_common 3505 && power_of_two < (unsigned int) *(int *) info) 3506 return true; 3507 3508 section = h->u.c.p->section; 3509 3510 /* Increase the size of the section. */ 3511 section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb, 3512 (bfd_size_type) (1 << power_of_two)) * opb; 3513 3514 /* Adjust the alignment if necessary. */ 3515 if (power_of_two > section->alignment_power) 3516 section->alignment_power = power_of_two; 3517 3518 /* Change the symbol from common to defined. */ 3519 h->type = bfd_link_hash_defined; 3520 h->u.def.section = section; 3521 h->u.def.value = section->_cooked_size; 3522 3523 /* Increase the size of the section. */ 3524 section->_cooked_size += size; 3525 3526 /* Make sure the section is allocated in memory, and make sure that 3527 it is no longer a common section. */ 3528 section->flags |= SEC_ALLOC; 3529 section->flags &= ~ SEC_IS_COMMON; 3530 3531 if (config.map_file != NULL) 3532 { 3533 static boolean header_printed; 3534 int len; 3535 char *name; 3536 char buf[50]; 3537 3538 if (! header_printed) 3539 { 3540 minfo (_("\nAllocating common symbols\n")); 3541 minfo (_("Common symbol size file\n\n")); 3542 header_printed = true; 3543 } 3544 3545 name = demangle (h->root.string); 3546 minfo ("%s", name); 3547 len = strlen (name); 3548 free (name); 3549 3550 if (len >= 19) 3551 { 3552 print_nl (); 3553 len = 0; 3554 } 3555 while (len < 20) 3556 { 3557 print_space (); 3558 ++len; 3559 } 3560 3561 minfo ("0x"); 3562 if (size <= 0xffffffff) 3563 sprintf (buf, "%lx", (unsigned long) size); 3564 else 3565 sprintf_vma (buf, size); 3566 minfo ("%s", buf); 3567 len = strlen (buf); 3568 3569 while (len < 16) 3570 { 3571 print_space (); 3572 ++len; 3573 } 3574 3575 minfo ("%B\n", section->owner); 3576 } 3577 3578 return true; 3579} 3580 3581/* 3582run through the input files and ensure that every input 3583section has somewhere to go. If one is found without 3584a destination then create an input request and place it 3585into the statement tree. 3586*/ 3587 3588static void 3589lang_place_orphans () 3590{ 3591 LANG_FOR_EACH_INPUT_STATEMENT (file) 3592 { 3593 asection *s; 3594 3595 for (s = file->the_bfd->sections; 3596 s != (asection *) NULL; 3597 s = s->next) 3598 { 3599 if (s->output_section == (asection *) NULL) 3600 { 3601 /* This section of the file is not attatched, root 3602 around for a sensible place for it to go */ 3603 3604 if (file->just_syms_flag) 3605 { 3606 /* We are only retrieving symbol values from this 3607 file. We want the symbols to act as though the 3608 values in the file are absolute. */ 3609 s->output_section = bfd_abs_section_ptr; 3610 s->output_offset = s->vma; 3611 } 3612 else if (strcmp (s->name, "COMMON") == 0) 3613 { 3614 /* This is a lonely common section which must have 3615 come from an archive. We attach to the section 3616 with the wildcard. */ 3617 if (! link_info.relocateable 3618 || command_line.force_common_definition) 3619 { 3620 if (default_common_section == NULL) 3621 { 3622#if 0 3623 /* This message happens when using the 3624 svr3.ifile linker script, so I have 3625 disabled it. */ 3626 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n")); 3627#endif 3628 default_common_section = 3629 lang_output_section_statement_lookup (".bss"); 3630 3631 } 3632 wild_doit (&default_common_section->children, s, 3633 default_common_section, file); 3634 } 3635 } 3636 else if (ldemul_place_orphan (file, s)) 3637 ; 3638 else 3639 { 3640 lang_output_section_statement_type *os = 3641 lang_output_section_statement_lookup (s->name); 3642 3643 wild_doit (&os->children, s, os, file); 3644 } 3645 } 3646 } 3647 } 3648} 3649 3650 3651void 3652lang_set_flags (ptr, flags, invert) 3653 lang_memory_region_type *ptr; 3654 CONST char *flags; 3655 int invert; 3656{ 3657 flagword *ptr_flags; 3658 3659 ptr_flags = invert ? &ptr->not_flags : &ptr->flags; 3660 while (*flags) 3661 { 3662 switch (*flags) 3663 { 3664 case 'A': case 'a': 3665 *ptr_flags |= SEC_ALLOC; 3666 break; 3667 3668 case 'R': case 'r': 3669 *ptr_flags |= SEC_READONLY; 3670 break; 3671 3672 case 'W': case 'w': 3673 *ptr_flags |= SEC_DATA; 3674 break; 3675 3676 case 'X': case 'x': 3677 *ptr_flags |= SEC_CODE; 3678 break; 3679 3680 case 'L': case 'l': 3681 case 'I': case 'i': 3682 *ptr_flags |= SEC_LOAD; 3683 break; 3684 3685 default: 3686 einfo (_("%P%F: invalid syntax in flags\n")); 3687 break; 3688 } 3689 flags++; 3690 } 3691} 3692 3693/* Call a function on each input file. This function will be called 3694 on an archive, but not on the elements. */ 3695 3696void 3697lang_for_each_input_file (func) 3698 void (*func) PARAMS ((lang_input_statement_type *)); 3699{ 3700 lang_input_statement_type *f; 3701 3702 for (f = (lang_input_statement_type *) input_file_chain.head; 3703 f != NULL; 3704 f = (lang_input_statement_type *) f->next_real_file) 3705 func (f); 3706} 3707 3708/* Call a function on each file. The function will be called on all 3709 the elements of an archive which are included in the link, but will 3710 not be called on the archive file itself. */ 3711 3712void 3713lang_for_each_file (func) 3714 void (*func) PARAMS ((lang_input_statement_type *)); 3715{ 3716 LANG_FOR_EACH_INPUT_STATEMENT (f) 3717 { 3718 func (f); 3719 } 3720} 3721 3722#if 0 3723 3724/* Not used. */ 3725 3726void 3727lang_for_each_input_section (func) 3728 void (*func) PARAMS ((bfd * ab, asection * as)); 3729{ 3730 LANG_FOR_EACH_INPUT_STATEMENT (f) 3731 { 3732 asection * s; 3733 3734 for (s = f->the_bfd->sections; 3735 s != (asection *) NULL; 3736 s = s->next) 3737 { 3738 func (f->the_bfd, s); 3739 } 3740 } 3741} 3742 3743#endif 3744 3745void 3746ldlang_add_file (entry) 3747 lang_input_statement_type * entry; 3748{ 3749 bfd **pp; 3750 3751 lang_statement_append (&file_chain, 3752 (lang_statement_union_type *) entry, 3753 &entry->next); 3754 3755 /* The BFD linker needs to have a list of all input BFDs involved in 3756 a link. */ 3757 ASSERT (entry->the_bfd->link_next == (bfd *) NULL); 3758 ASSERT (entry->the_bfd != output_bfd); 3759 for (pp = &link_info.input_bfds; 3760 *pp != (bfd *) NULL; 3761 pp = &(*pp)->link_next) 3762 ; 3763 *pp = entry->the_bfd; 3764 entry->the_bfd->usrdata = (PTR) entry; 3765 bfd_set_gp_size (entry->the_bfd, g_switch_value); 3766 3767 /* Look through the sections and check for any which should not be 3768 included in the link. We need to do this now, so that we can 3769 notice when the backend linker tries to report multiple 3770 definition errors for symbols which are in sections we aren't 3771 going to link. FIXME: It might be better to entirely ignore 3772 symbols which are defined in sections which are going to be 3773 discarded. This would require modifying the backend linker for 3774 each backend which might set the SEC_LINK_ONCE flag. If we do 3775 this, we should probably handle SEC_EXCLUDE in the same way. */ 3776 3777 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry); 3778} 3779 3780void 3781lang_add_output (name, from_script) 3782 CONST char *name; 3783 int from_script; 3784{ 3785 /* Make -o on command line override OUTPUT in script. */ 3786 if (had_output_filename == false || !from_script) 3787 { 3788 output_filename = name; 3789 had_output_filename = true; 3790 } 3791} 3792 3793 3794static lang_output_section_statement_type *current_section; 3795 3796static int 3797topower (x) 3798 int x; 3799{ 3800 unsigned int i = 1; 3801 int l; 3802 3803 if (x < 0) 3804 return -1; 3805 3806 for (l = 0; l < 32; l++) 3807 { 3808 if (i >= (unsigned int) x) 3809 return l; 3810 i <<= 1; 3811 } 3812 3813 return 0; 3814} 3815 3816void 3817lang_enter_output_section_statement (output_section_statement_name, 3818 address_exp, sectype, block_value, 3819 align, subalign, ebase) 3820 const char *output_section_statement_name; 3821 etree_type * address_exp; 3822 enum section_type sectype; 3823 bfd_vma block_value; 3824 etree_type *align; 3825 etree_type *subalign; 3826 etree_type *ebase; 3827{ 3828 lang_output_section_statement_type *os; 3829 3830 current_section = 3831 os = 3832 lang_output_section_statement_lookup (output_section_statement_name); 3833 3834 3835 3836 /* Add this statement to tree */ 3837 /* add_statement(lang_output_section_statement_enum, 3838 output_section_statement);*/ 3839 /* Make next things chain into subchain of this */ 3840 3841 if (os->addr_tree == 3842 (etree_type *) NULL) 3843 { 3844 os->addr_tree = 3845 address_exp; 3846 } 3847 os->sectype = sectype; 3848 if (sectype != noload_section) 3849 os->flags = SEC_NO_FLAGS; 3850 else 3851 os->flags = SEC_NEVER_LOAD; 3852 os->block_value = block_value ? block_value : 1; 3853 stat_ptr = &os->children; 3854 3855 os->subsection_alignment = topower( 3856 exp_get_value_int(subalign, -1, 3857 "subsection alignment", 3858 0)); 3859 os->section_alignment = topower( 3860 exp_get_value_int(align, -1, 3861 "section alignment", 0)); 3862 3863 os->load_base = ebase; 3864} 3865 3866 3867void 3868lang_final () 3869{ 3870 lang_output_statement_type *new = 3871 new_stat (lang_output_statement, stat_ptr); 3872 3873 new->name = output_filename; 3874} 3875 3876/* Reset the current counters in the regions */ 3877static void 3878reset_memory_regions () 3879{ 3880 lang_memory_region_type *p = lang_memory_region_list; 3881 3882 for (p = lang_memory_region_list; 3883 p != (lang_memory_region_type *) NULL; 3884 p = p->next) 3885 { 3886 p->old_length = (bfd_size_type) (p->current - p->origin); 3887 p->current = p->origin; 3888 } 3889} 3890 3891/* Expand a wild statement for a particular FILE, marking its sections KEEP 3892 as needed. SECTION may be NULL, in which case it is a wild card. */ 3893 3894static void 3895gc_section_callback (ptr, section, file, data) 3896 lang_wild_statement_type *ptr; 3897 asection *section; 3898 lang_input_statement_type *file ATTRIBUTE_UNUSED; 3899 void *data ATTRIBUTE_UNUSED; 3900{ 3901 /* If the wild pattern was marked KEEP, the member sections 3902 should be as well. */ 3903 if (ptr->keep_sections) 3904 section->flags |= SEC_KEEP; 3905} 3906 3907/* Handle a wild statement, marking it against GC. SECTION or FILE or both 3908 may be NULL, indicating that it is a wildcard. */ 3909 3910static void 3911lang_gc_wild (s, section, file) 3912 lang_wild_statement_type *s; 3913 const char *section; 3914 const char *file; 3915{ 3916 walk_wild (s, section, file, gc_section_callback, NULL); 3917} 3918 3919/* Iterate over sections marking them against GC. */ 3920 3921static void 3922lang_gc_sections_1 (s) 3923 lang_statement_union_type * s; 3924{ 3925 for (; s != (lang_statement_union_type *) NULL; s = s->next) 3926 { 3927 switch (s->header.type) 3928 { 3929 case lang_wild_statement_enum: 3930 lang_gc_wild (&s->wild_statement, 3931 s->wild_statement.section_name, 3932 s->wild_statement.filename); 3933 break; 3934 case lang_constructors_statement_enum: 3935 lang_gc_sections_1 (constructor_list.head); 3936 break; 3937 case lang_output_section_statement_enum: 3938 lang_gc_sections_1 (s->output_section_statement.children.head); 3939 break; 3940 case lang_group_statement_enum: 3941 lang_gc_sections_1 (s->group_statement.children.head); 3942 break; 3943 default: 3944 break; 3945 } 3946 } 3947} 3948 3949static void 3950lang_gc_sections () 3951{ 3952 struct bfd_link_hash_entry *h; 3953 ldlang_undef_chain_list_type *ulist, fake_list_start; 3954 3955 /* Keep all sections so marked in the link script. */ 3956 3957 lang_gc_sections_1 (statement_list.head); 3958 3959 /* Keep all sections containing symbols undefined on the command-line. 3960 Handle the entry symbol at the same time. */ 3961 3962 if (entry_symbol != NULL) 3963 { 3964 fake_list_start.next = ldlang_undef_chain_list_head; 3965 fake_list_start.name = (char *) entry_symbol; 3966 ulist = &fake_list_start; 3967 } 3968 else 3969 ulist = ldlang_undef_chain_list_head; 3970 3971 for (; ulist; ulist = ulist->next) 3972 { 3973 h = bfd_link_hash_lookup (link_info.hash, ulist->name, 3974 false, false, false); 3975 3976 if (h != (struct bfd_link_hash_entry *) NULL 3977 && (h->type == bfd_link_hash_defined 3978 || h->type == bfd_link_hash_defweak) 3979 && ! bfd_is_abs_section (h->u.def.section)) 3980 { 3981 h->u.def.section->flags |= SEC_KEEP; 3982 } 3983 } 3984 3985 bfd_gc_sections (output_bfd, &link_info); 3986} 3987 3988void 3989lang_process () 3990{ 3991 lang_reasonable_defaults (); 3992 current_target = default_target; 3993 3994 lang_for_each_statement (ldlang_open_output); /* Open the output file */ 3995 3996 ldemul_create_output_section_statements (); 3997 3998 /* Add to the hash table all undefineds on the command line */ 3999 lang_place_undefineds (); 4000 4001 already_linked_table_init (); 4002 4003 /* Create a bfd for each input file */ 4004 current_target = default_target; 4005 open_input_bfds (statement_list.head, false); 4006 4007 ldemul_after_open (); 4008 4009 already_linked_table_free (); 4010 4011 /* Make sure that we're not mixing architectures. We call this 4012 after all the input files have been opened, but before we do any 4013 other processing, so that any operations merge_private_bfd_data 4014 does on the output file will be known during the rest of the 4015 link. */ 4016 lang_check (); 4017 4018 /* Handle .exports instead of a version script if we're told to do so. */ 4019 if (command_line.version_exports_section) 4020 lang_do_version_exports_section (); 4021 4022 /* Build all sets based on the information gathered from the input 4023 files. */ 4024 ldctor_build_sets (); 4025 4026 /* Remove unreferenced sections if asked to. */ 4027 if (command_line.gc_sections) 4028 lang_gc_sections (); 4029 4030 /* Size up the common data */ 4031 lang_common (); 4032 4033 /* Run through the contours of the script and attach input sections 4034 to the correct output sections 4035 */ 4036 map_input_to_output_sections (statement_list.head, (char *) NULL, 4037 (lang_output_section_statement_type *) NULL); 4038 4039 4040 /* Find any sections not attached explicitly and handle them */ 4041 lang_place_orphans (); 4042 4043 ldemul_before_allocation (); 4044 4045 /* We must record the program headers before we try to fix the 4046 section positions, since they will affect SIZEOF_HEADERS. */ 4047 lang_record_phdrs (); 4048 4049 /* Now run around and relax if we can */ 4050 if (command_line.relax) 4051 { 4052 /* First time round is a trial run to get the 'worst case' 4053 addresses of the objects if there was no relaxing. */ 4054 lang_size_sections (statement_list.head, 4055 abs_output_section, 4056 &(statement_list.head), 0, (bfd_vma) 0, false); 4057 4058 /* Keep relaxing until bfd_relax_section gives up. */ 4059 do 4060 { 4061 reset_memory_regions (); 4062 4063 relax_again = false; 4064 4065 /* Note: pe-dll.c does something like this also. If you find 4066 you need to change this code, you probably need to change 4067 pe-dll.c also. DJ */ 4068 4069 /* Do all the assignments with our current guesses as to 4070 section sizes. */ 4071 lang_do_assignments (statement_list.head, 4072 abs_output_section, 4073 (fill_type) 0, (bfd_vma) 0); 4074 4075 /* Perform another relax pass - this time we know where the 4076 globals are, so can make better guess. */ 4077 lang_size_sections (statement_list.head, 4078 abs_output_section, 4079 &(statement_list.head), 0, (bfd_vma) 0, true); 4080 } 4081 while (relax_again); 4082 } 4083 else 4084 { 4085 /* Size up the sections. */ 4086 lang_size_sections (statement_list.head, 4087 abs_output_section, 4088 &(statement_list.head), 0, (bfd_vma) 0, false); 4089 } 4090 4091 /* See if anything special should be done now we know how big 4092 everything is. */ 4093 ldemul_after_allocation (); 4094 4095 /* Fix any .startof. or .sizeof. symbols. */ 4096 lang_set_startof (); 4097 4098 /* Do all the assignments, now that we know the final restingplaces 4099 of all the symbols */ 4100 4101 lang_do_assignments (statement_list.head, 4102 abs_output_section, 4103 (fill_type) 0, (bfd_vma) 0); 4104 4105 /* Make sure that the section addresses make sense. */ 4106 if (! link_info.relocateable 4107 && command_line.check_section_addresses) 4108 lang_check_section_addresses (); 4109 4110 /* Final stuffs */ 4111 4112 ldemul_finish (); 4113 lang_finish (); 4114} 4115 4116/* EXPORTED TO YACC */ 4117 4118void 4119lang_add_wild (section_name, sections_sorted, filename, filenames_sorted, 4120 keep_sections, exclude_filename_list) 4121 const char *const section_name; 4122 boolean sections_sorted; 4123 const char *const filename; 4124 boolean filenames_sorted; 4125 boolean keep_sections; 4126 struct name_list *exclude_filename_list; 4127{ 4128 lang_wild_statement_type *new = new_stat (lang_wild_statement, 4129 stat_ptr); 4130 4131 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0) 4132 { 4133 placed_commons = true; 4134 } 4135 if (filename != NULL && ! wildcardp (filename)) 4136 { 4137 lang_has_input_file = true; 4138 } 4139 new->section_name = section_name; 4140 new->sections_sorted = sections_sorted; 4141 new->filename = filename; 4142 new->filenames_sorted = filenames_sorted; 4143 new->keep_sections = keep_sections; 4144 new->exclude_filename_list = exclude_filename_list; 4145 lang_list_init (&new->children); 4146} 4147 4148void 4149lang_section_start (name, address) 4150 CONST char *name; 4151 etree_type * address; 4152{ 4153 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr); 4154 4155 ad->section_name = name; 4156 ad->address = address; 4157} 4158 4159/* Set the start symbol to NAME. CMDLINE is nonzero if this is called 4160 because of a -e argument on the command line, or zero if this is 4161 called by ENTRY in a linker script. Command line arguments take 4162 precedence. */ 4163 4164void 4165lang_add_entry (name, cmdline) 4166 CONST char *name; 4167 boolean cmdline; 4168{ 4169 if (entry_symbol == NULL 4170 || cmdline 4171 || ! entry_from_cmdline) 4172 { 4173 entry_symbol = name; 4174 entry_from_cmdline = cmdline; 4175 } 4176} 4177 4178void 4179lang_add_target (name) 4180 CONST char *name; 4181{ 4182 lang_target_statement_type *new = new_stat (lang_target_statement, 4183 stat_ptr); 4184 4185 new->target = name; 4186 4187} 4188 4189void 4190lang_add_map (name) 4191 CONST char *name; 4192{ 4193 while (*name) 4194 { 4195 switch (*name) 4196 { 4197 case 'F': 4198 map_option_f = true; 4199 break; 4200 } 4201 name++; 4202 } 4203} 4204 4205void 4206lang_add_fill (exp) 4207 int exp; 4208{ 4209 lang_fill_statement_type *new = new_stat (lang_fill_statement, 4210 stat_ptr); 4211 4212 new->fill = exp; 4213} 4214 4215void 4216lang_add_data (type, exp) 4217 int type; 4218 union etree_union *exp; 4219{ 4220 4221 lang_data_statement_type *new = new_stat (lang_data_statement, 4222 stat_ptr); 4223 4224 new->exp = exp; 4225 new->type = type; 4226 4227} 4228 4229/* Create a new reloc statement. RELOC is the BFD relocation type to 4230 generate. HOWTO is the corresponding howto structure (we could 4231 look this up, but the caller has already done so). SECTION is the 4232 section to generate a reloc against, or NAME is the name of the 4233 symbol to generate a reloc against. Exactly one of SECTION and 4234 NAME must be NULL. ADDEND is an expression for the addend. */ 4235 4236void 4237lang_add_reloc (reloc, howto, section, name, addend) 4238 bfd_reloc_code_real_type reloc; 4239 reloc_howto_type *howto; 4240 asection *section; 4241 const char *name; 4242 union etree_union *addend; 4243{ 4244 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr); 4245 4246 p->reloc = reloc; 4247 p->howto = howto; 4248 p->section = section; 4249 p->name = name; 4250 p->addend_exp = addend; 4251 4252 p->addend_value = 0; 4253 p->output_section = NULL; 4254 p->output_vma = 0; 4255} 4256 4257lang_assignment_statement_type * 4258lang_add_assignment (exp) 4259 etree_type * exp; 4260{ 4261 lang_assignment_statement_type *new = new_stat (lang_assignment_statement, 4262 stat_ptr); 4263 4264 new->exp = exp; 4265 return new; 4266} 4267 4268void 4269lang_add_attribute (attribute) 4270 enum statement_enum attribute; 4271{ 4272 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr); 4273} 4274 4275void 4276lang_startup (name) 4277 CONST char *name; 4278{ 4279 if (startup_file != (char *) NULL) 4280 { 4281 einfo (_("%P%Fmultiple STARTUP files\n")); 4282 } 4283 first_file->filename = name; 4284 first_file->local_sym_name = name; 4285 first_file->real = true; 4286 4287 startup_file = name; 4288} 4289 4290void 4291lang_float (maybe) 4292 boolean maybe; 4293{ 4294 lang_float_flag = maybe; 4295} 4296 4297void 4298lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec) 4299 bfd_vma fill; 4300 const char *memspec; 4301 struct lang_output_section_phdr_list *phdrs; 4302 const char *lma_memspec; 4303{ 4304 current_section->fill = fill; 4305 current_section->region = lang_memory_region_lookup (memspec); 4306 if (strcmp (lma_memspec, "*default*") != 0) 4307 { 4308 current_section->lma_region = lang_memory_region_lookup (lma_memspec); 4309 /* if no runtime region has been given, but the load region has been, 4310 use the load region */ 4311 if (strcmp (memspec, "*default*") == 0) 4312 current_section->region = lang_memory_region_lookup (lma_memspec); 4313 } 4314 current_section->phdrs = phdrs; 4315 stat_ptr = &statement_list; 4316} 4317 4318/* 4319 Create an absolute symbol with the given name with the value of the 4320 address of first byte of the section named. 4321 4322 If the symbol already exists, then do nothing. 4323*/ 4324void 4325lang_abs_symbol_at_beginning_of (secname, name) 4326 const char *secname; 4327 const char *name; 4328{ 4329 struct bfd_link_hash_entry *h; 4330 4331 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true); 4332 if (h == (struct bfd_link_hash_entry *) NULL) 4333 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); 4334 4335 if (h->type == bfd_link_hash_new 4336 || h->type == bfd_link_hash_undefined) 4337 { 4338 asection *sec; 4339 4340 h->type = bfd_link_hash_defined; 4341 4342 sec = bfd_get_section_by_name (output_bfd, secname); 4343 if (sec == (asection *) NULL) 4344 h->u.def.value = 0; 4345 else 4346 h->u.def.value = bfd_get_section_vma (output_bfd, sec); 4347 4348 h->u.def.section = bfd_abs_section_ptr; 4349 } 4350} 4351 4352/* 4353 Create an absolute symbol with the given name with the value of the 4354 address of the first byte after the end of the section named. 4355 4356 If the symbol already exists, then do nothing. 4357*/ 4358void 4359lang_abs_symbol_at_end_of (secname, name) 4360 const char *secname; 4361 const char *name; 4362{ 4363 struct bfd_link_hash_entry *h; 4364 4365 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true); 4366 if (h == (struct bfd_link_hash_entry *) NULL) 4367 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); 4368 4369 if (h->type == bfd_link_hash_new 4370 || h->type == bfd_link_hash_undefined) 4371 { 4372 asection *sec; 4373 4374 h->type = bfd_link_hash_defined; 4375 4376 sec = bfd_get_section_by_name (output_bfd, secname); 4377 if (sec == (asection *) NULL) 4378 h->u.def.value = 0; 4379 else 4380 h->u.def.value = (bfd_get_section_vma (output_bfd, sec) 4381 + bfd_section_size (output_bfd, sec) / 4382 bfd_octets_per_byte (output_bfd)); 4383 4384 h->u.def.section = bfd_abs_section_ptr; 4385 } 4386} 4387 4388void 4389lang_statement_append (list, element, field) 4390 lang_statement_list_type * list; 4391 lang_statement_union_type * element; 4392 lang_statement_union_type ** field; 4393{ 4394 *(list->tail) = element; 4395 list->tail = field; 4396} 4397 4398/* Set the output format type. -oformat overrides scripts. */ 4399 4400void 4401lang_add_output_format (format, big, little, from_script) 4402 const char *format; 4403 const char *big; 4404 const char *little; 4405 int from_script; 4406{ 4407 if (output_target == NULL || !from_script) 4408 { 4409 if (command_line.endian == ENDIAN_BIG 4410 && big != NULL) 4411 format = big; 4412 else if (command_line.endian == ENDIAN_LITTLE 4413 && little != NULL) 4414 format = little; 4415 4416 output_target = format; 4417 } 4418} 4419 4420/* Enter a group. This creates a new lang_group_statement, and sets 4421 stat_ptr to build new statements within the group. */ 4422 4423void 4424lang_enter_group () 4425{ 4426 lang_group_statement_type *g; 4427 4428 g = new_stat (lang_group_statement, stat_ptr); 4429 lang_list_init (&g->children); 4430 stat_ptr = &g->children; 4431} 4432 4433/* Leave a group. This just resets stat_ptr to start writing to the 4434 regular list of statements again. Note that this will not work if 4435 groups can occur inside anything else which can adjust stat_ptr, 4436 but currently they can't. */ 4437 4438void 4439lang_leave_group () 4440{ 4441 stat_ptr = &statement_list; 4442} 4443 4444/* Add a new program header. This is called for each entry in a PHDRS 4445 command in a linker script. */ 4446 4447void 4448lang_new_phdr (name, type, filehdr, phdrs, at, flags) 4449 const char *name; 4450 etree_type *type; 4451 boolean filehdr; 4452 boolean phdrs; 4453 etree_type *at; 4454 etree_type *flags; 4455{ 4456 struct lang_phdr *n, **pp; 4457 4458 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr)); 4459 n->next = NULL; 4460 n->name = name; 4461 n->type = exp_get_value_int (type, 0, "program header type", 4462 lang_final_phase_enum); 4463 n->filehdr = filehdr; 4464 n->phdrs = phdrs; 4465 n->at = at; 4466 n->flags = flags; 4467 4468 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next) 4469 ; 4470 *pp = n; 4471} 4472 4473/* Record the program header information in the output BFD. FIXME: We 4474 should not be calling an ELF specific function here. */ 4475 4476static void 4477lang_record_phdrs () 4478{ 4479 unsigned int alc; 4480 asection **secs; 4481 struct lang_output_section_phdr_list *last; 4482 struct lang_phdr *l; 4483 lang_statement_union_type *u; 4484 4485 alc = 10; 4486 secs = (asection **) xmalloc (alc * sizeof (asection *)); 4487 last = NULL; 4488 for (l = lang_phdr_list; l != NULL; l = l->next) 4489 { 4490 unsigned int c; 4491 flagword flags; 4492 bfd_vma at; 4493 4494 c = 0; 4495 for (u = lang_output_section_statement.head; 4496 u != NULL; 4497 u = u->output_section_statement.next) 4498 { 4499 lang_output_section_statement_type *os; 4500 struct lang_output_section_phdr_list *pl; 4501 4502 os = &u->output_section_statement; 4503 4504 pl = os->phdrs; 4505 if (pl != NULL) 4506 last = pl; 4507 else 4508 { 4509 if (os->sectype == noload_section 4510 || os->bfd_section == NULL 4511 || (os->bfd_section->flags & SEC_ALLOC) == 0) 4512 continue; 4513 pl = last; 4514 } 4515 4516 if (os->bfd_section == NULL) 4517 continue; 4518 4519 for (; pl != NULL; pl = pl->next) 4520 { 4521 if (strcmp (pl->name, l->name) == 0) 4522 { 4523 if (c >= alc) 4524 { 4525 alc *= 2; 4526 secs = ((asection **) 4527 xrealloc (secs, alc * sizeof (asection *))); 4528 } 4529 secs[c] = os->bfd_section; 4530 ++c; 4531 pl->used = true; 4532 } 4533 } 4534 } 4535 4536 if (l->flags == NULL) 4537 flags = 0; 4538 else 4539 flags = exp_get_vma (l->flags, 0, "phdr flags", 4540 lang_final_phase_enum); 4541 4542 if (l->at == NULL) 4543 at = 0; 4544 else 4545 at = exp_get_vma (l->at, 0, "phdr load address", 4546 lang_final_phase_enum); 4547 4548 if (! bfd_record_phdr (output_bfd, l->type, 4549 l->flags == NULL ? false : true, 4550 flags, 4551 l->at == NULL ? false : true, 4552 at, l->filehdr, l->phdrs, c, secs)) 4553 einfo (_("%F%P: bfd_record_phdr failed: %E\n")); 4554 } 4555 4556 free (secs); 4557 4558 /* Make sure all the phdr assignments succeeded. */ 4559 for (u = lang_output_section_statement.head; 4560 u != NULL; 4561 u = u->output_section_statement.next) 4562 { 4563 struct lang_output_section_phdr_list *pl; 4564 4565 if (u->output_section_statement.bfd_section == NULL) 4566 continue; 4567 4568 for (pl = u->output_section_statement.phdrs; 4569 pl != NULL; 4570 pl = pl->next) 4571 if (! pl->used && strcmp (pl->name, "NONE") != 0) 4572 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"), 4573 u->output_section_statement.name, pl->name); 4574 } 4575} 4576 4577/* Record a list of sections which may not be cross referenced. */ 4578 4579void 4580lang_add_nocrossref (l) 4581 struct lang_nocrossref *l; 4582{ 4583 struct lang_nocrossrefs *n; 4584 4585 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n); 4586 n->next = nocrossref_list; 4587 n->list = l; 4588 nocrossref_list = n; 4589 4590 /* Set notice_all so that we get informed about all symbols. */ 4591 link_info.notice_all = true; 4592} 4593 4594/* Overlay handling. We handle overlays with some static variables. */ 4595 4596/* The overlay virtual address. */ 4597static etree_type *overlay_vma; 4598 4599/* The overlay load address. */ 4600static etree_type *overlay_lma; 4601 4602/* Whether nocrossrefs is set for this overlay. */ 4603static int overlay_nocrossrefs; 4604 4605/* An expression for the maximum section size seen so far. */ 4606static etree_type *overlay_max; 4607 4608/* A list of all the sections in this overlay. */ 4609 4610struct overlay_list 4611{ 4612 struct overlay_list *next; 4613 lang_output_section_statement_type *os; 4614}; 4615 4616static struct overlay_list *overlay_list; 4617 4618/* Start handling an overlay. */ 4619 4620void 4621lang_enter_overlay (vma_expr, lma_expr, nocrossrefs) 4622 etree_type *vma_expr; 4623 etree_type *lma_expr; 4624 int nocrossrefs; 4625{ 4626 /* The grammar should prevent nested overlays from occurring. */ 4627 ASSERT (overlay_vma == NULL 4628 && overlay_lma == NULL 4629 && overlay_list == NULL 4630 && overlay_max == NULL); 4631 4632 overlay_vma = vma_expr; 4633 overlay_lma = lma_expr; 4634 overlay_nocrossrefs = nocrossrefs; 4635} 4636 4637/* Start a section in an overlay. We handle this by calling 4638 lang_enter_output_section_statement with the correct VMA and LMA. */ 4639 4640void 4641lang_enter_overlay_section (name) 4642 const char *name; 4643{ 4644 struct overlay_list *n; 4645 etree_type *size; 4646 4647 lang_enter_output_section_statement (name, overlay_vma, normal_section, 4648 0, 0, 0, overlay_lma); 4649 4650 /* If this is the first section, then base the VMA and LMA of future 4651 sections on this one. This will work correctly even if `.' is 4652 used in the addresses. */ 4653 if (overlay_list == NULL) 4654 { 4655 overlay_vma = exp_nameop (ADDR, name); 4656 overlay_lma = exp_nameop (LOADADDR, name); 4657 } 4658 4659 /* Remember the section. */ 4660 n = (struct overlay_list *) xmalloc (sizeof *n); 4661 n->os = current_section; 4662 n->next = overlay_list; 4663 overlay_list = n; 4664 4665 size = exp_nameop (SIZEOF, name); 4666 4667 /* Adjust the LMA for the next section. */ 4668 overlay_lma = exp_binop ('+', overlay_lma, size); 4669 4670 /* Arrange to work out the maximum section end address. */ 4671 if (overlay_max == NULL) 4672 overlay_max = size; 4673 else 4674 overlay_max = exp_binop (MAX_K, overlay_max, size); 4675} 4676 4677/* Finish a section in an overlay. There isn't any special to do 4678 here. */ 4679 4680void 4681lang_leave_overlay_section (fill, phdrs) 4682 bfd_vma fill; 4683 struct lang_output_section_phdr_list *phdrs; 4684{ 4685 const char *name; 4686 char *clean, *s2; 4687 const char *s1; 4688 char *buf; 4689 4690 name = current_section->name; 4691 4692 lang_leave_output_section_statement (fill, "*default*", 4693 phdrs, "*default*"); 4694 4695 /* Define the magic symbols. */ 4696 4697 clean = xmalloc (strlen (name) + 1); 4698 s2 = clean; 4699 for (s1 = name; *s1 != '\0'; s1++) 4700 if (isalnum ((unsigned char) *s1) || *s1 == '_') 4701 *s2++ = *s1; 4702 *s2 = '\0'; 4703 4704 buf = xmalloc (strlen (clean) + sizeof "__load_start_"); 4705 sprintf (buf, "__load_start_%s", clean); 4706 lang_add_assignment (exp_assop ('=', buf, 4707 exp_nameop (LOADADDR, name))); 4708 4709 buf = xmalloc (strlen (clean) + sizeof "__load_stop_"); 4710 sprintf (buf, "__load_stop_%s", clean); 4711 lang_add_assignment (exp_assop ('=', buf, 4712 exp_binop ('+', 4713 exp_nameop (LOADADDR, name), 4714 exp_nameop (SIZEOF, name)))); 4715 4716 free (clean); 4717} 4718 4719/* Finish an overlay. If there are any overlay wide settings, this 4720 looks through all the sections in the overlay and sets them. */ 4721 4722void 4723lang_leave_overlay (fill, memspec, phdrs, lma_memspec) 4724 bfd_vma fill; 4725 const char *memspec; 4726 struct lang_output_section_phdr_list *phdrs; 4727 const char *lma_memspec; 4728{ 4729 lang_memory_region_type *region; 4730 lang_memory_region_type *lma_region; 4731 struct overlay_list *l; 4732 struct lang_nocrossref *nocrossref; 4733 4734 if (memspec == NULL) 4735 region = NULL; 4736 else 4737 region = lang_memory_region_lookup (memspec); 4738 4739 if (lma_memspec == NULL) 4740 lma_region = NULL; 4741 else 4742 lma_region = lang_memory_region_lookup (lma_memspec); 4743 4744 nocrossref = NULL; 4745 4746 l = overlay_list; 4747 while (l != NULL) 4748 { 4749 struct overlay_list *next; 4750 4751 if (fill != 0 && l->os->fill == 0) 4752 l->os->fill = fill; 4753 if (region != NULL && l->os->region == NULL) 4754 l->os->region = region; 4755 if (lma_region != NULL && l->os->lma_region == NULL) 4756 l->os->lma_region = lma_region; 4757 if (phdrs != NULL && l->os->phdrs == NULL) 4758 l->os->phdrs = phdrs; 4759 4760 if (overlay_nocrossrefs) 4761 { 4762 struct lang_nocrossref *nc; 4763 4764 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc); 4765 nc->name = l->os->name; 4766 nc->next = nocrossref; 4767 nocrossref = nc; 4768 } 4769 4770 next = l->next; 4771 free (l); 4772 l = next; 4773 } 4774 4775 if (nocrossref != NULL) 4776 lang_add_nocrossref (nocrossref); 4777 4778 /* Update . for the end of the overlay. */ 4779 lang_add_assignment (exp_assop ('=', ".", 4780 exp_binop ('+', overlay_vma, overlay_max))); 4781 4782 overlay_vma = NULL; 4783 overlay_lma = NULL; 4784 overlay_nocrossrefs = 0; 4785 overlay_list = NULL; 4786 overlay_max = NULL; 4787} 4788 4789/* Version handling. This is only useful for ELF. */ 4790 4791/* This global variable holds the version tree that we build. */ 4792 4793struct bfd_elf_version_tree *lang_elf_version_info; 4794 4795static int 4796lang_vers_match_lang_c (expr, sym) 4797 struct bfd_elf_version_expr *expr; 4798 const char *sym; 4799{ 4800 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0') 4801 return 1; 4802 return fnmatch (expr->pattern, sym, 0) == 0; 4803} 4804 4805static int 4806lang_vers_match_lang_cplusplus (expr, sym) 4807 struct bfd_elf_version_expr *expr; 4808 const char *sym; 4809{ 4810 char *alt_sym; 4811 int result; 4812 4813 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0') 4814 return 1; 4815 4816 alt_sym = cplus_demangle(sym, /* DMGL_NO_TPARAMS */ 0); 4817 if (!alt_sym) 4818 { 4819 /* cplus_demangle (also) returns NULL when it is not a C++ symbol. 4820 Should we early out false in this case? */ 4821 result = fnmatch (expr->pattern, sym, 0) == 0; 4822 } 4823 else 4824 { 4825 result = fnmatch (expr->pattern, alt_sym, 0) == 0; 4826 free (alt_sym); 4827 } 4828 4829 return result; 4830} 4831 4832static int 4833lang_vers_match_lang_java (expr, sym) 4834 struct bfd_elf_version_expr *expr; 4835 const char *sym; 4836{ 4837 char *alt_sym; 4838 int result; 4839 4840 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0') 4841 return 1; 4842 4843 alt_sym = cplus_demangle(sym, DMGL_JAVA); 4844 if (!alt_sym) 4845 { 4846 /* cplus_demangle (also) returns NULL when it is not a Java symbol. 4847 Should we early out false in this case? */ 4848 result = fnmatch (expr->pattern, sym, 0) == 0; 4849 } 4850 else 4851 { 4852 result = fnmatch (expr->pattern, alt_sym, 0) == 0; 4853 free (alt_sym); 4854 } 4855 4856 return result; 4857} 4858 4859/* This is called for each variable name or match expression. */ 4860 4861struct bfd_elf_version_expr * 4862lang_new_vers_regex (orig, new, lang) 4863 struct bfd_elf_version_expr *orig; 4864 const char *new; 4865 const char *lang; 4866{ 4867 struct bfd_elf_version_expr *ret; 4868 4869 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret); 4870 ret->next = orig; 4871 ret->pattern = new; 4872 4873 if (lang == NULL || strcasecmp (lang, "C") == 0) 4874 ret->match = lang_vers_match_lang_c; 4875 else if (strcasecmp (lang, "C++") == 0) 4876 ret->match = lang_vers_match_lang_cplusplus; 4877 else if (strcasecmp (lang, "Java") == 0) 4878 ret->match = lang_vers_match_lang_java; 4879 else 4880 { 4881 einfo (_("%X%P: unknown language `%s' in version information\n"), 4882 lang); 4883 ret->match = lang_vers_match_lang_c; 4884 } 4885 4886 return ret; 4887} 4888 4889/* This is called for each set of variable names and match 4890 expressions. */ 4891 4892struct bfd_elf_version_tree * 4893lang_new_vers_node (globals, locals) 4894 struct bfd_elf_version_expr *globals; 4895 struct bfd_elf_version_expr *locals; 4896{ 4897 struct bfd_elf_version_tree *ret; 4898 4899 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret); 4900 ret->next = NULL; 4901 ret->name = NULL; 4902 ret->vernum = 0; 4903 ret->globals = globals; 4904 ret->locals = locals; 4905 ret->deps = NULL; 4906 ret->name_indx = (unsigned int) -1; 4907 ret->used = 0; 4908 return ret; 4909} 4910 4911/* This static variable keeps track of version indices. */ 4912 4913static int version_index; 4914 4915/* This is called when we know the name and dependencies of the 4916 version. */ 4917 4918void 4919lang_register_vers_node (name, version, deps) 4920 const char *name; 4921 struct bfd_elf_version_tree *version; 4922 struct bfd_elf_version_deps *deps; 4923{ 4924 struct bfd_elf_version_tree *t, **pp; 4925 struct bfd_elf_version_expr *e1; 4926 4927 /* Make sure this node has a unique name. */ 4928 for (t = lang_elf_version_info; t != NULL; t = t->next) 4929 if (strcmp (t->name, name) == 0) 4930 einfo (_("%X%P: duplicate version tag `%s'\n"), name); 4931 4932 /* Check the global and local match names, and make sure there 4933 aren't any duplicates. */ 4934 4935 for (e1 = version->globals; e1 != NULL; e1 = e1->next) 4936 { 4937 for (t = lang_elf_version_info; t != NULL; t = t->next) 4938 { 4939 struct bfd_elf_version_expr *e2; 4940 4941 for (e2 = t->locals; e2 != NULL; e2 = e2->next) 4942 if (strcmp (e1->pattern, e2->pattern) == 0) 4943 einfo (_("%X%P: duplicate expression `%s' in version information\n"), 4944 e1->pattern); 4945 } 4946 } 4947 4948 for (e1 = version->locals; e1 != NULL; e1 = e1->next) 4949 { 4950 for (t = lang_elf_version_info; t != NULL; t = t->next) 4951 { 4952 struct bfd_elf_version_expr *e2; 4953 4954 for (e2 = t->globals; e2 != NULL; e2 = e2->next) 4955 if (strcmp (e1->pattern, e2->pattern) == 0) 4956 einfo (_("%X%P: duplicate expression `%s' in version information\n"), 4957 e1->pattern); 4958 } 4959 } 4960 4961 version->deps = deps; 4962 version->name = name; 4963 ++version_index; 4964 version->vernum = version_index; 4965 4966 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next) 4967 ; 4968 *pp = version; 4969} 4970 4971/* This is called when we see a version dependency. */ 4972 4973struct bfd_elf_version_deps * 4974lang_add_vers_depend (list, name) 4975 struct bfd_elf_version_deps *list; 4976 const char *name; 4977{ 4978 struct bfd_elf_version_deps *ret; 4979 struct bfd_elf_version_tree *t; 4980 4981 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret); 4982 ret->next = list; 4983 4984 for (t = lang_elf_version_info; t != NULL; t = t->next) 4985 { 4986 if (strcmp (t->name, name) == 0) 4987 { 4988 ret->version_needed = t; 4989 return ret; 4990 } 4991 } 4992 4993 einfo (_("%X%P: unable to find version dependency `%s'\n"), name); 4994 4995 return ret; 4996} 4997 4998static void 4999lang_do_version_exports_section () 5000{ 5001 struct bfd_elf_version_expr *greg = NULL, *lreg; 5002 5003 LANG_FOR_EACH_INPUT_STATEMENT (is) 5004 { 5005 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports"); 5006 char *contents, *p; 5007 bfd_size_type len; 5008 5009 if (sec == NULL) 5010 continue; 5011 5012 len = bfd_section_size (is->the_bfd, sec); 5013 contents = xmalloc (len); 5014 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len)) 5015 einfo (_("%X%P: unable to read .exports section contents"), sec); 5016 5017 p = contents; 5018 while (p < contents+len) 5019 { 5020 greg = lang_new_vers_regex (greg, p, NULL); 5021 p = strchr (p, '\0') + 1; 5022 } 5023 5024 /* Do not free the contents, as we used them creating the regex. */ 5025 5026 /* Do not include this section in the link. */ 5027 bfd_set_section_flags (is->the_bfd, sec, 5028 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE); 5029 } 5030 5031 lreg = lang_new_vers_regex (NULL, "*", NULL); 5032 lang_register_vers_node (command_line.version_exports_section, 5033 lang_new_vers_node (greg, lreg), NULL); 5034} 5035