1 /* Linker command language support. 2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000 3 Free Software Foundation, Inc. 4 5 This file is part of GLD, the Gnu Linker. 6 7 GLD is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2, or (at your option) 10 any later version. 11 12 GLD is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GLD; see the file COPYING. If not, write to the Free 19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 20 02111-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 */ 44 static lang_statement_union_type *new_statement PARAMS ((enum statement_enum, 45 size_t, 46 lang_statement_list_type*)); 47 48 49 /* LOCALS */ 50 static struct obstack stat_obstack; 51 52 #define obstack_chunk_alloc xmalloc 53 #define obstack_chunk_free free 54 static CONST char *startup_file; 55 static lang_statement_list_type input_file_chain; 56 static boolean placed_commons = false; 57 static lang_output_section_statement_type *default_common_section; 58 static boolean map_option_f; 59 static bfd_vma print_dot; 60 static lang_input_statement_type *first_file; 61 static CONST char *current_target; 62 static CONST char *output_target; 63 static lang_statement_list_type statement_list; 64 static struct lang_phdr *lang_phdr_list; 65 66 static void lang_for_each_statement_worker 67 PARAMS ((void (*func) (lang_statement_union_type *), 68 lang_statement_union_type *s)); 69 static lang_input_statement_type *new_afile 70 PARAMS ((const char *name, lang_input_file_enum_type file_type, 71 const char *target, boolean add_to_list)); 72 static void init_os PARAMS ((lang_output_section_statement_type *s)); 73 static void exp_init_os PARAMS ((etree_type *)); 74 static void section_already_linked PARAMS ((bfd *, asection *, PTR)); 75 static struct bfd_hash_entry *already_linked_newfunc 76 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, 77 const char *string)); 78 static void already_linked_table_init PARAMS ((void)); 79 static void already_linked_table_free PARAMS ((void)); 80 static boolean wildcardp PARAMS ((const char *)); 81 static lang_statement_union_type *wild_sort 82 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *, 83 asection *)); 84 static lang_input_statement_type *lookup_name PARAMS ((const char *name)); 85 static void load_symbols PARAMS ((lang_input_statement_type *entry, 86 lang_statement_list_type *)); 87 static void wild PARAMS ((lang_wild_statement_type *s, 88 const char *section, const char *file, 89 const char *target, 90 lang_output_section_statement_type *output)); 91 static bfd *open_output PARAMS ((const char *name)); 92 static void ldlang_open_output PARAMS ((lang_statement_union_type *statement)); 93 static void open_input_bfds 94 PARAMS ((lang_statement_union_type *statement, boolean)); 95 static void lang_reasonable_defaults PARAMS ((void)); 96 static void lang_place_undefineds PARAMS ((void)); 97 static void map_input_to_output_sections 98 PARAMS ((lang_statement_union_type *s, 99 const char *target, 100 lang_output_section_statement_type *output_section_statement)); 101 static void print_output_section_statement 102 PARAMS ((lang_output_section_statement_type *output_section_statement)); 103 static void print_assignment 104 PARAMS ((lang_assignment_statement_type *assignment, 105 lang_output_section_statement_type *output_section)); 106 static void print_input_statement PARAMS ((lang_input_statement_type *statm)); 107 static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR)); 108 static void print_input_section PARAMS ((lang_input_section_type *in)); 109 static void print_fill_statement PARAMS ((lang_fill_statement_type *fill)); 110 static void print_data_statement PARAMS ((lang_data_statement_type *data)); 111 static void print_address_statement PARAMS ((lang_address_statement_type *)); 112 static void print_reloc_statement PARAMS ((lang_reloc_statement_type *reloc)); 113 static void print_padding_statement PARAMS ((lang_padding_statement_type *s)); 114 static void print_wild_statement 115 PARAMS ((lang_wild_statement_type *w, 116 lang_output_section_statement_type *os)); 117 static void print_group 118 PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *)); 119 static void print_statement PARAMS ((lang_statement_union_type *s, 120 lang_output_section_statement_type *os)); 121 static void print_statement_list PARAMS ((lang_statement_union_type *s, 122 lang_output_section_statement_type *os)); 123 static void print_statements PARAMS ((void)); 124 static bfd_vma insert_pad PARAMS ((lang_statement_union_type **this_ptr, 125 fill_type fill, unsigned int power, 126 asection *output_section_statement, 127 bfd_vma dot)); 128 static bfd_vma size_input_section 129 PARAMS ((lang_statement_union_type **this_ptr, 130 lang_output_section_statement_type *output_section_statement, 131 fill_type fill, bfd_vma dot, boolean relax)); 132 static void lang_finish PARAMS ((void)); 133 static void ignore_bfd_errors PARAMS ((const char *, ...)); 134 static void lang_check PARAMS ((void)); 135 static void lang_common PARAMS ((void)); 136 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR)); 137 static void lang_place_orphans PARAMS ((void)); 138 static int topower PARAMS ((int)); 139 static void lang_set_startof PARAMS ((void)); 140 static void reset_memory_regions PARAMS ((void)); 141 static void lang_record_phdrs PARAMS ((void)); 142 static void lang_gc_wild 143 PARAMS ((lang_wild_statement_type *, const char *, const char *)); 144 static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *)); 145 static void lang_gc_sections PARAMS ((void)); 146 static void lang_do_version_exports_section PARAMS ((void)); 147 static void lang_check_section_addresses PARAMS ((void)); 148 149 typedef void (*callback_t) PARAMS ((lang_wild_statement_type *, 150 asection *, lang_input_statement_type *, 151 void *)); 152 static void walk_wild_section 153 PARAMS ((lang_wild_statement_type *, const char *, 154 lang_input_statement_type *, callback_t, void *)); 155 static void walk_wild_file 156 PARAMS ((lang_wild_statement_type *, const char *, 157 lang_input_statement_type *, callback_t, void *)); 158 159 static int get_target PARAMS ((const bfd_target *, void *)); 160 static void stricpy PARAMS ((char *, char *)); 161 static void strcut PARAMS ((char *, char *)); 162 static int name_compare PARAMS ((char *, char *)); 163 static int closest_target_match PARAMS ((const bfd_target *, void *)); 164 static char * get_first_input_target PARAMS ((void)); 165 166 /* EXPORTS */ 167 lang_output_section_statement_type *abs_output_section; 168 lang_statement_list_type lang_output_section_statement; 169 lang_statement_list_type *stat_ptr = &statement_list; 170 lang_statement_list_type file_chain = { NULL, NULL }; 171 const char *entry_symbol = NULL; 172 boolean entry_from_cmdline; 173 boolean lang_has_input_file = false; 174 boolean had_output_filename = false; 175 boolean lang_float_flag = false; 176 boolean delete_output_file_on_failure = false; 177 struct lang_nocrossrefs *nocrossref_list; 178 179 etree_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 196 PTR 197 stat_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 207 static void 208 walk_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 268 static void 269 walk_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 305 static void 306 walk_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 344 static void 345 lang_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 391 void 392 lang_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 /*----------------------------------------------------------------------*/ 400 void 401 lang_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 414 static 415 lang_statement_union_type * 416 new_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 */ 441 static lang_input_statement_type * 442 new_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 528 lang_input_statement_type * 529 lang_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 */ 539 void 540 lang_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 571 static lang_memory_region_type *lang_memory_region_list; 572 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list; 573 574 lang_memory_region_type * 575 lang_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 627 lang_memory_region_type * 628 lang_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 652 lang_output_section_statement_type * 653 lang_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 672 lang_output_section_statement_type * 673 lang_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 711 static void 712 lang_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 731 void 732 lang_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 787 static void 788 init_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 826 static void 827 exp_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 886 struct already_linked_hash_entry 887 { 888 struct bfd_hash_entry root; 889 struct already_linked *entry; 890 }; 891 892 struct already_linked 893 { 894 struct already_linked *next; 895 asection *sec; 896 }; 897 898 /* The hash table. */ 899 900 static struct bfd_hash_table already_linked_table; 901 902 /*ARGSUSED*/ 903 static void 904 section_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 1019 static struct bfd_hash_entry * 1020 already_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 1033 static void 1034 already_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 1042 static void 1043 already_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 1060 static boolean 1061 wildcardp (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 1078 void 1079 wild_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 1207 static lang_statement_union_type * 1208 wild_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 1306 static void 1307 output_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 1362 static lang_input_statement_type * 1363 lookup_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 1399 static void 1400 load_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 1513 static void 1514 wild (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. */ 1534 static int 1535 get_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. */ 1545 static void 1546 stricpy (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. */ 1565 static void 1566 strcut (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. */ 1585 static int 1586 name_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. */ 1624 static 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. */ 1629 static int 1630 closest_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. */ 1663 static char * 1664 get_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 1691 static bfd * 1692 open_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 1783 static void 1784 ldlang_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 1817 static void 1818 open_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 1893 static void 1894 lang_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 */ 1922 typedef struct ldlang_undef_chain_list 1923 { 1924 struct ldlang_undef_chain_list *next; 1925 char *name; 1926 } ldlang_undef_chain_list_type; 1927 1928 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head; 1929 1930 void 1931 ldlang_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 */ 1948 static void 1949 lang_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 */ 1972 static void 1973 map_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 2049 static void 2050 print_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 2095 static void 2096 print_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 2125 static void 2126 print_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 2138 static boolean 2139 print_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 2166 static void 2167 print_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 2224 static void 2225 print_fill_statement (fill) 2226 lang_fill_statement_type * fill; 2227 { 2228 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill); 2229 } 2230 2231 static void 2232 print_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 2292 static void 2293 print_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 2303 static void 2304 print_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 2336 static void 2337 print_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 2367 static void 2368 print_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 2409 static void 2410 print_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 2422 static void 2423 print_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 2437 static void 2438 print_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 2509 static void 2510 print_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 2520 void 2521 dprint_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 2543 static bfd_vma 2544 insert_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 */ 2592 static bfd_vma 2593 size_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. */ 2642 static void 2643 lang_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 2697 static 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 2704 static void 2705 os_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 2738 bfd_vma 2739 lang_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 3115 bfd_vma 3116 lang_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 3282 static void 3283 lang_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 3326 static void 3327 lang_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 3403 static void 3404 #ifdef ANSI_PROTOTYPES 3405 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...) 3406 #else 3407 ignore_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 3418 static void 3419 lang_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 3466 static void 3467 lang_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 3487 static boolean 3488 lang_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 /* 3582 run through the input files and ensure that every input 3583 section has somewhere to go. If one is found without 3584 a destination then create an input request and place it 3585 into the statement tree. 3586 */ 3587 3588 static void 3589 lang_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 3651 void 3652 lang_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 3696 void 3697 lang_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 3712 void 3713 lang_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 3726 void 3727 lang_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 3745 void 3746 ldlang_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 3780 void 3781 lang_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 3794 static lang_output_section_statement_type *current_section; 3795 3796 static int 3797 topower (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 3816 lang_output_section_statement_type * 3817 lang_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 return os; 3865 } 3866 3867 3868 void 3869 lang_final () 3870 { 3871 lang_output_statement_type *new = 3872 new_stat (lang_output_statement, stat_ptr); 3873 3874 new->name = output_filename; 3875 } 3876 3877 /* Reset the current counters in the regions */ 3878 static void 3879 reset_memory_regions () 3880 { 3881 lang_memory_region_type *p = lang_memory_region_list; 3882 3883 for (p = lang_memory_region_list; 3884 p != (lang_memory_region_type *) NULL; 3885 p = p->next) 3886 { 3887 p->old_length = (bfd_size_type) (p->current - p->origin); 3888 p->current = p->origin; 3889 } 3890 } 3891 3892 /* Expand a wild statement for a particular FILE, marking its sections KEEP 3893 as needed. SECTION may be NULL, in which case it is a wild card. */ 3894 3895 static void 3896 gc_section_callback (ptr, section, file, data) 3897 lang_wild_statement_type *ptr; 3898 asection *section; 3899 lang_input_statement_type *file ATTRIBUTE_UNUSED; 3900 void *data ATTRIBUTE_UNUSED; 3901 { 3902 /* If the wild pattern was marked KEEP, the member sections 3903 should be as well. */ 3904 if (ptr->keep_sections) 3905 section->flags |= SEC_KEEP; 3906 } 3907 3908 /* Handle a wild statement, marking it against GC. SECTION or FILE or both 3909 may be NULL, indicating that it is a wildcard. */ 3910 3911 static void 3912 lang_gc_wild (s, section, file) 3913 lang_wild_statement_type *s; 3914 const char *section; 3915 const char *file; 3916 { 3917 walk_wild (s, section, file, gc_section_callback, NULL); 3918 } 3919 3920 /* Iterate over sections marking them against GC. */ 3921 3922 static void 3923 lang_gc_sections_1 (s) 3924 lang_statement_union_type * s; 3925 { 3926 for (; s != (lang_statement_union_type *) NULL; s = s->next) 3927 { 3928 switch (s->header.type) 3929 { 3930 case lang_wild_statement_enum: 3931 lang_gc_wild (&s->wild_statement, 3932 s->wild_statement.section_name, 3933 s->wild_statement.filename); 3934 break; 3935 case lang_constructors_statement_enum: 3936 lang_gc_sections_1 (constructor_list.head); 3937 break; 3938 case lang_output_section_statement_enum: 3939 lang_gc_sections_1 (s->output_section_statement.children.head); 3940 break; 3941 case lang_group_statement_enum: 3942 lang_gc_sections_1 (s->group_statement.children.head); 3943 break; 3944 default: 3945 break; 3946 } 3947 } 3948 } 3949 3950 static void 3951 lang_gc_sections () 3952 { 3953 struct bfd_link_hash_entry *h; 3954 ldlang_undef_chain_list_type *ulist, fake_list_start; 3955 3956 /* Keep all sections so marked in the link script. */ 3957 3958 lang_gc_sections_1 (statement_list.head); 3959 3960 /* Keep all sections containing symbols undefined on the command-line. 3961 Handle the entry symbol at the same time. */ 3962 3963 if (entry_symbol != NULL) 3964 { 3965 fake_list_start.next = ldlang_undef_chain_list_head; 3966 fake_list_start.name = (char *) entry_symbol; 3967 ulist = &fake_list_start; 3968 } 3969 else 3970 ulist = ldlang_undef_chain_list_head; 3971 3972 for (; ulist; ulist = ulist->next) 3973 { 3974 h = bfd_link_hash_lookup (link_info.hash, ulist->name, 3975 false, false, false); 3976 3977 if (h != (struct bfd_link_hash_entry *) NULL 3978 && (h->type == bfd_link_hash_defined 3979 || h->type == bfd_link_hash_defweak) 3980 && ! bfd_is_abs_section (h->u.def.section)) 3981 { 3982 h->u.def.section->flags |= SEC_KEEP; 3983 } 3984 } 3985 3986 bfd_gc_sections (output_bfd, &link_info); 3987 } 3988 3989 void 3990 lang_process () 3991 { 3992 lang_reasonable_defaults (); 3993 current_target = default_target; 3994 3995 lang_for_each_statement (ldlang_open_output); /* Open the output file */ 3996 3997 ldemul_create_output_section_statements (); 3998 3999 /* Add to the hash table all undefineds on the command line */ 4000 lang_place_undefineds (); 4001 4002 already_linked_table_init (); 4003 4004 /* Create a bfd for each input file */ 4005 current_target = default_target; 4006 open_input_bfds (statement_list.head, false); 4007 4008 ldemul_after_open (); 4009 4010 already_linked_table_free (); 4011 4012 /* Make sure that we're not mixing architectures. We call this 4013 after all the input files have been opened, but before we do any 4014 other processing, so that any operations merge_private_bfd_data 4015 does on the output file will be known during the rest of the 4016 link. */ 4017 lang_check (); 4018 4019 /* Handle .exports instead of a version script if we're told to do so. */ 4020 if (command_line.version_exports_section) 4021 lang_do_version_exports_section (); 4022 4023 /* Build all sets based on the information gathered from the input 4024 files. */ 4025 ldctor_build_sets (); 4026 4027 /* Remove unreferenced sections if asked to. */ 4028 if (command_line.gc_sections) 4029 lang_gc_sections (); 4030 4031 /* Size up the common data */ 4032 lang_common (); 4033 4034 /* Run through the contours of the script and attach input sections 4035 to the correct output sections 4036 */ 4037 map_input_to_output_sections (statement_list.head, (char *) NULL, 4038 (lang_output_section_statement_type *) NULL); 4039 4040 4041 /* Find any sections not attached explicitly and handle them */ 4042 lang_place_orphans (); 4043 4044 ldemul_before_allocation (); 4045 4046 /* We must record the program headers before we try to fix the 4047 section positions, since they will affect SIZEOF_HEADERS. */ 4048 lang_record_phdrs (); 4049 4050 /* Now run around and relax if we can */ 4051 if (command_line.relax) 4052 { 4053 /* First time round is a trial run to get the 'worst case' 4054 addresses of the objects if there was no relaxing. */ 4055 lang_size_sections (statement_list.head, 4056 abs_output_section, 4057 &(statement_list.head), 0, (bfd_vma) 0, false); 4058 4059 /* Keep relaxing until bfd_relax_section gives up. */ 4060 do 4061 { 4062 reset_memory_regions (); 4063 4064 relax_again = false; 4065 4066 /* Note: pe-dll.c does something like this also. If you find 4067 you need to change this code, you probably need to change 4068 pe-dll.c also. DJ */ 4069 4070 /* Do all the assignments with our current guesses as to 4071 section sizes. */ 4072 lang_do_assignments (statement_list.head, 4073 abs_output_section, 4074 (fill_type) 0, (bfd_vma) 0); 4075 4076 /* Perform another relax pass - this time we know where the 4077 globals are, so can make better guess. */ 4078 lang_size_sections (statement_list.head, 4079 abs_output_section, 4080 &(statement_list.head), 0, (bfd_vma) 0, true); 4081 } 4082 while (relax_again); 4083 } 4084 else 4085 { 4086 /* Size up the sections. */ 4087 lang_size_sections (statement_list.head, 4088 abs_output_section, 4089 &(statement_list.head), 0, (bfd_vma) 0, false); 4090 } 4091 4092 /* See if anything special should be done now we know how big 4093 everything is. */ 4094 ldemul_after_allocation (); 4095 4096 /* Fix any .startof. or .sizeof. symbols. */ 4097 lang_set_startof (); 4098 4099 /* Do all the assignments, now that we know the final restingplaces 4100 of all the symbols */ 4101 4102 lang_do_assignments (statement_list.head, 4103 abs_output_section, 4104 (fill_type) 0, (bfd_vma) 0); 4105 4106 /* Make sure that the section addresses make sense. */ 4107 if (! link_info.relocateable 4108 && command_line.check_section_addresses) 4109 lang_check_section_addresses (); 4110 4111 /* Final stuffs */ 4112 4113 ldemul_finish (); 4114 lang_finish (); 4115 } 4116 4117 /* EXPORTED TO YACC */ 4118 4119 void 4120 lang_add_wild (section_name, sections_sorted, filename, filenames_sorted, 4121 keep_sections, exclude_filename_list) 4122 const char *const section_name; 4123 boolean sections_sorted; 4124 const char *const filename; 4125 boolean filenames_sorted; 4126 boolean keep_sections; 4127 struct name_list *exclude_filename_list; 4128 { 4129 lang_wild_statement_type *new = new_stat (lang_wild_statement, 4130 stat_ptr); 4131 4132 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0) 4133 { 4134 placed_commons = true; 4135 } 4136 if (filename != NULL && ! wildcardp (filename)) 4137 { 4138 lang_has_input_file = true; 4139 } 4140 new->section_name = section_name; 4141 new->sections_sorted = sections_sorted; 4142 new->filename = filename; 4143 new->filenames_sorted = filenames_sorted; 4144 new->keep_sections = keep_sections; 4145 new->exclude_filename_list = exclude_filename_list; 4146 lang_list_init (&new->children); 4147 } 4148 4149 void 4150 lang_section_start (name, address) 4151 CONST char *name; 4152 etree_type * address; 4153 { 4154 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr); 4155 4156 ad->section_name = name; 4157 ad->address = address; 4158 } 4159 4160 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called 4161 because of a -e argument on the command line, or zero if this is 4162 called by ENTRY in a linker script. Command line arguments take 4163 precedence. */ 4164 4165 void 4166 lang_add_entry (name, cmdline) 4167 CONST char *name; 4168 boolean cmdline; 4169 { 4170 if (entry_symbol == NULL 4171 || cmdline 4172 || ! entry_from_cmdline) 4173 { 4174 entry_symbol = name; 4175 entry_from_cmdline = cmdline; 4176 } 4177 } 4178 4179 void 4180 lang_add_target (name) 4181 CONST char *name; 4182 { 4183 lang_target_statement_type *new = new_stat (lang_target_statement, 4184 stat_ptr); 4185 4186 new->target = name; 4187 4188 } 4189 4190 void 4191 lang_add_map (name) 4192 CONST char *name; 4193 { 4194 while (*name) 4195 { 4196 switch (*name) 4197 { 4198 case 'F': 4199 map_option_f = true; 4200 break; 4201 } 4202 name++; 4203 } 4204 } 4205 4206 void 4207 lang_add_fill (exp) 4208 int exp; 4209 { 4210 lang_fill_statement_type *new = new_stat (lang_fill_statement, 4211 stat_ptr); 4212 4213 new->fill = exp; 4214 } 4215 4216 void 4217 lang_add_data (type, exp) 4218 int type; 4219 union etree_union *exp; 4220 { 4221 4222 lang_data_statement_type *new = new_stat (lang_data_statement, 4223 stat_ptr); 4224 4225 new->exp = exp; 4226 new->type = type; 4227 4228 } 4229 4230 /* Create a new reloc statement. RELOC is the BFD relocation type to 4231 generate. HOWTO is the corresponding howto structure (we could 4232 look this up, but the caller has already done so). SECTION is the 4233 section to generate a reloc against, or NAME is the name of the 4234 symbol to generate a reloc against. Exactly one of SECTION and 4235 NAME must be NULL. ADDEND is an expression for the addend. */ 4236 4237 void 4238 lang_add_reloc (reloc, howto, section, name, addend) 4239 bfd_reloc_code_real_type reloc; 4240 reloc_howto_type *howto; 4241 asection *section; 4242 const char *name; 4243 union etree_union *addend; 4244 { 4245 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr); 4246 4247 p->reloc = reloc; 4248 p->howto = howto; 4249 p->section = section; 4250 p->name = name; 4251 p->addend_exp = addend; 4252 4253 p->addend_value = 0; 4254 p->output_section = NULL; 4255 p->output_vma = 0; 4256 } 4257 4258 lang_assignment_statement_type * 4259 lang_add_assignment (exp) 4260 etree_type * exp; 4261 { 4262 lang_assignment_statement_type *new = new_stat (lang_assignment_statement, 4263 stat_ptr); 4264 4265 new->exp = exp; 4266 return new; 4267 } 4268 4269 void 4270 lang_add_attribute (attribute) 4271 enum statement_enum attribute; 4272 { 4273 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr); 4274 } 4275 4276 void 4277 lang_startup (name) 4278 CONST char *name; 4279 { 4280 if (startup_file != (char *) NULL) 4281 { 4282 einfo (_("%P%Fmultiple STARTUP files\n")); 4283 } 4284 first_file->filename = name; 4285 first_file->local_sym_name = name; 4286 first_file->real = true; 4287 4288 startup_file = name; 4289 } 4290 4291 void 4292 lang_float (maybe) 4293 boolean maybe; 4294 { 4295 lang_float_flag = maybe; 4296 } 4297 4298 void 4299 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec) 4300 bfd_vma fill; 4301 const char *memspec; 4302 struct lang_output_section_phdr_list *phdrs; 4303 const char *lma_memspec; 4304 { 4305 current_section->fill = fill; 4306 current_section->region = lang_memory_region_lookup (memspec); 4307 if (strcmp (lma_memspec, "*default*") != 0) 4308 { 4309 current_section->lma_region = lang_memory_region_lookup (lma_memspec); 4310 /* if no runtime region has been given, but the load region has been, 4311 use the load region */ 4312 if (strcmp (memspec, "*default*") == 0) 4313 current_section->region = lang_memory_region_lookup (lma_memspec); 4314 } 4315 current_section->phdrs = phdrs; 4316 stat_ptr = &statement_list; 4317 } 4318 4319 /* 4320 Create an absolute symbol with the given name with the value of the 4321 address of first byte of the section named. 4322 4323 If the symbol already exists, then do nothing. 4324 */ 4325 void 4326 lang_abs_symbol_at_beginning_of (secname, name) 4327 const char *secname; 4328 const char *name; 4329 { 4330 struct bfd_link_hash_entry *h; 4331 4332 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true); 4333 if (h == (struct bfd_link_hash_entry *) NULL) 4334 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); 4335 4336 if (h->type == bfd_link_hash_new 4337 || h->type == bfd_link_hash_undefined) 4338 { 4339 asection *sec; 4340 4341 h->type = bfd_link_hash_defined; 4342 4343 sec = bfd_get_section_by_name (output_bfd, secname); 4344 if (sec == (asection *) NULL) 4345 h->u.def.value = 0; 4346 else 4347 h->u.def.value = bfd_get_section_vma (output_bfd, sec); 4348 4349 h->u.def.section = bfd_abs_section_ptr; 4350 } 4351 } 4352 4353 /* 4354 Create an absolute symbol with the given name with the value of the 4355 address of the first byte after the end of the section named. 4356 4357 If the symbol already exists, then do nothing. 4358 */ 4359 void 4360 lang_abs_symbol_at_end_of (secname, name) 4361 const char *secname; 4362 const char *name; 4363 { 4364 struct bfd_link_hash_entry *h; 4365 4366 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true); 4367 if (h == (struct bfd_link_hash_entry *) NULL) 4368 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); 4369 4370 if (h->type == bfd_link_hash_new 4371 || h->type == bfd_link_hash_undefined) 4372 { 4373 asection *sec; 4374 4375 h->type = bfd_link_hash_defined; 4376 4377 sec = bfd_get_section_by_name (output_bfd, secname); 4378 if (sec == (asection *) NULL) 4379 h->u.def.value = 0; 4380 else 4381 h->u.def.value = (bfd_get_section_vma (output_bfd, sec) 4382 + bfd_section_size (output_bfd, sec) / 4383 bfd_octets_per_byte (output_bfd)); 4384 4385 h->u.def.section = bfd_abs_section_ptr; 4386 } 4387 } 4388 4389 void 4390 lang_statement_append (list, element, field) 4391 lang_statement_list_type * list; 4392 lang_statement_union_type * element; 4393 lang_statement_union_type ** field; 4394 { 4395 *(list->tail) = element; 4396 list->tail = field; 4397 } 4398 4399 /* Set the output format type. -oformat overrides scripts. */ 4400 4401 void 4402 lang_add_output_format (format, big, little, from_script) 4403 const char *format; 4404 const char *big; 4405 const char *little; 4406 int from_script; 4407 { 4408 if (output_target == NULL || !from_script) 4409 { 4410 if (command_line.endian == ENDIAN_BIG 4411 && big != NULL) 4412 format = big; 4413 else if (command_line.endian == ENDIAN_LITTLE 4414 && little != NULL) 4415 format = little; 4416 4417 output_target = format; 4418 } 4419 } 4420 4421 /* Enter a group. This creates a new lang_group_statement, and sets 4422 stat_ptr to build new statements within the group. */ 4423 4424 void 4425 lang_enter_group () 4426 { 4427 lang_group_statement_type *g; 4428 4429 g = new_stat (lang_group_statement, stat_ptr); 4430 lang_list_init (&g->children); 4431 stat_ptr = &g->children; 4432 } 4433 4434 /* Leave a group. This just resets stat_ptr to start writing to the 4435 regular list of statements again. Note that this will not work if 4436 groups can occur inside anything else which can adjust stat_ptr, 4437 but currently they can't. */ 4438 4439 void 4440 lang_leave_group () 4441 { 4442 stat_ptr = &statement_list; 4443 } 4444 4445 /* Add a new program header. This is called for each entry in a PHDRS 4446 command in a linker script. */ 4447 4448 void 4449 lang_new_phdr (name, type, filehdr, phdrs, at, flags) 4450 const char *name; 4451 etree_type *type; 4452 boolean filehdr; 4453 boolean phdrs; 4454 etree_type *at; 4455 etree_type *flags; 4456 { 4457 struct lang_phdr *n, **pp; 4458 4459 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr)); 4460 n->next = NULL; 4461 n->name = name; 4462 n->type = exp_get_value_int (type, 0, "program header type", 4463 lang_final_phase_enum); 4464 n->filehdr = filehdr; 4465 n->phdrs = phdrs; 4466 n->at = at; 4467 n->flags = flags; 4468 4469 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next) 4470 ; 4471 *pp = n; 4472 } 4473 4474 /* Record the program header information in the output BFD. FIXME: We 4475 should not be calling an ELF specific function here. */ 4476 4477 static void 4478 lang_record_phdrs () 4479 { 4480 unsigned int alc; 4481 asection **secs; 4482 struct lang_output_section_phdr_list *last; 4483 struct lang_phdr *l; 4484 lang_statement_union_type *u; 4485 4486 alc = 10; 4487 secs = (asection **) xmalloc (alc * sizeof (asection *)); 4488 last = NULL; 4489 for (l = lang_phdr_list; l != NULL; l = l->next) 4490 { 4491 unsigned int c; 4492 flagword flags; 4493 bfd_vma at; 4494 4495 c = 0; 4496 for (u = lang_output_section_statement.head; 4497 u != NULL; 4498 u = u->output_section_statement.next) 4499 { 4500 lang_output_section_statement_type *os; 4501 struct lang_output_section_phdr_list *pl; 4502 4503 os = &u->output_section_statement; 4504 4505 pl = os->phdrs; 4506 if (pl != NULL) 4507 last = pl; 4508 else 4509 { 4510 if (os->sectype == noload_section 4511 || os->bfd_section == NULL 4512 || (os->bfd_section->flags & SEC_ALLOC) == 0) 4513 continue; 4514 pl = last; 4515 } 4516 4517 if (os->bfd_section == NULL) 4518 continue; 4519 4520 for (; pl != NULL; pl = pl->next) 4521 { 4522 if (strcmp (pl->name, l->name) == 0) 4523 { 4524 if (c >= alc) 4525 { 4526 alc *= 2; 4527 secs = ((asection **) 4528 xrealloc (secs, alc * sizeof (asection *))); 4529 } 4530 secs[c] = os->bfd_section; 4531 ++c; 4532 pl->used = true; 4533 } 4534 } 4535 } 4536 4537 if (l->flags == NULL) 4538 flags = 0; 4539 else 4540 flags = exp_get_vma (l->flags, 0, "phdr flags", 4541 lang_final_phase_enum); 4542 4543 if (l->at == NULL) 4544 at = 0; 4545 else 4546 at = exp_get_vma (l->at, 0, "phdr load address", 4547 lang_final_phase_enum); 4548 4549 if (! bfd_record_phdr (output_bfd, l->type, 4550 l->flags == NULL ? false : true, 4551 flags, 4552 l->at == NULL ? false : true, 4553 at, l->filehdr, l->phdrs, c, secs)) 4554 einfo (_("%F%P: bfd_record_phdr failed: %E\n")); 4555 } 4556 4557 free (secs); 4558 4559 /* Make sure all the phdr assignments succeeded. */ 4560 for (u = lang_output_section_statement.head; 4561 u != NULL; 4562 u = u->output_section_statement.next) 4563 { 4564 struct lang_output_section_phdr_list *pl; 4565 4566 if (u->output_section_statement.bfd_section == NULL) 4567 continue; 4568 4569 for (pl = u->output_section_statement.phdrs; 4570 pl != NULL; 4571 pl = pl->next) 4572 if (! pl->used && strcmp (pl->name, "NONE") != 0) 4573 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"), 4574 u->output_section_statement.name, pl->name); 4575 } 4576 } 4577 4578 /* Record a list of sections which may not be cross referenced. */ 4579 4580 void 4581 lang_add_nocrossref (l) 4582 struct lang_nocrossref *l; 4583 { 4584 struct lang_nocrossrefs *n; 4585 4586 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n); 4587 n->next = nocrossref_list; 4588 n->list = l; 4589 nocrossref_list = n; 4590 4591 /* Set notice_all so that we get informed about all symbols. */ 4592 link_info.notice_all = true; 4593 } 4594 4595 /* Overlay handling. We handle overlays with some static variables. */ 4596 4597 /* The overlay virtual address. */ 4598 static etree_type *overlay_vma; 4599 4600 /* The overlay load address. */ 4601 static etree_type *overlay_lma; 4602 4603 /* Whether nocrossrefs is set for this overlay. */ 4604 static int overlay_nocrossrefs; 4605 4606 /* An expression for the maximum section size seen so far. */ 4607 static etree_type *overlay_max; 4608 4609 /* A list of all the sections in this overlay. */ 4610 4611 struct overlay_list 4612 { 4613 struct overlay_list *next; 4614 lang_output_section_statement_type *os; 4615 }; 4616 4617 static struct overlay_list *overlay_list; 4618 4619 /* Start handling an overlay. */ 4620 4621 void 4622 lang_enter_overlay (vma_expr, lma_expr, nocrossrefs) 4623 etree_type *vma_expr; 4624 etree_type *lma_expr; 4625 int nocrossrefs; 4626 { 4627 /* The grammar should prevent nested overlays from occurring. */ 4628 ASSERT (overlay_vma == NULL 4629 && overlay_lma == NULL 4630 && overlay_list == NULL 4631 && overlay_max == NULL); 4632 4633 overlay_vma = vma_expr; 4634 overlay_lma = lma_expr; 4635 overlay_nocrossrefs = nocrossrefs; 4636 } 4637 4638 /* Start a section in an overlay. We handle this by calling 4639 lang_enter_output_section_statement with the correct VMA and LMA. */ 4640 4641 void 4642 lang_enter_overlay_section (name) 4643 const char *name; 4644 { 4645 struct overlay_list *n; 4646 etree_type *size; 4647 4648 lang_enter_output_section_statement (name, overlay_vma, normal_section, 4649 0, 0, 0, overlay_lma); 4650 4651 /* If this is the first section, then base the VMA and LMA of future 4652 sections on this one. This will work correctly even if `.' is 4653 used in the addresses. */ 4654 if (overlay_list == NULL) 4655 { 4656 overlay_vma = exp_nameop (ADDR, name); 4657 overlay_lma = exp_nameop (LOADADDR, name); 4658 } 4659 4660 /* Remember the section. */ 4661 n = (struct overlay_list *) xmalloc (sizeof *n); 4662 n->os = current_section; 4663 n->next = overlay_list; 4664 overlay_list = n; 4665 4666 size = exp_nameop (SIZEOF, name); 4667 4668 /* Adjust the LMA for the next section. */ 4669 overlay_lma = exp_binop ('+', overlay_lma, size); 4670 4671 /* Arrange to work out the maximum section end address. */ 4672 if (overlay_max == NULL) 4673 overlay_max = size; 4674 else 4675 overlay_max = exp_binop (MAX_K, overlay_max, size); 4676 } 4677 4678 /* Finish a section in an overlay. There isn't any special to do 4679 here. */ 4680 4681 void 4682 lang_leave_overlay_section (fill, phdrs) 4683 bfd_vma fill; 4684 struct lang_output_section_phdr_list *phdrs; 4685 { 4686 const char *name; 4687 char *clean, *s2; 4688 const char *s1; 4689 char *buf; 4690 4691 name = current_section->name; 4692 4693 lang_leave_output_section_statement (fill, "*default*", 4694 phdrs, "*default*"); 4695 4696 /* Define the magic symbols. */ 4697 4698 clean = xmalloc (strlen (name) + 1); 4699 s2 = clean; 4700 for (s1 = name; *s1 != '\0'; s1++) 4701 if (isalnum ((unsigned char) *s1) || *s1 == '_') 4702 *s2++ = *s1; 4703 *s2 = '\0'; 4704 4705 buf = xmalloc (strlen (clean) + sizeof "__load_start_"); 4706 sprintf (buf, "__load_start_%s", clean); 4707 lang_add_assignment (exp_assop ('=', buf, 4708 exp_nameop (LOADADDR, name))); 4709 4710 buf = xmalloc (strlen (clean) + sizeof "__load_stop_"); 4711 sprintf (buf, "__load_stop_%s", clean); 4712 lang_add_assignment (exp_assop ('=', buf, 4713 exp_binop ('+', 4714 exp_nameop (LOADADDR, name), 4715 exp_nameop (SIZEOF, name)))); 4716 4717 free (clean); 4718 } 4719 4720 /* Finish an overlay. If there are any overlay wide settings, this 4721 looks through all the sections in the overlay and sets them. */ 4722 4723 void 4724 lang_leave_overlay (fill, memspec, phdrs, lma_memspec) 4725 bfd_vma fill; 4726 const char *memspec; 4727 struct lang_output_section_phdr_list *phdrs; 4728 const char *lma_memspec; 4729 { 4730 lang_memory_region_type *region; 4731 lang_memory_region_type *lma_region; 4732 struct overlay_list *l; 4733 struct lang_nocrossref *nocrossref; 4734 4735 if (memspec == NULL) 4736 region = NULL; 4737 else 4738 region = lang_memory_region_lookup (memspec); 4739 4740 if (lma_memspec == NULL) 4741 lma_region = NULL; 4742 else 4743 lma_region = lang_memory_region_lookup (lma_memspec); 4744 4745 nocrossref = NULL; 4746 4747 l = overlay_list; 4748 while (l != NULL) 4749 { 4750 struct overlay_list *next; 4751 4752 if (fill != 0 && l->os->fill == 0) 4753 l->os->fill = fill; 4754 if (region != NULL && l->os->region == NULL) 4755 l->os->region = region; 4756 if (lma_region != NULL && l->os->lma_region == NULL) 4757 l->os->lma_region = lma_region; 4758 if (phdrs != NULL && l->os->phdrs == NULL) 4759 l->os->phdrs = phdrs; 4760 4761 if (overlay_nocrossrefs) 4762 { 4763 struct lang_nocrossref *nc; 4764 4765 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc); 4766 nc->name = l->os->name; 4767 nc->next = nocrossref; 4768 nocrossref = nc; 4769 } 4770 4771 next = l->next; 4772 free (l); 4773 l = next; 4774 } 4775 4776 if (nocrossref != NULL) 4777 lang_add_nocrossref (nocrossref); 4778 4779 /* Update . for the end of the overlay. */ 4780 lang_add_assignment (exp_assop ('=', ".", 4781 exp_binop ('+', overlay_vma, overlay_max))); 4782 4783 overlay_vma = NULL; 4784 overlay_lma = NULL; 4785 overlay_nocrossrefs = 0; 4786 overlay_list = NULL; 4787 overlay_max = NULL; 4788 } 4789 4790 /* Version handling. This is only useful for ELF. */ 4791 4792 /* This global variable holds the version tree that we build. */ 4793 4794 struct bfd_elf_version_tree *lang_elf_version_info; 4795 4796 static int 4797 lang_vers_match_lang_c (expr, sym) 4798 struct bfd_elf_version_expr *expr; 4799 const char *sym; 4800 { 4801 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0') 4802 return 1; 4803 return fnmatch (expr->pattern, sym, 0) == 0; 4804 } 4805 4806 static int 4807 lang_vers_match_lang_cplusplus (expr, sym) 4808 struct bfd_elf_version_expr *expr; 4809 const char *sym; 4810 { 4811 char *alt_sym; 4812 int result; 4813 4814 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0') 4815 return 1; 4816 4817 alt_sym = cplus_demangle(sym, /* DMGL_NO_TPARAMS */ 0); 4818 if (!alt_sym) 4819 { 4820 /* cplus_demangle (also) returns NULL when it is not a C++ symbol. 4821 Should we early out false in this case? */ 4822 result = fnmatch (expr->pattern, sym, 0) == 0; 4823 } 4824 else 4825 { 4826 result = fnmatch (expr->pattern, alt_sym, 0) == 0; 4827 free (alt_sym); 4828 } 4829 4830 return result; 4831 } 4832 4833 static int 4834 lang_vers_match_lang_java (expr, sym) 4835 struct bfd_elf_version_expr *expr; 4836 const char *sym; 4837 { 4838 char *alt_sym; 4839 int result; 4840 4841 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0') 4842 return 1; 4843 4844 alt_sym = cplus_demangle(sym, DMGL_JAVA); 4845 if (!alt_sym) 4846 { 4847 /* cplus_demangle (also) returns NULL when it is not a Java symbol. 4848 Should we early out false in this case? */ 4849 result = fnmatch (expr->pattern, sym, 0) == 0; 4850 } 4851 else 4852 { 4853 result = fnmatch (expr->pattern, alt_sym, 0) == 0; 4854 free (alt_sym); 4855 } 4856 4857 return result; 4858 } 4859 4860 /* This is called for each variable name or match expression. */ 4861 4862 struct bfd_elf_version_expr * 4863 lang_new_vers_regex (orig, new, lang) 4864 struct bfd_elf_version_expr *orig; 4865 const char *new; 4866 const char *lang; 4867 { 4868 struct bfd_elf_version_expr *ret; 4869 4870 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret); 4871 ret->next = orig; 4872 ret->pattern = new; 4873 4874 if (lang == NULL || strcasecmp (lang, "C") == 0) 4875 ret->match = lang_vers_match_lang_c; 4876 else if (strcasecmp (lang, "C++") == 0) 4877 ret->match = lang_vers_match_lang_cplusplus; 4878 else if (strcasecmp (lang, "Java") == 0) 4879 ret->match = lang_vers_match_lang_java; 4880 else 4881 { 4882 einfo (_("%X%P: unknown language `%s' in version information\n"), 4883 lang); 4884 ret->match = lang_vers_match_lang_c; 4885 } 4886 4887 return ret; 4888 } 4889 4890 /* This is called for each set of variable names and match 4891 expressions. */ 4892 4893 struct bfd_elf_version_tree * 4894 lang_new_vers_node (globals, locals) 4895 struct bfd_elf_version_expr *globals; 4896 struct bfd_elf_version_expr *locals; 4897 { 4898 struct bfd_elf_version_tree *ret; 4899 4900 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret); 4901 ret->next = NULL; 4902 ret->name = NULL; 4903 ret->vernum = 0; 4904 ret->globals = globals; 4905 ret->locals = locals; 4906 ret->deps = NULL; 4907 ret->name_indx = (unsigned int) -1; 4908 ret->used = 0; 4909 return ret; 4910 } 4911 4912 /* This static variable keeps track of version indices. */ 4913 4914 static int version_index; 4915 4916 /* This is called when we know the name and dependencies of the 4917 version. */ 4918 4919 void 4920 lang_register_vers_node (name, version, deps) 4921 const char *name; 4922 struct bfd_elf_version_tree *version; 4923 struct bfd_elf_version_deps *deps; 4924 { 4925 struct bfd_elf_version_tree *t, **pp; 4926 struct bfd_elf_version_expr *e1; 4927 4928 /* Make sure this node has a unique name. */ 4929 for (t = lang_elf_version_info; t != NULL; t = t->next) 4930 if (strcmp (t->name, name) == 0) 4931 einfo (_("%X%P: duplicate version tag `%s'\n"), name); 4932 4933 /* Check the global and local match names, and make sure there 4934 aren't any duplicates. */ 4935 4936 for (e1 = version->globals; e1 != NULL; e1 = e1->next) 4937 { 4938 for (t = lang_elf_version_info; t != NULL; t = t->next) 4939 { 4940 struct bfd_elf_version_expr *e2; 4941 4942 for (e2 = t->locals; e2 != NULL; e2 = e2->next) 4943 if (strcmp (e1->pattern, e2->pattern) == 0) 4944 einfo (_("%X%P: duplicate expression `%s' in version information\n"), 4945 e1->pattern); 4946 } 4947 } 4948 4949 for (e1 = version->locals; e1 != NULL; e1 = e1->next) 4950 { 4951 for (t = lang_elf_version_info; t != NULL; t = t->next) 4952 { 4953 struct bfd_elf_version_expr *e2; 4954 4955 for (e2 = t->globals; e2 != NULL; e2 = e2->next) 4956 if (strcmp (e1->pattern, e2->pattern) == 0) 4957 einfo (_("%X%P: duplicate expression `%s' in version information\n"), 4958 e1->pattern); 4959 } 4960 } 4961 4962 version->deps = deps; 4963 version->name = name; 4964 ++version_index; 4965 version->vernum = version_index; 4966 4967 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next) 4968 ; 4969 *pp = version; 4970 } 4971 4972 /* This is called when we see a version dependency. */ 4973 4974 struct bfd_elf_version_deps * 4975 lang_add_vers_depend (list, name) 4976 struct bfd_elf_version_deps *list; 4977 const char *name; 4978 { 4979 struct bfd_elf_version_deps *ret; 4980 struct bfd_elf_version_tree *t; 4981 4982 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret); 4983 ret->next = list; 4984 4985 for (t = lang_elf_version_info; t != NULL; t = t->next) 4986 { 4987 if (strcmp (t->name, name) == 0) 4988 { 4989 ret->version_needed = t; 4990 return ret; 4991 } 4992 } 4993 4994 einfo (_("%X%P: unable to find version dependency `%s'\n"), name); 4995 4996 return ret; 4997 } 4998 4999 static void 5000 lang_do_version_exports_section () 5001 { 5002 struct bfd_elf_version_expr *greg = NULL, *lreg; 5003 5004 LANG_FOR_EACH_INPUT_STATEMENT (is) 5005 { 5006 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports"); 5007 char *contents, *p; 5008 bfd_size_type len; 5009 5010 if (sec == NULL) 5011 continue; 5012 5013 len = bfd_section_size (is->the_bfd, sec); 5014 contents = xmalloc (len); 5015 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len)) 5016 einfo (_("%X%P: unable to read .exports section contents"), sec); 5017 5018 p = contents; 5019 while (p < contents+len) 5020 { 5021 greg = lang_new_vers_regex (greg, p, NULL); 5022 p = strchr (p, '\0') + 1; 5023 } 5024 5025 /* Do not free the contents, as we used them creating the regex. */ 5026 5027 /* Do not include this section in the link. */ 5028 bfd_set_section_flags (is->the_bfd, sec, 5029 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE); 5030 } 5031 5032 lreg = lang_new_vers_regex (NULL, "*", NULL); 5033 lang_register_vers_node (command_line.version_exports_section, 5034 lang_new_vers_node (greg, lreg), NULL); 5035 } 5036