elf32.em revision 33965
1# This shell script emits a C file. -*- C -*- 2# It does some substitutions. 3# This file is now misnamed, because it supports both 32 bit and 64 bit 4# ELF emulations. 5test -z "${ELFSIZE}" && ELFSIZE=32 6cat >e${EMULATION_NAME}.c <<EOF 7/* This file is is generated by a shell script. DO NOT EDIT! */ 8 9/* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME} 10 Copyright (C) 1991, 93, 94, 95, 96, 1997 Free Software Foundation, Inc. 11 Written by Steve Chamberlain <sac@cygnus.com> 12 ELF support by Ian Lance Taylor <ian@cygnus.com> 13 14This file is part of GLD, the Gnu Linker. 15 16This program is free software; you can redistribute it and/or modify 17it under the terms of the GNU General Public License as published by 18the Free Software Foundation; either version 2 of the License, or 19(at your option) any later version. 20 21This program is distributed in the hope that it will be useful, 22but WITHOUT ANY WARRANTY; without even the implied warranty of 23MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 24GNU General Public License for more details. 25 26You should have received a copy of the GNU General Public License 27along with this program; if not, write to the Free Software 28Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 29 30#define TARGET_IS_${EMULATION_NAME} 31 32#include "bfd.h" 33#include "sysdep.h" 34 35#include <ctype.h> 36 37#include "bfdlink.h" 38 39#include "ld.h" 40#include "ldmain.h" 41#include "ldemul.h" 42#include "ldfile.h" 43#include "ldmisc.h" 44#include "ldexp.h" 45#include "ldlang.h" 46#include "ldgram.h" 47 48static void gld${EMULATION_NAME}_before_parse PARAMS ((void)); 49static boolean gld${EMULATION_NAME}_open_dynamic_archive 50 PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *)); 51static void gld${EMULATION_NAME}_after_open PARAMS ((void)); 52static void gld${EMULATION_NAME}_check_needed 53 PARAMS ((lang_input_statement_type *)); 54static void gld${EMULATION_NAME}_stat_needed 55 PARAMS ((lang_input_statement_type *)); 56static boolean gld${EMULATION_NAME}_search_needed 57 PARAMS ((const char *, const char *)); 58static boolean gld${EMULATION_NAME}_try_needed PARAMS ((const char *)); 59static void gld${EMULATION_NAME}_before_allocation PARAMS ((void)); 60static void gld${EMULATION_NAME}_find_statement_assignment 61 PARAMS ((lang_statement_union_type *)); 62static void gld${EMULATION_NAME}_find_exp_assignment PARAMS ((etree_type *)); 63static boolean gld${EMULATION_NAME}_place_orphan 64 PARAMS ((lang_input_statement_type *, asection *)); 65static void gld${EMULATION_NAME}_place_section 66 PARAMS ((lang_statement_union_type *)); 67static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile)); 68 69static void 70gld${EMULATION_NAME}_before_parse() 71{ 72 ldfile_output_architecture = bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`; 73 config.dynamic_link = ${DYNAMIC_LINK-true}; 74} 75 76/* Try to open a dynamic archive. This is where we know that ELF 77 dynamic libraries have an extension of .so. */ 78 79static boolean 80gld${EMULATION_NAME}_open_dynamic_archive (arch, search, entry) 81 const char *arch; 82 search_dirs_type *search; 83 lang_input_statement_type *entry; 84{ 85 const char *filename; 86 char *string; 87 88 if (! entry->is_archive) 89 return false; 90 91 filename = entry->filename; 92 93 string = (char *) xmalloc (strlen (search->name) 94 + strlen (filename) 95 + strlen (arch) 96 + sizeof "/lib.so"); 97 98 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch); 99 100 if (! ldfile_try_open_bfd (string, entry)) 101 { 102 free (string); 103 return false; 104 } 105 106 entry->filename = string; 107 108 /* We have found a dynamic object to include in the link. The ELF 109 backend linker will create a DT_NEEDED entry in the .dynamic 110 section naming this file. If this file includes a DT_SONAME 111 entry, it will be used. Otherwise, the ELF linker will just use 112 the name of the file. For an archive found by searching, like 113 this one, the DT_NEEDED entry should consist of just the name of 114 the file, without the path information used to find it. Note 115 that we only need to do this if we have a dynamic object; an 116 archive will never be referenced by a DT_NEEDED entry. 117 118 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not 119 very pretty. I haven't been able to think of anything that is 120 pretty, though. */ 121 if (bfd_check_format (entry->the_bfd, bfd_object) 122 && (entry->the_bfd->flags & DYNAMIC) != 0) 123 { 124 char *needed_name; 125 126 ASSERT (entry->is_archive && entry->search_dirs_flag); 127 needed_name = (char *) xmalloc (strlen (filename) 128 + strlen (arch) 129 + sizeof "lib.so"); 130 sprintf (needed_name, "lib%s%s.so", filename, arch); 131 bfd_elf_set_dt_needed_name (entry->the_bfd, needed_name); 132 } 133 134 return true; 135} 136 137EOF 138if [ "x${host}" = "x${target}" ] ; then 139 if [ "x${DEFAULT_EMULATION}" = "x${EMULATION_NAME}" ] ; then 140cat >>e${EMULATION_NAME}.c <<EOF 141 142/* For a native linker, check the file /etc/ld.so.conf for directories 143 in which we may find shared libraries. /etc/ld.so.conf is really 144 only meaningful on Linux, but we check it on other systems anyhow. */ 145 146static boolean gld${EMULATION_NAME}_check_ld_so_conf PARAMS ((const char *)); 147 148static boolean 149gld${EMULATION_NAME}_check_ld_so_conf (name) 150 const char *name; 151{ 152 static boolean initialized; 153 static char *ld_so_conf; 154 155 if (! initialized) 156 { 157 FILE *f; 158 159 f = fopen ("/etc/ld.so.conf", FOPEN_RT); 160 if (f != NULL) 161 { 162 char *b; 163 size_t len, alloc; 164 int c; 165 166 len = 0; 167 alloc = 100; 168 b = (char *) xmalloc (alloc); 169 170 while ((c = getc (f)) != EOF) 171 { 172 if (len + 1 >= alloc) 173 { 174 alloc *= 2; 175 b = (char *) xrealloc (b, alloc); 176 } 177 if (c != ':' 178 && c != ' ' 179 && c != '\t' 180 && c != '\n' 181 && c != ',') 182 { 183 b[len] = c; 184 ++len; 185 } 186 else 187 { 188 if (len > 0 && b[len - 1] != ':') 189 { 190 b[len] = ':'; 191 ++len; 192 } 193 } 194 } 195 196 if (len > 0 && b[len - 1] == ':') 197 --len; 198 199 if (len > 0) 200 b[len] = '\0'; 201 else 202 { 203 free (b); 204 b = NULL; 205 } 206 207 fclose (f); 208 209 ld_so_conf = b; 210 } 211 212 initialized = true; 213 } 214 215 if (ld_so_conf == NULL) 216 return false; 217 218 return gld${EMULATION_NAME}_search_needed (ld_so_conf, name); 219} 220 221EOF 222 fi 223fi 224cat >>e${EMULATION_NAME}.c <<EOF 225 226/* These variables are required to pass information back and forth 227 between after_open and check_needed and stat_needed. */ 228 229static struct bfd_link_needed_list *global_needed; 230static struct stat global_stat; 231static boolean global_found; 232 233/* This is called after all the input files have been opened. */ 234 235static void 236gld${EMULATION_NAME}_after_open () 237{ 238 struct bfd_link_needed_list *needed, *l; 239 240 /* We only need to worry about this when doing a final link. */ 241 if (link_info.relocateable || link_info.shared) 242 return; 243 244 /* Get the list of files which appear in DT_NEEDED entries in 245 dynamic objects included in the link (often there will be none). 246 For each such file, we want to track down the corresponding 247 library, and include the symbol table in the link. This is what 248 the runtime dynamic linker will do. Tracking the files down here 249 permits one dynamic object to include another without requiring 250 special action by the person doing the link. Note that the 251 needed list can actually grow while we are stepping through this 252 loop. */ 253 needed = bfd_elf_get_needed_list (output_bfd, &link_info); 254 for (l = needed; l != NULL; l = l->next) 255 { 256 struct bfd_link_needed_list *ll; 257 const char *lib_path; 258 size_t len; 259 search_dirs_type *search; 260 261 /* If we've already seen this file, skip it. */ 262 for (ll = needed; ll != l; ll = ll->next) 263 if (strcmp (ll->name, l->name) == 0) 264 break; 265 if (ll != l) 266 continue; 267 268 /* See if this file was included in the link explicitly. */ 269 global_needed = l; 270 global_found = false; 271 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed); 272 if (global_found) 273 continue; 274 275 /* We need to find this file and include the symbol table. We 276 want to search for the file in the same way that the dynamic 277 linker will search. That means that we want to use 278 rpath_link, rpath, then the environment variable 279 LD_LIBRARY_PATH (native only), then the linker script 280 LIB_SEARCH_DIRS. We do not search using the -L arguments. */ 281 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link, 282 l->name)) 283 continue; 284 if (gld${EMULATION_NAME}_search_needed (command_line.rpath, l->name)) 285 continue; 286 if (command_line.rpath_link == NULL 287 && command_line.rpath == NULL) 288 { 289 lib_path = (const char *) getenv ("LD_RUN_PATH"); 290 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name)) 291 continue; 292 } 293EOF 294if [ "x${host}" = "x${target}" ] ; then 295 if [ "x${DEFAULT_EMULATION}" = "x${EMULATION_NAME}" ] ; then 296cat >>e${EMULATION_NAME}.c <<EOF 297 lib_path = (const char *) getenv ("LD_LIBRARY_PATH"); 298 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name)) 299 continue; 300EOF 301 fi 302fi 303cat >>e${EMULATION_NAME}.c <<EOF 304 len = strlen (l->name); 305 for (search = search_head; search != NULL; search = search->next) 306 { 307 char *filename; 308 309 if (search->cmdline) 310 continue; 311 filename = (char *) xmalloc (strlen (search->name) + len + 2); 312 sprintf (filename, "%s/%s", search->name, l->name); 313 if (gld${EMULATION_NAME}_try_needed (filename)) 314 break; 315 free (filename); 316 } 317 if (search != NULL) 318 continue; 319EOF 320if [ "x${host}" = "x${target}" ] ; then 321 if [ "x${DEFAULT_EMULATION}" = "x${EMULATION_NAME}" ] ; then 322cat >>e${EMULATION_NAME}.c <<EOF 323 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name)) 324 continue; 325EOF 326 fi 327fi 328cat >>e${EMULATION_NAME}.c <<EOF 329 330 einfo ("%P: warning: %s, needed by %B, not found (try using --rpath)\n", 331 l->name, l->by); 332 } 333} 334 335/* Search for a needed file in a path. */ 336 337static boolean 338gld${EMULATION_NAME}_search_needed (path, name) 339 const char *path; 340 const char *name; 341{ 342 const char *s; 343 size_t len; 344 345 if (path == NULL || *path == '\0') 346 return false; 347 len = strlen (name); 348 while (1) 349 { 350 char *filename, *sset; 351 352 s = strchr (path, ':'); 353 if (s == NULL) 354 s = path + strlen (path); 355 356 filename = (char *) xmalloc (s - path + len + 2); 357 if (s == path) 358 sset = filename; 359 else 360 { 361 memcpy (filename, path, s - path); 362 filename[s - path] = '/'; 363 sset = filename + (s - path) + 1; 364 } 365 strcpy (sset, name); 366 367 if (gld${EMULATION_NAME}_try_needed (filename)) 368 return true; 369 370 free (filename); 371 372 if (*s == '\0') 373 break; 374 path = s + 1; 375 } 376 377 return false; 378} 379 380/* This function is called for each possible name for a dynamic object 381 named by a DT_NEEDED entry. */ 382 383static boolean 384gld${EMULATION_NAME}_try_needed (name) 385 const char *name; 386{ 387 bfd *abfd; 388 389 abfd = bfd_openr (name, bfd_get_target (output_bfd)); 390 if (abfd == NULL) 391 return false; 392 if (! bfd_check_format (abfd, bfd_object)) 393 { 394 (void) bfd_close (abfd); 395 return false; 396 } 397 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0) 398 { 399 (void) bfd_close (abfd); 400 return false; 401 } 402 403 /* We've found a dynamic object matching the DT_NEEDED entry. */ 404 405 /* We have already checked that there is no other input file of the 406 same name. We must now check again that we are not including the 407 same file twice. We need to do this because on many systems 408 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will 409 reference libc.so.1. If we have already included libc.so, we 410 don't want to include libc.so.1 if they are the same file, and we 411 can only check that using stat. */ 412 413 if (bfd_stat (abfd, &global_stat) != 0) 414 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd); 415 global_found = false; 416 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed); 417 if (global_found) 418 { 419 /* Return true to indicate that we found the file, even though 420 we aren't going to do anything with it. */ 421 return true; 422 } 423 424 /* Tell the ELF backend that don't want the output file to have a 425 DT_NEEDED entry for this file. */ 426 bfd_elf_set_dt_needed_name (abfd, ""); 427 428 /* Add this file into the symbol table. */ 429 if (! bfd_link_add_symbols (abfd, &link_info)) 430 einfo ("%F%B: could not read symbols: %E\n", abfd); 431 432 return true; 433} 434 435/* See if an input file matches a DT_NEEDED entry by name. */ 436 437static void 438gld${EMULATION_NAME}_check_needed (s) 439 lang_input_statement_type *s; 440{ 441 if (global_found) 442 return; 443 444 if (s->filename != NULL 445 && strcmp (s->filename, global_needed->name) == 0) 446 { 447 global_found = true; 448 return; 449 } 450 451 if (s->the_bfd != NULL) 452 { 453 const char *soname; 454 455 soname = bfd_elf_get_dt_soname (s->the_bfd); 456 if (soname != NULL 457 && strcmp (soname, global_needed->name) == 0) 458 { 459 global_found = true; 460 return; 461 } 462 } 463 464 if (s->search_dirs_flag 465 && s->filename != NULL 466 && strchr (global_needed->name, '/') == NULL) 467 { 468 const char *f; 469 470 f = strrchr (s->filename, '/'); 471 if (f != NULL 472 && strcmp (f + 1, global_needed->name) == 0) 473 { 474 global_found = true; 475 return; 476 } 477 } 478} 479 480/* See if an input file matches a DT_NEEDED entry by running stat on 481 the file. */ 482 483static void 484gld${EMULATION_NAME}_stat_needed (s) 485 lang_input_statement_type *s; 486{ 487 struct stat st; 488 const char *suffix; 489 const char *soname; 490 const char *f; 491 492 if (global_found) 493 return; 494 if (s->the_bfd == NULL) 495 return; 496 497 if (bfd_stat (s->the_bfd, &st) != 0) 498 { 499 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd); 500 return; 501 } 502 503 if (st.st_dev == global_stat.st_dev 504 && st.st_ino == global_stat.st_ino) 505 { 506 global_found = true; 507 return; 508 } 509 510 /* We issue a warning if it looks like we are including two 511 different versions of the same shared library. For example, 512 there may be a problem if -lc picks up libc.so.6 but some other 513 shared library has a DT_NEEDED entry of libc.so.5. This is a 514 hueristic test, and it will only work if the name looks like 515 NAME.so.VERSION. FIXME: Depending on file names is error-prone. 516 If we really want to issue warnings about mixing version numbers 517 of shared libraries, we need to find a better way. */ 518 519 if (strchr (global_needed->name, '/') != NULL) 520 return; 521 suffix = strstr (global_needed->name, ".so."); 522 if (suffix == NULL) 523 return; 524 suffix += sizeof ".so." - 1; 525 526 soname = bfd_elf_get_dt_soname (s->the_bfd); 527 if (soname == NULL) 528 soname = s->filename; 529 530 f = strrchr (soname, '/'); 531 if (f != NULL) 532 ++f; 533 else 534 f = soname; 535 536 if (strncmp (f, global_needed->name, suffix - global_needed->name) == 0) 537 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n", 538 global_needed->name, global_needed->by, f); 539} 540 541/* This is called after the sections have been attached to output 542 sections, but before any sizes or addresses have been set. */ 543 544static void 545gld${EMULATION_NAME}_before_allocation () 546{ 547 const char *rpath; 548 asection *sinterp; 549 550 /* If we are going to make any variable assignments, we need to let 551 the ELF backend know about them in case the variables are 552 referred to by dynamic objects. */ 553 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment); 554 555 /* Let the ELF backend work out the sizes of any sections required 556 by dynamic linking. */ 557 rpath = command_line.rpath; 558 if (rpath == NULL) 559 rpath = (const char *) getenv ("LD_RUN_PATH"); 560 if (! (bfd_elf${ELFSIZE}_size_dynamic_sections 561 (output_bfd, command_line.soname, rpath, 562 command_line.export_dynamic, command_line.filter_shlib, 563 (const char * const *) command_line.auxiliary_filters, 564 &link_info, &sinterp, lang_elf_version_info))) 565 einfo ("%P%F: failed to set dynamic section sizes: %E\n"); 566 567 /* Let the user override the dynamic linker we are using. */ 568 if (command_line.interpreter != NULL 569 && sinterp != NULL) 570 { 571 sinterp->contents = (bfd_byte *) command_line.interpreter; 572 sinterp->_raw_size = strlen (command_line.interpreter) + 1; 573 } 574 575 /* Look for any sections named .gnu.warning. As a GNU extensions, 576 we treat such sections as containing warning messages. We print 577 out the warning message, and then zero out the section size so 578 that it does not get copied into the output file. */ 579 580 { 581 LANG_FOR_EACH_INPUT_STATEMENT (is) 582 { 583 asection *s; 584 bfd_size_type sz; 585 char *msg; 586 boolean ret; 587 588 if (is->just_syms_flag) 589 continue; 590 591 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning"); 592 if (s == NULL) 593 continue; 594 595 sz = bfd_section_size (is->the_bfd, s); 596 msg = xmalloc ((size_t) sz + 1); 597 if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz)) 598 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n", 599 is->the_bfd); 600 msg[sz] = '\0'; 601 ret = link_info.callbacks->warning (&link_info, msg, 602 (const char *) NULL, 603 is->the_bfd, (asection *) NULL, 604 (bfd_vma) 0); 605 ASSERT (ret); 606 free (msg); 607 608 /* Clobber the section size, so that we don't waste copying the 609 warning into the output file. */ 610 s->_raw_size = 0; 611 } 612 } 613 614#if defined (TARGET_IS_elf32bmip) || defined (TARGET_IS_elf32lmip) 615 /* For MIPS ELF the .reginfo section requires special handling. 616 Each input section is 24 bytes, and the final output section must 617 also be 24 bytes. We handle this by clobbering all but the first 618 input section size to 0. The .reginfo section is handled 619 specially by the backend code anyhow. */ 620 { 621 boolean found = false; 622 LANG_FOR_EACH_INPUT_STATEMENT (is) 623 { 624 asection *s; 625 626 if (is->just_syms_flag) 627 continue; 628 629 s = bfd_get_section_by_name (is->the_bfd, ".reginfo"); 630 if (s == NULL) 631 continue; 632 633 if (! found) 634 { 635 found = true; 636 continue; 637 } 638 639 s->_raw_size = 0; 640 s->_cooked_size = 0; 641 } 642 } 643#endif 644} 645 646/* This is called by the before_allocation routine via 647 lang_for_each_statement. It locates any assignment statements, and 648 tells the ELF backend about them, in case they are assignments to 649 symbols which are referred to by dynamic objects. */ 650 651static void 652gld${EMULATION_NAME}_find_statement_assignment (s) 653 lang_statement_union_type *s; 654{ 655 if (s->header.type == lang_assignment_statement_enum) 656 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp); 657} 658 659/* Look through an expression for an assignment statement. */ 660 661static void 662gld${EMULATION_NAME}_find_exp_assignment (exp) 663 etree_type *exp; 664{ 665 struct bfd_link_hash_entry *h; 666 667 switch (exp->type.node_class) 668 { 669 case etree_provide: 670 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst, 671 false, false, false); 672 if (h == NULL) 673 break; 674 675 /* We call record_link_assignment even if the symbol is defined. 676 This is because if it is defined by a dynamic object, we 677 actually want to use the value defined by the linker script, 678 not the value from the dynamic object (because we are setting 679 symbols like etext). If the symbol is defined by a regular 680 object, then, as it happens, calling record_link_assignment 681 will do no harm. */ 682 683 /* Fall through. */ 684 case etree_assign: 685 if (strcmp (exp->assign.dst, ".") != 0) 686 { 687 if (! (bfd_elf${ELFSIZE}_record_link_assignment 688 (output_bfd, &link_info, exp->assign.dst, 689 exp->type.node_class == etree_provide ? true : false))) 690 einfo ("%P%F: failed to record assignment to %s: %E\n", 691 exp->assign.dst); 692 } 693 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src); 694 break; 695 696 case etree_binary: 697 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs); 698 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs); 699 break; 700 701 case etree_trinary: 702 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond); 703 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs); 704 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs); 705 break; 706 707 case etree_unary: 708 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child); 709 break; 710 711 default: 712 break; 713 } 714} 715 716/* Place an orphan section. We use this to put random SHF_ALLOC 717 sections in the right segment. */ 718 719static asection *hold_section; 720static lang_output_section_statement_type *hold_use; 721static lang_output_section_statement_type *hold_text; 722static lang_output_section_statement_type *hold_rodata; 723static lang_output_section_statement_type *hold_data; 724static lang_output_section_statement_type *hold_bss; 725static lang_output_section_statement_type *hold_rel; 726static lang_output_section_statement_type *hold_interp; 727 728/*ARGSUSED*/ 729static boolean 730gld${EMULATION_NAME}_place_orphan (file, s) 731 lang_input_statement_type *file; 732 asection *s; 733{ 734 lang_output_section_statement_type *place; 735 asection *snew, **pps; 736 lang_statement_list_type *old; 737 lang_statement_list_type add; 738 etree_type *address; 739 const char *secname, *ps; 740 const char *outsecname; 741 lang_output_section_statement_type *os; 742 743 if ((s->flags & SEC_ALLOC) == 0) 744 return false; 745 746 /* Look through the script to see where to place this section. */ 747 hold_section = s; 748 hold_use = NULL; 749 lang_for_each_statement (gld${EMULATION_NAME}_place_section); 750 751 if (hold_use != NULL) 752 { 753 /* We have already placed a section with this name. */ 754 wild_doit (&hold_use->children, s, hold_use, file); 755 return true; 756 } 757 758 secname = bfd_get_section_name (s->owner, s); 759 760 /* If this is a final link, then always put .gnu.warning.SYMBOL 761 sections into the .text section to get them out of the way. */ 762 if (! link_info.shared 763 && ! link_info.relocateable 764 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0 765 && hold_text != NULL) 766 { 767 wild_doit (&hold_text->children, s, hold_text, file); 768 return true; 769 } 770 771 /* Decide which segment the section should go in based on the 772 section name and section flags. We put loadable .note sections 773 right after the .interp section, so that the PT_NOTE segment is 774 stored right after the program headers where the OS can read it 775 in the first page. */ 776 place = NULL; 777 if ((s->flags & SEC_LOAD) != 0 778 && strncmp (secname, ".note", 4) == 0 779 && hold_interp != NULL) 780 place = hold_interp; 781 else if ((s->flags & SEC_HAS_CONTENTS) == 0 782 && hold_bss != NULL) 783 place = hold_bss; 784 else if ((s->flags & SEC_READONLY) == 0 785 && hold_data != NULL) 786 place = hold_data; 787 else if (strncmp (secname, ".rel", 4) == 0 788 && hold_rel != NULL) 789 place = hold_rel; 790 else if ((s->flags & SEC_CODE) == 0 791 && (s->flags & SEC_READONLY) != 0 792 && hold_rodata != NULL) 793 place = hold_rodata; 794 else if ((s->flags & SEC_READONLY) != 0 795 && hold_text != NULL) 796 place = hold_text; 797 if (place == NULL) 798 return false; 799 800 /* Choose a unique name for the section. This will be needed if the 801 same section name appears in the input file with different 802 loadable or allocateable characteristics. */ 803 outsecname = secname; 804 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL) 805 { 806 unsigned int len; 807 char *newname; 808 unsigned int i; 809 810 len = strlen (outsecname); 811 newname = xmalloc (len + 5); 812 strcpy (newname, outsecname); 813 i = 0; 814 do 815 { 816 sprintf (newname + len, "%d", i); 817 ++i; 818 } 819 while (bfd_get_section_by_name (output_bfd, newname) != NULL); 820 821 outsecname = newname; 822 } 823 824 /* Create the section in the output file, and put it in the right 825 place. This shuffling is to make the output file look neater. */ 826 snew = bfd_make_section (output_bfd, outsecname); 827 if (snew == NULL) 828 einfo ("%P%F: output format %s cannot represent section called %s\n", 829 output_bfd->xvec->name, outsecname); 830 if (place->bfd_section != NULL) 831 { 832 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next) 833 ; 834 *pps = snew->next; 835 snew->next = place->bfd_section->next; 836 place->bfd_section->next = snew; 837 } 838 839 /* Start building a list of statements for this section. */ 840 old = stat_ptr; 841 stat_ptr = &add; 842 lang_list_init (stat_ptr); 843 844 /* If the name of the section is representable in C, then create 845 symbols to mark the start and the end of the section. */ 846 for (ps = outsecname; *ps != '\0'; ps++) 847 if (! isalnum (*ps) && *ps != '_') 848 break; 849 if (*ps == '\0' && config.build_constructors) 850 { 851 char *symname; 852 853 symname = (char *) xmalloc (ps - outsecname + sizeof "__start_"); 854 sprintf (symname, "__start_%s", outsecname); 855 lang_add_assignment (exp_assop ('=', symname, 856 exp_unop (ALIGN_K, 857 exp_intop ((bfd_vma) 1 858 << s->alignment_power)))); 859 } 860 861 if (! link_info.relocateable) 862 address = NULL; 863 else 864 address = exp_intop ((bfd_vma) 0); 865 866 lang_enter_output_section_statement (outsecname, address, 0, 867 (bfd_vma) 0, 868 (etree_type *) NULL, 869 (etree_type *) NULL, 870 (etree_type *) NULL); 871 872 os = lang_output_section_statement_lookup (outsecname); 873 wild_doit (&os->children, s, os, file); 874 875 lang_leave_output_section_statement 876 ((bfd_vma) 0, "*default*", (struct lang_output_section_phdr_list *) NULL); 877 stat_ptr = &add; 878 879 if (*ps == '\0' && config.build_constructors) 880 { 881 char *symname; 882 883 symname = (char *) xmalloc (ps - outsecname + sizeof "__stop_"); 884 sprintf (symname, "__stop_%s", outsecname); 885 lang_add_assignment (exp_assop ('=', symname, 886 exp_nameop (NAME, "."))); 887 } 888 889 /* Now stick the new statement list right after PLACE. */ 890 *add.tail = place->header.next; 891 place->header.next = add.head; 892 893 stat_ptr = old; 894 895 return true; 896} 897 898static void 899gld${EMULATION_NAME}_place_section (s) 900 lang_statement_union_type *s; 901{ 902 lang_output_section_statement_type *os; 903 904 if (s->header.type != lang_output_section_statement_enum) 905 return; 906 907 os = &s->output_section_statement; 908 909 if (strcmp (os->name, hold_section->name) == 0 910 && ((hold_section->flags & (SEC_LOAD | SEC_ALLOC)) 911 == (os->bfd_section->flags & (SEC_LOAD | SEC_ALLOC)))) 912 hold_use = os; 913 914 if (strcmp (os->name, ".text") == 0) 915 hold_text = os; 916 else if (strcmp (os->name, ".rodata") == 0) 917 hold_rodata = os; 918 else if (strcmp (os->name, ".data") == 0) 919 hold_data = os; 920 else if (strcmp (os->name, ".bss") == 0) 921 hold_bss = os; 922 else if (hold_rel == NULL 923 && os->bfd_section != NULL 924 && (os->bfd_section->flags & SEC_ALLOC) != 0 925 && strncmp (os->name, ".rel", 4) == 0) 926 hold_rel = os; 927 else if (strcmp (os->name, ".interp") == 0) 928 hold_interp = os; 929} 930 931static char * 932gld${EMULATION_NAME}_get_script(isfile) 933 int *isfile; 934EOF 935 936if test -n "$COMPILE_IN" 937then 938# Scripts compiled in. 939 940# sed commands to quote an ld script as a C string. 941sc='s/["\\]/\\&/g 942s/$/\\n\\/ 9431s/^/"/ 944$s/$/n"/ 945' 946 947cat >>e${EMULATION_NAME}.c <<EOF 948{ 949 *isfile = 0; 950 951 if (link_info.relocateable == true && config.build_constructors == true) 952 return `sed "$sc" ldscripts/${EMULATION_NAME}.xu`; 953 else if (link_info.relocateable == true) 954 return `sed "$sc" ldscripts/${EMULATION_NAME}.xr`; 955 else if (!config.text_read_only) 956 return `sed "$sc" ldscripts/${EMULATION_NAME}.xbn`; 957 else if (!config.magic_demand_paged) 958 return `sed "$sc" ldscripts/${EMULATION_NAME}.xn`; 959 else if (link_info.shared) 960 return `sed "$sc" ldscripts/${EMULATION_NAME}.xs`; 961 else 962 return `sed "$sc" ldscripts/${EMULATION_NAME}.x`; 963} 964EOF 965 966else 967# Scripts read from the filesystem. 968 969cat >>e${EMULATION_NAME}.c <<EOF 970{ 971 *isfile = 1; 972 973 if (link_info.relocateable == true && config.build_constructors == true) 974 return "ldscripts/${EMULATION_NAME}.xu"; 975 else if (link_info.relocateable == true) 976 return "ldscripts/${EMULATION_NAME}.xr"; 977 else if (!config.text_read_only) 978 return "ldscripts/${EMULATION_NAME}.xbn"; 979 else if (!config.magic_demand_paged) 980 return "ldscripts/${EMULATION_NAME}.xn"; 981 else if (link_info.shared) 982 return "ldscripts/${EMULATION_NAME}.xs"; 983 else 984 return "ldscripts/${EMULATION_NAME}.x"; 985} 986EOF 987 988fi 989 990cat >>e${EMULATION_NAME}.c <<EOF 991 992struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = 993{ 994 gld${EMULATION_NAME}_before_parse, 995 syslib_default, 996 hll_default, 997 after_parse_default, 998 gld${EMULATION_NAME}_after_open, 999 after_allocation_default, 1000 set_output_arch_default, 1001 ldemul_default_target, 1002 gld${EMULATION_NAME}_before_allocation, 1003 gld${EMULATION_NAME}_get_script, 1004 "${EMULATION_NAME}", 1005 "${OUTPUT_FORMAT}", 1006 NULL, 1007 NULL, 1008 gld${EMULATION_NAME}_open_dynamic_archive, 1009 gld${EMULATION_NAME}_place_orphan 1010}; 1011EOF 1012