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