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 6if [ -z "$MACHINE" ]; then 7 OUTPUT_ARCH=${ARCH} 8else 9 OUTPUT_ARCH=${ARCH}:${MACHINE} 10fi 11cat >e${EMULATION_NAME}.c <<EOF 12/* This file is is generated by a shell script. DO NOT EDIT! */ 13 14/* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME} 15 Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 16 2002, 2003, 2004 Free Software Foundation, Inc. 17 Written by Steve Chamberlain <sac@cygnus.com> 18 ELF support by Ian Lance Taylor <ian@cygnus.com> 19 20This file is part of GLD, the Gnu Linker. 21 22This program is free software; you can redistribute it and/or modify 23it under the terms of the GNU General Public License as published by 24the Free Software Foundation; either version 2 of the License, or 25(at your option) any later version. 26 27This program is distributed in the hope that it will be useful, 28but WITHOUT ANY WARRANTY; without even the implied warranty of 29MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 30GNU General Public License for more details. 31 32You should have received a copy of the GNU General Public License 33along with this program; if not, write to the Free Software 34Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 35 36#define TARGET_IS_${EMULATION_NAME} 37 38#include "bfd.h" 39#include "sysdep.h" 40#include "libiberty.h" 41#include "safe-ctype.h" 42#include "getopt.h" 43 44#include "bfdlink.h" 45 46#include "ld.h" 47#include "ldmain.h" 48#include "ldmisc.h" 49#include "ldexp.h" 50#include "ldlang.h" 51#include "ldfile.h" 52#include "ldemul.h" 53#include <ldgram.h> 54#include "elf/common.h" 55 56/* Declare functions used by various EXTRA_EM_FILEs. */ 57static void gld${EMULATION_NAME}_before_parse (void); 58static void gld${EMULATION_NAME}_after_open (void); 59static void gld${EMULATION_NAME}_before_allocation (void); 60static bfd_boolean gld${EMULATION_NAME}_place_orphan 61 (lang_input_statement_type *file, asection *s); 62static void gld${EMULATION_NAME}_finish (void); 63 64EOF 65 66# Import any needed special functions and/or overrides. 67# 68if test -n "$EXTRA_EM_FILE" ; then 69. ${srcdir}/emultempl/${EXTRA_EM_FILE}.em 70fi 71 72# Functions in this file can be overridden by setting the LDEMUL_* shell 73# variables. If the name of the overriding function is the same as is 74# defined in this file, then don't output this file's version. 75# If a different overriding name is given then output the standard function 76# as presumably it is called from the overriding function. 77# 78if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then 79cat >>e${EMULATION_NAME}.c <<EOF 80 81static void 82gld${EMULATION_NAME}_before_parse (void) 83{ 84 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`); 85 config.dynamic_link = ${DYNAMIC_LINK-TRUE}; 86 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`; 87} 88 89EOF 90fi 91 92if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then 93cat >>e${EMULATION_NAME}.c <<EOF 94/* Handle as_needed DT_NEEDED. */ 95 96static bfd_boolean 97gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry) 98{ 99 if (!entry->as_needed 100 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0) 101 return FALSE; 102 103 /* Tell the ELF linker that we don't want the output file to have a 104 DT_NEEDED entry for this file, unless it is used to resolve 105 references in a regular object. */ 106 bfd_elf_set_dyn_lib_class (entry->the_bfd, DYN_AS_NEEDED); 107 108 /* Continue on with normal load_symbols processing. */ 109 return FALSE; 110} 111EOF 112fi 113 114cat >>e${EMULATION_NAME}.c <<EOF 115 116/* These variables are required to pass information back and forth 117 between after_open and check_needed and stat_needed and vercheck. */ 118 119static struct bfd_link_needed_list *global_needed; 120static struct stat global_stat; 121static bfd_boolean global_found; 122static struct bfd_link_needed_list *global_vercheck_needed; 123static bfd_boolean global_vercheck_failed; 124 125 126/* On Linux, it's possible to have different versions of the same 127 shared library linked against different versions of libc. The 128 dynamic linker somehow tags which libc version to use in 129 /etc/ld.so.cache, and, based on the libc that it sees in the 130 executable, chooses which version of the shared library to use. 131 132 We try to do a similar check here by checking whether this shared 133 library needs any other shared libraries which may conflict with 134 libraries we have already included in the link. If it does, we 135 skip it, and try to find another shared library farther on down the 136 link path. 137 138 This is called via lang_for_each_input_file. 139 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object 140 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find 141 a conflicting version. */ 142 143static void 144gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s) 145{ 146 const char *soname; 147 struct bfd_link_needed_list *l; 148 149 if (global_vercheck_failed) 150 return; 151 if (s->the_bfd == NULL 152 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0) 153 return; 154 155 soname = bfd_elf_get_dt_soname (s->the_bfd); 156 if (soname == NULL) 157 soname = lbasename (bfd_get_filename (s->the_bfd)); 158 159 for (l = global_vercheck_needed; l != NULL; l = l->next) 160 { 161 const char *suffix; 162 163 if (strcmp (soname, l->name) == 0) 164 { 165 /* Probably can't happen, but it's an easy check. */ 166 continue; 167 } 168 169 if (strchr (l->name, '/') != NULL) 170 continue; 171 172 suffix = strstr (l->name, ".so."); 173 if (suffix == NULL) 174 continue; 175 176 suffix += sizeof ".so." - 1; 177 178 if (strncmp (soname, l->name, suffix - l->name) == 0) 179 { 180 /* Here we know that S is a dynamic object FOO.SO.VER1, and 181 the object we are considering needs a dynamic object 182 FOO.SO.VER2, and VER1 and VER2 are different. This 183 appears to be a version mismatch, so we tell the caller 184 to try a different version of this library. */ 185 global_vercheck_failed = TRUE; 186 return; 187 } 188 } 189} 190 191 192/* See if an input file matches a DT_NEEDED entry by running stat on 193 the file. */ 194 195static void 196gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s) 197{ 198 struct stat st; 199 const char *suffix; 200 const char *soname; 201 202 if (global_found) 203 return; 204 if (s->the_bfd == NULL) 205 return; 206 207 if (bfd_stat (s->the_bfd, &st) != 0) 208 { 209 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd); 210 return; 211 } 212 213 if (st.st_dev == global_stat.st_dev 214 && st.st_ino == global_stat.st_ino) 215 { 216 global_found = TRUE; 217 return; 218 } 219 220 /* We issue a warning if it looks like we are including two 221 different versions of the same shared library. For example, 222 there may be a problem if -lc picks up libc.so.6 but some other 223 shared library has a DT_NEEDED entry of libc.so.5. This is a 224 heuristic test, and it will only work if the name looks like 225 NAME.so.VERSION. FIXME: Depending on file names is error-prone. 226 If we really want to issue warnings about mixing version numbers 227 of shared libraries, we need to find a better way. */ 228 229 if (strchr (global_needed->name, '/') != NULL) 230 return; 231 suffix = strstr (global_needed->name, ".so."); 232 if (suffix == NULL) 233 return; 234 suffix += sizeof ".so." - 1; 235 236 soname = bfd_elf_get_dt_soname (s->the_bfd); 237 if (soname == NULL) 238 soname = lbasename (s->filename); 239 240 if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0) 241 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n", 242 global_needed->name, global_needed->by, soname); 243} 244 245 246/* This function is called for each possible name for a dynamic object 247 named by a DT_NEEDED entry. The FORCE parameter indicates whether 248 to skip the check for a conflicting version. */ 249 250static bfd_boolean 251gld${EMULATION_NAME}_try_needed (const char *name, int force) 252{ 253 bfd *abfd; 254 const char *soname; 255 256 abfd = bfd_openr (name, bfd_get_target (output_bfd)); 257 if (abfd == NULL) 258 return FALSE; 259 if (! bfd_check_format (abfd, bfd_object)) 260 { 261 bfd_close (abfd); 262 return FALSE; 263 } 264 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0) 265 { 266 bfd_close (abfd); 267 return FALSE; 268 } 269 270 /* For DT_NEEDED, they have to match. */ 271 if (abfd->xvec != output_bfd->xvec) 272 { 273 bfd_close (abfd); 274 return FALSE; 275 } 276 277 /* Check whether this object would include any conflicting library 278 versions. If FORCE is set, then we skip this check; we use this 279 the second time around, if we couldn't find any compatible 280 instance of the shared library. */ 281 282 if (! force) 283 { 284 struct bfd_link_needed_list *needed; 285 286 if (! bfd_elf_get_bfd_needed_list (abfd, &needed)) 287 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd); 288 289 if (needed != NULL) 290 { 291 global_vercheck_needed = needed; 292 global_vercheck_failed = FALSE; 293 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck); 294 if (global_vercheck_failed) 295 { 296 bfd_close (abfd); 297 /* Return FALSE to force the caller to move on to try 298 another file on the search path. */ 299 return FALSE; 300 } 301 302 /* But wait! It gets much worse. On Linux, if a shared 303 library does not use libc at all, we are supposed to skip 304 it the first time around in case we encounter a shared 305 library later on with the same name which does use the 306 version of libc that we want. This is much too horrible 307 to use on any system other than Linux. */ 308 309EOF 310case ${target} in 311 *-*-linux-gnu*) 312 cat >>e${EMULATION_NAME}.c <<EOF 313 { 314 struct bfd_link_needed_list *l; 315 316 for (l = needed; l != NULL; l = l->next) 317 if (strncmp (l->name, "libc.so", 7) == 0) 318 break; 319 if (l == NULL) 320 { 321 bfd_close (abfd); 322 return FALSE; 323 } 324 } 325 326EOF 327 ;; 328esac 329cat >>e${EMULATION_NAME}.c <<EOF 330 } 331 } 332 333 /* We've found a dynamic object matching the DT_NEEDED entry. */ 334 335 /* We have already checked that there is no other input file of the 336 same name. We must now check again that we are not including the 337 same file twice. We need to do this because on many systems 338 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will 339 reference libc.so.1. If we have already included libc.so, we 340 don't want to include libc.so.1 if they are the same file, and we 341 can only check that using stat. */ 342 343 if (bfd_stat (abfd, &global_stat) != 0) 344 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd); 345 346 /* First strip off everything before the last '/'. */ 347 soname = lbasename (abfd->filename); 348 349 if (trace_file_tries) 350 info_msg (_("found %s at %s\n"), soname, name); 351 352 global_found = FALSE; 353 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed); 354 if (global_found) 355 { 356 /* Return TRUE to indicate that we found the file, even though 357 we aren't going to do anything with it. */ 358 return TRUE; 359 } 360 361 /* Specify the soname to use. */ 362 bfd_elf_set_dt_needed_name (abfd, soname); 363 364 /* Tell the ELF linker that we don't want the output file to have a 365 DT_NEEDED entry for this file, unless it is used to resolve 366 references in a regular object. */ 367 bfd_elf_set_dyn_lib_class (abfd, DYN_DT_NEEDED); 368 369 /* Add this file into the symbol table. */ 370 if (! bfd_link_add_symbols (abfd, &link_info)) 371 einfo ("%F%B: could not read symbols: %E\n", abfd); 372 373 return TRUE; 374} 375 376 377/* Search for a needed file in a path. */ 378 379static bfd_boolean 380gld${EMULATION_NAME}_search_needed (const char *path, const char *name, int force) 381{ 382 const char *s; 383 size_t len; 384 385 if (name[0] == '/') 386 return gld${EMULATION_NAME}_try_needed (name, force); 387 388 if (path == NULL || *path == '\0') 389 return FALSE; 390 len = strlen (name); 391 while (1) 392 { 393 char *filename, *sset; 394 395 s = strchr (path, ':'); 396 if (s == NULL) 397 s = path + strlen (path); 398 399 filename = (char *) xmalloc (s - path + len + 2); 400 if (s == path) 401 sset = filename; 402 else 403 { 404 memcpy (filename, path, s - path); 405 filename[s - path] = '/'; 406 sset = filename + (s - path) + 1; 407 } 408 strcpy (sset, name); 409 410 if (gld${EMULATION_NAME}_try_needed (filename, force)) 411 return TRUE; 412 413 free (filename); 414 415 if (*s == '\0') 416 break; 417 path = s + 1; 418 } 419 420 return FALSE; 421} 422 423EOF 424if [ "x${USE_LIBPATH}" = xyes ] ; then 425 cat >>e${EMULATION_NAME}.c <<EOF 426 427/* Add the sysroot to every entry in a colon-separated path. */ 428 429static char * 430gld${EMULATION_NAME}_add_sysroot (const char *path) 431{ 432 int len, colons, i; 433 char *ret, *p; 434 435 len = strlen (path); 436 colons = 0; 437 i = 0; 438 while (path[i]) 439 if (path[i++] == ':') 440 colons++; 441 442 if (path[i]) 443 colons++; 444 445 len = len + (colons + 1) * strlen (ld_sysroot); 446 ret = xmalloc (len + 1); 447 strcpy (ret, ld_sysroot); 448 p = ret + strlen (ret); 449 i = 0; 450 while (path[i]) 451 if (path[i] == ':') 452 { 453 *p++ = path[i++]; 454 strcpy (p, ld_sysroot); 455 p = p + strlen (p); 456 } 457 else 458 *p++ = path[i++]; 459 460 *p = 0; 461 return ret; 462} 463 464EOF 465 case ${target} in 466 *-*-linux-gnu*) 467 cat >>e${EMULATION_NAME}.c <<EOF 468/* For a native linker, check the file /etc/ld.so.conf for directories 469 in which we may find shared libraries. /etc/ld.so.conf is really 470 only meaningful on Linux. */ 471 472static bfd_boolean 473gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force) 474{ 475 static bfd_boolean initialized; 476 static char *ld_so_conf; 477 478 if (! initialized) 479 { 480 FILE *f; 481 char *tmppath; 482 483 tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL); 484 f = fopen (tmppath, FOPEN_RT); 485 free (tmppath); 486 if (f != NULL) 487 { 488 char *b; 489 size_t len, alloc; 490 int c; 491 492 len = 0; 493 alloc = 100; 494 b = (char *) xmalloc (alloc); 495 496 while ((c = getc (f)) != EOF) 497 { 498 if (len + 1 >= alloc) 499 { 500 alloc *= 2; 501 b = (char *) xrealloc (b, alloc); 502 } 503 if (c != ':' 504 && c != ' ' 505 && c != '\t' 506 && c != '\n' 507 && c != ',') 508 { 509 b[len] = c; 510 ++len; 511 } 512 else 513 { 514 if (len > 0 && b[len - 1] != ':') 515 { 516 b[len] = ':'; 517 ++len; 518 } 519 } 520 } 521 522 if (len > 0 && b[len - 1] == ':') 523 --len; 524 525 if (len > 0) 526 b[len] = '\0'; 527 else 528 { 529 free (b); 530 b = NULL; 531 } 532 533 fclose (f); 534 535 if (b) 536 { 537 char *d = gld${EMULATION_NAME}_add_sysroot (b); 538 free (b); 539 b = d; 540 } 541 542 ld_so_conf = b; 543 } 544 545 initialized = TRUE; 546 } 547 548 if (ld_so_conf == NULL) 549 return FALSE; 550 551 return gld${EMULATION_NAME}_search_needed (ld_so_conf, name, force); 552} 553 554EOF 555 # Linux 556 ;; 557 esac 558fi 559cat >>e${EMULATION_NAME}.c <<EOF 560 561/* See if an input file matches a DT_NEEDED entry by name. */ 562 563static void 564gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s) 565{ 566 if (global_found) 567 return; 568 569 if (s->filename != NULL) 570 { 571 const char *f; 572 573 if (strcmp (s->filename, global_needed->name) == 0) 574 { 575 global_found = TRUE; 576 return; 577 } 578 579 if (s->search_dirs_flag) 580 { 581 f = strrchr (s->filename, '/'); 582 if (f != NULL 583 && strcmp (f + 1, global_needed->name) == 0) 584 { 585 global_found = TRUE; 586 return; 587 } 588 } 589 } 590 591 if (s->the_bfd != NULL) 592 { 593 const char *soname; 594 595 soname = bfd_elf_get_dt_soname (s->the_bfd); 596 if (soname != NULL 597 && strcmp (soname, global_needed->name) == 0) 598 { 599 global_found = TRUE; 600 return; 601 } 602 } 603} 604 605EOF 606 607if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then 608cat >>e${EMULATION_NAME}.c <<EOF 609 610/* This is called after all the input files have been opened. */ 611 612static void 613gld${EMULATION_NAME}_after_open (void) 614{ 615 struct bfd_link_needed_list *needed, *l; 616 617 /* We only need to worry about this when doing a final link. */ 618 if (link_info.relocatable || !link_info.executable) 619 return; 620 621 /* Get the list of files which appear in DT_NEEDED entries in 622 dynamic objects included in the link (often there will be none). 623 For each such file, we want to track down the corresponding 624 library, and include the symbol table in the link. This is what 625 the runtime dynamic linker will do. Tracking the files down here 626 permits one dynamic object to include another without requiring 627 special action by the person doing the link. Note that the 628 needed list can actually grow while we are stepping through this 629 loop. */ 630 needed = bfd_elf_get_needed_list (output_bfd, &link_info); 631 for (l = needed; l != NULL; l = l->next) 632 { 633 struct bfd_link_needed_list *ll; 634 int force; 635 636 /* If we've already seen this file, skip it. */ 637 for (ll = needed; ll != l; ll = ll->next) 638 if (strcmp (ll->name, l->name) == 0) 639 break; 640 if (ll != l) 641 continue; 642 643 /* See if this file was included in the link explicitly. */ 644 global_needed = l; 645 global_found = FALSE; 646 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed); 647 if (global_found) 648 continue; 649 650 if (trace_file_tries) 651 info_msg (_("%s needed by %B\n"), l->name, l->by); 652 653 /* We need to find this file and include the symbol table. We 654 want to search for the file in the same way that the dynamic 655 linker will search. That means that we want to use 656 rpath_link, rpath, then the environment variable 657 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH 658 entries (native only), then the linker script LIB_SEARCH_DIRS. 659 We do not search using the -L arguments. 660 661 We search twice. The first time, we skip objects which may 662 introduce version mismatches. The second time, we force 663 their use. See gld${EMULATION_NAME}_vercheck comment. */ 664 for (force = 0; force < 2; force++) 665 { 666 size_t len; 667 search_dirs_type *search; 668EOF 669if [ "x${USE_LIBPATH}" = xyes ] ; then 670cat >>e${EMULATION_NAME}.c <<EOF 671 const char *lib_path; 672 struct bfd_link_needed_list *rp; 673 int found; 674EOF 675fi 676cat >>e${EMULATION_NAME}.c <<EOF 677 678 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link, 679 l->name, force)) 680 break; 681EOF 682if [ "x${USE_LIBPATH}" = xyes ] ; then 683cat >>e${EMULATION_NAME}.c <<EOF 684 if (gld${EMULATION_NAME}_search_needed (command_line.rpath, 685 l->name, force)) 686 break; 687EOF 688fi 689if [ "x${NATIVE}" = xyes ] ; then 690cat >>e${EMULATION_NAME}.c <<EOF 691 if (command_line.rpath_link == NULL 692 && command_line.rpath == NULL) 693 { 694 lib_path = (const char *) getenv ("LD_RUN_PATH"); 695 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, 696 force)) 697 break; 698 } 699 lib_path = (const char *) getenv ("LD_LIBRARY_PATH"); 700 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, force)) 701 break; 702EOF 703fi 704if [ "x${USE_LIBPATH}" = xyes ] ; then 705cat >>e${EMULATION_NAME}.c <<EOF 706 found = 0; 707 rp = bfd_elf_get_runpath_list (output_bfd, &link_info); 708 for (; !found && rp != NULL; rp = rp->next) 709 { 710 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name); 711 found = (rp->by == l->by 712 && gld${EMULATION_NAME}_search_needed (tmpname, 713 l->name, 714 force)); 715 free (tmpname); 716 } 717 if (found) 718 break; 719 720EOF 721fi 722cat >>e${EMULATION_NAME}.c <<EOF 723 len = strlen (l->name); 724 for (search = search_head; search != NULL; search = search->next) 725 { 726 char *filename; 727 728 if (search->cmdline) 729 continue; 730 filename = (char *) xmalloc (strlen (search->name) + len + 2); 731 sprintf (filename, "%s/%s", search->name, l->name); 732 if (gld${EMULATION_NAME}_try_needed (filename, force)) 733 break; 734 free (filename); 735 } 736 if (search != NULL) 737 break; 738EOF 739if [ "x${USE_LIBPATH}" = xyes ] ; then 740 case ${target} in 741 *-*-linux-gnu*) 742 cat >>e${EMULATION_NAME}.c <<EOF 743 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force)) 744 break; 745EOF 746 # Linux 747 ;; 748 esac 749fi 750cat >>e${EMULATION_NAME}.c <<EOF 751 } 752 753 if (force < 2) 754 continue; 755 756 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n", 757 l->name, l->by); 758 } 759} 760 761EOF 762fi 763 764cat >>e${EMULATION_NAME}.c <<EOF 765 766/* Look through an expression for an assignment statement. */ 767 768static void 769gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp) 770{ 771 struct bfd_link_hash_entry *h; 772 773 switch (exp->type.node_class) 774 { 775 case etree_provide: 776 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst, 777 FALSE, FALSE, FALSE); 778 if (h == NULL) 779 break; 780 781 /* We call record_link_assignment even if the symbol is defined. 782 This is because if it is defined by a dynamic object, we 783 actually want to use the value defined by the linker script, 784 not the value from the dynamic object (because we are setting 785 symbols like etext). If the symbol is defined by a regular 786 object, then, as it happens, calling record_link_assignment 787 will do no harm. */ 788 789 /* Fall through. */ 790 case etree_assign: 791 if (strcmp (exp->assign.dst, ".") != 0) 792 { 793 if (! (bfd_elf_record_link_assignment 794 (output_bfd, &link_info, exp->assign.dst, 795 exp->type.node_class == etree_provide ? TRUE : FALSE))) 796 einfo ("%P%F: failed to record assignment to %s: %E\n", 797 exp->assign.dst); 798 } 799 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src); 800 break; 801 802 case etree_binary: 803 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs); 804 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs); 805 break; 806 807 case etree_trinary: 808 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond); 809 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs); 810 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs); 811 break; 812 813 case etree_unary: 814 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child); 815 break; 816 817 default: 818 break; 819 } 820} 821 822 823/* This is called by the before_allocation routine via 824 lang_for_each_statement. It locates any assignment statements, and 825 tells the ELF backend about them, in case they are assignments to 826 symbols which are referred to by dynamic objects. */ 827 828static void 829gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s) 830{ 831 if (s->header.type == lang_assignment_statement_enum) 832 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp); 833} 834 835EOF 836 837if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then 838 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then 839 ELF_INTERPRETER_SET_DEFAULT=" 840 if (sinterp != NULL) 841 { 842 sinterp->contents = ${ELF_INTERPRETER_NAME}; 843 sinterp->_raw_size = strlen (sinterp->contents) + 1; 844 } 845 846" 847 else 848 ELF_INTERPRETER_SET_DEFAULT= 849 fi 850cat >>e${EMULATION_NAME}.c <<EOF 851 852/* This is called after the sections have been attached to output 853 sections, but before any sizes or addresses have been set. */ 854 855static void 856gld${EMULATION_NAME}_before_allocation (void) 857{ 858 const char *rpath; 859 asection *sinterp; 860 861 if (link_info.hash->type == bfd_link_elf_hash_table) 862 _bfd_elf_tls_setup (output_bfd, &link_info); 863 864 /* If we are going to make any variable assignments, we need to let 865 the ELF backend know about them in case the variables are 866 referred to by dynamic objects. */ 867 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment); 868 869 /* Let the ELF backend work out the sizes of any sections required 870 by dynamic linking. */ 871 rpath = command_line.rpath; 872 if (rpath == NULL) 873 rpath = (const char *) getenv ("LD_RUN_PATH"); 874 if (! (bfd_elf_size_dynamic_sections 875 (output_bfd, command_line.soname, rpath, 876 command_line.filter_shlib, 877 (const char * const *) command_line.auxiliary_filters, 878 &link_info, &sinterp, lang_elf_version_info))) 879 einfo ("%P%F: failed to set dynamic section sizes: %E\n"); 880${ELF_INTERPRETER_SET_DEFAULT} 881 /* Let the user override the dynamic linker we are using. */ 882 if (command_line.interpreter != NULL 883 && sinterp != NULL) 884 { 885 sinterp->contents = (bfd_byte *) command_line.interpreter; 886 sinterp->_raw_size = strlen (command_line.interpreter) + 1; 887 } 888 889 /* Look for any sections named .gnu.warning. As a GNU extensions, 890 we treat such sections as containing warning messages. We print 891 out the warning message, and then zero out the section size so 892 that it does not get copied into the output file. */ 893 894 { 895 LANG_FOR_EACH_INPUT_STATEMENT (is) 896 { 897 asection *s; 898 bfd_size_type sz; 899 bfd_size_type prefix_len; 900 char *msg; 901 bfd_boolean ret; 902 const char * gnu_warning_prefix = _("warning: "); 903 904 if (is->just_syms_flag) 905 continue; 906 907 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning"); 908 if (s == NULL) 909 continue; 910 911 sz = bfd_section_size (is->the_bfd, s); 912 prefix_len = strlen (gnu_warning_prefix); 913 msg = xmalloc ((size_t) (prefix_len + sz + 1)); 914 strcpy (msg, gnu_warning_prefix); 915 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len, 916 (file_ptr) 0, sz)) 917 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n", 918 is->the_bfd); 919 msg[prefix_len + sz] = '\0'; 920 ret = link_info.callbacks->warning (&link_info, msg, 921 (const char *) NULL, 922 is->the_bfd, (asection *) NULL, 923 (bfd_vma) 0); 924 ASSERT (ret); 925 free (msg); 926 927 /* Clobber the section size, so that we don't waste copying the 928 warning into the output file. */ 929 s->_raw_size = 0; 930 } 931 } 932} 933 934EOF 935fi 936 937if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then 938cat >>e${EMULATION_NAME}.c <<EOF 939 940/* Try to open a dynamic archive. This is where we know that ELF 941 dynamic libraries have an extension of .so (or .sl on oddball systems 942 like hpux). */ 943 944static bfd_boolean 945gld${EMULATION_NAME}_open_dynamic_archive 946 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry) 947{ 948 const char *filename; 949 char *string; 950 951 if (! entry->is_archive) 952 return FALSE; 953 954 filename = entry->filename; 955 956 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION 957 is defined, but it does not seem worth the headache to optimize 958 away those two bytes of space. */ 959 string = (char *) xmalloc (strlen (search->name) 960 + strlen (filename) 961 + strlen (arch) 962#ifdef EXTRA_SHLIB_EXTENSION 963 + strlen (EXTRA_SHLIB_EXTENSION) 964#endif 965 + sizeof "/lib.so"); 966 967 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch); 968 969#ifdef EXTRA_SHLIB_EXTENSION 970 /* Try the .so extension first. If that fails build a new filename 971 using EXTRA_SHLIB_EXTENSION. */ 972 if (! ldfile_try_open_bfd (string, entry)) 973 sprintf (string, "%s/lib%s%s%s", search->name, 974 filename, arch, EXTRA_SHLIB_EXTENSION); 975#endif 976 977 if (! ldfile_try_open_bfd (string, entry)) 978 { 979 free (string); 980 return FALSE; 981 } 982 983 entry->filename = string; 984 985 /* We have found a dynamic object to include in the link. The ELF 986 backend linker will create a DT_NEEDED entry in the .dynamic 987 section naming this file. If this file includes a DT_SONAME 988 entry, it will be used. Otherwise, the ELF linker will just use 989 the name of the file. For an archive found by searching, like 990 this one, the DT_NEEDED entry should consist of just the name of 991 the file, without the path information used to find it. Note 992 that we only need to do this if we have a dynamic object; an 993 archive will never be referenced by a DT_NEEDED entry. 994 995 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not 996 very pretty. I haven't been able to think of anything that is 997 pretty, though. */ 998 if (bfd_check_format (entry->the_bfd, bfd_object) 999 && (entry->the_bfd->flags & DYNAMIC) != 0) 1000 { 1001 ASSERT (entry->is_archive && entry->search_dirs_flag); 1002 1003 /* Rather than duplicating the logic above. Just use the 1004 filename we recorded earlier. */ 1005 1006 filename = lbasename (entry->filename); 1007 bfd_elf_set_dt_needed_name (entry->the_bfd, filename); 1008 } 1009 1010 return TRUE; 1011} 1012 1013EOF 1014fi 1015 1016if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then 1017cat >>e${EMULATION_NAME}.c <<EOF 1018 1019/* A variant of lang_output_section_find. Used by place_orphan. */ 1020 1021static lang_output_section_statement_type * 1022output_rel_find (asection *sec, int isdyn) 1023{ 1024 lang_statement_union_type *u; 1025 lang_output_section_statement_type *lookup; 1026 lang_output_section_statement_type *last = NULL; 1027 lang_output_section_statement_type *last_alloc = NULL; 1028 lang_output_section_statement_type *last_rel = NULL; 1029 lang_output_section_statement_type *last_rel_alloc = NULL; 1030 int rela = sec->name[4] == 'a'; 1031 1032 for (u = lang_output_section_statement.head; u; u = lookup->next) 1033 { 1034 lookup = &u->output_section_statement; 1035 if (strncmp (".rel", lookup->name, 4) == 0) 1036 { 1037 int lookrela = lookup->name[4] == 'a'; 1038 1039 /* .rel.dyn must come before all other reloc sections, to suit 1040 GNU ld.so. */ 1041 if (isdyn) 1042 break; 1043 1044 /* Don't place after .rel.plt as doing so results in wrong 1045 dynamic tags. */ 1046 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0) 1047 break; 1048 1049 if (rela == lookrela || last_rel == NULL) 1050 last_rel = lookup; 1051 if ((rela == lookrela || last_rel_alloc == NULL) 1052 && lookup->bfd_section != NULL 1053 && (lookup->bfd_section->flags & SEC_ALLOC) != 0) 1054 last_rel_alloc = lookup; 1055 } 1056 1057 last = lookup; 1058 if (lookup->bfd_section != NULL 1059 && (lookup->bfd_section->flags & SEC_ALLOC) != 0) 1060 last_alloc = lookup; 1061 } 1062 1063 if (last_rel_alloc) 1064 return last_rel_alloc; 1065 1066 if (last_rel) 1067 return last_rel; 1068 1069 if (last_alloc) 1070 return last_alloc; 1071 1072 return last; 1073} 1074 1075/* Find the last output section before given output statement. 1076 Used by place_orphan. */ 1077 1078static asection * 1079output_prev_sec_find (lang_output_section_statement_type *os) 1080{ 1081 asection *s = (asection *) NULL; 1082 lang_statement_union_type *u; 1083 lang_output_section_statement_type *lookup; 1084 1085 for (u = lang_output_section_statement.head; 1086 u != (lang_statement_union_type *) NULL; 1087 u = lookup->next) 1088 { 1089 lookup = &u->output_section_statement; 1090 if (lookup == os) 1091 return s; 1092 1093 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL) 1094 s = lookup->bfd_section; 1095 } 1096 1097 return NULL; 1098} 1099 1100/* Place an orphan section. We use this to put random SHF_ALLOC 1101 sections in the right segment. */ 1102 1103struct orphan_save { 1104 lang_output_section_statement_type *os; 1105 asection **section; 1106 lang_statement_union_type **stmt; 1107 lang_statement_union_type **os_tail; 1108}; 1109 1110static bfd_boolean 1111gld${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s) 1112{ 1113 static struct orphan_save hold_text; 1114 static struct orphan_save hold_rodata; 1115 static struct orphan_save hold_data; 1116 static struct orphan_save hold_bss; 1117 static struct orphan_save hold_rel; 1118 static struct orphan_save hold_interp; 1119 static struct orphan_save hold_sdata; 1120 static int count = 1; 1121 struct orphan_save *place; 1122 lang_statement_list_type *old; 1123 lang_statement_list_type add; 1124 etree_type *address; 1125 const char *secname; 1126 const char *ps = NULL; 1127 lang_output_section_statement_type *os; 1128 lang_statement_union_type **os_tail; 1129 etree_type *load_base; 1130 int isdyn = 0; 1131 1132 secname = bfd_get_section_name (s->owner, s); 1133 if (! link_info.relocatable 1134 && link_info.combreloc 1135 && (s->flags & SEC_ALLOC) 1136 && strncmp (secname, ".rel", 4) == 0) 1137 { 1138 if (secname[4] == 'a') 1139 secname = ".rela.dyn"; 1140 else 1141 secname = ".rel.dyn"; 1142 isdyn = 1; 1143 } 1144 1145 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (secname))) 1146 { 1147 /* Look through the script to see where to place this section. */ 1148 os = lang_output_section_find (secname); 1149 1150 if (os != NULL 1151 && (os->bfd_section == NULL 1152 || ((s->flags ^ os->bfd_section->flags) 1153 & (SEC_LOAD | SEC_ALLOC)) == 0)) 1154 { 1155 /* We already have an output section statement with this 1156 name, and its bfd section, if any, has compatible flags. */ 1157 lang_add_section (&os->children, s, os, file); 1158 return TRUE; 1159 } 1160 } 1161 1162 if (hold_text.os == NULL) 1163 hold_text.os = lang_output_section_find (".text"); 1164 1165 /* If this is a final link, then always put .gnu.warning.SYMBOL 1166 sections into the .text section to get them out of the way. */ 1167 if (link_info.executable 1168 && ! link_info.relocatable 1169 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0 1170 && hold_text.os != NULL) 1171 { 1172 lang_add_section (&hold_text.os->children, s, hold_text.os, file); 1173 return TRUE; 1174 } 1175 1176 /* Decide which segment the section should go in based on the 1177 section name and section flags. We put loadable .note sections 1178 right after the .interp section, so that the PT_NOTE segment is 1179 stored right after the program headers where the OS can read it 1180 in the first page. */ 1181#define HAVE_SECTION(hold, name) \ 1182(hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL) 1183 1184 if ((s->flags & SEC_EXCLUDE) != 0 && !link_info.relocatable) 1185 { 1186 if (s->output_section == NULL) 1187 s->output_section = bfd_abs_section_ptr; 1188 return TRUE; 1189 } 1190 1191 place = NULL; 1192 if ((s->flags & SEC_ALLOC) == 0) 1193 ; 1194 else if ((s->flags & SEC_LOAD) != 0 1195 && strncmp (secname, ".note", 5) == 0 1196 && HAVE_SECTION (hold_interp, ".interp")) 1197 place = &hold_interp; 1198 else if ((s->flags & SEC_HAS_CONTENTS) == 0 1199 && HAVE_SECTION (hold_bss, ".bss")) 1200 place = &hold_bss; 1201 else if ((s->flags & SEC_SMALL_DATA) != 0 1202 && HAVE_SECTION (hold_sdata, ".sdata")) 1203 place = &hold_sdata; 1204 else if ((s->flags & SEC_READONLY) == 0 1205 && HAVE_SECTION (hold_data, ".data")) 1206 place = &hold_data; 1207 else if (strncmp (secname, ".rel", 4) == 0 1208 && (s->flags & SEC_LOAD) != 0 1209 && (hold_rel.os != NULL 1210 || (hold_rel.os = output_rel_find (s, isdyn)) != NULL)) 1211 place = &hold_rel; 1212 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == SEC_READONLY 1213 && HAVE_SECTION (hold_rodata, ".rodata")) 1214 place = &hold_rodata; 1215 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == (SEC_CODE | SEC_READONLY) 1216 && hold_text.os != NULL) 1217 place = &hold_text; 1218 1219#undef HAVE_SECTION 1220 1221 /* Choose a unique name for the section. This will be needed if the 1222 same section name appears in the input file with different 1223 loadable or allocatable characteristics. */ 1224 if (bfd_get_section_by_name (output_bfd, secname) != NULL) 1225 { 1226 secname = bfd_get_unique_section_name (output_bfd, secname, &count); 1227 if (secname == NULL) 1228 einfo ("%F%P: place_orphan failed: %E\n"); 1229 } 1230 1231 /* Start building a list of statements for this section. 1232 First save the current statement pointer. */ 1233 old = stat_ptr; 1234 1235 /* If we have found an appropriate place for the output section 1236 statements for this orphan, add them to our own private list, 1237 inserting them later into the global statement list. */ 1238 if (place != NULL) 1239 { 1240 stat_ptr = &add; 1241 lang_list_init (stat_ptr); 1242 } 1243 1244 if (config.build_constructors) 1245 { 1246 /* If the name of the section is representable in C, then create 1247 symbols to mark the start and the end of the section. */ 1248 for (ps = secname; *ps != '\0'; ps++) 1249 if (! ISALNUM (*ps) && *ps != '_') 1250 break; 1251 if (*ps == '\0') 1252 { 1253 char *symname; 1254 etree_type *e_align; 1255 1256 symname = (char *) xmalloc (ps - secname + sizeof "__start_"); 1257 sprintf (symname, "__start_%s", secname); 1258 e_align = exp_unop (ALIGN_K, 1259 exp_intop ((bfd_vma) 1 << s->alignment_power)); 1260 lang_add_assignment (exp_assop ('=', symname, e_align)); 1261 } 1262 } 1263 1264 address = NULL; 1265 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0) 1266 address = exp_intop ((bfd_vma) 0); 1267 1268 load_base = NULL; 1269 if (place != NULL && place->os->load_base != NULL) 1270 { 1271 etree_type *lma_from_vma; 1272 lma_from_vma = exp_binop ('-', place->os->load_base, 1273 exp_nameop (ADDR, place->os->name)); 1274 load_base = exp_binop ('+', lma_from_vma, 1275 exp_nameop (ADDR, secname)); 1276 } 1277 1278 os_tail = lang_output_section_statement.tail; 1279 os = lang_enter_output_section_statement (secname, address, 0, 1280 (etree_type *) NULL, 1281 (etree_type *) NULL, 1282 load_base); 1283 1284 lang_add_section (&os->children, s, os, file); 1285 1286 lang_leave_output_section_statement 1287 ((bfd_vma) 0, "*default*", 1288 (struct lang_output_section_phdr_list *) NULL, NULL); 1289 1290 if (config.build_constructors && *ps == '\0') 1291 { 1292 char *symname; 1293 1294 /* lang_leave_ouput_section_statement resets stat_ptr. Put 1295 stat_ptr back where we want it. */ 1296 if (place != NULL) 1297 stat_ptr = &add; 1298 1299 symname = (char *) xmalloc (ps - secname + sizeof "__stop_"); 1300 sprintf (symname, "__stop_%s", secname); 1301 lang_add_assignment (exp_assop ('=', symname, 1302 exp_nameop (NAME, "."))); 1303 } 1304 1305 /* Restore the global list pointer. */ 1306 stat_ptr = old; 1307 1308 if (place != NULL && os->bfd_section != NULL) 1309 { 1310 asection *snew, **pps; 1311 1312 snew = os->bfd_section; 1313 1314 /* Shuffle the bfd section list to make the output file look 1315 neater. This is really only cosmetic. */ 1316 if (place->section == NULL) 1317 { 1318 asection *bfd_section = place->os->bfd_section; 1319 1320 /* If the output statement hasn't been used to place 1321 any input sections (and thus doesn't have an output 1322 bfd_section), look for the closest prior output statement 1323 having an output section. */ 1324 if (bfd_section == NULL) 1325 bfd_section = output_prev_sec_find (place->os); 1326 1327 if (bfd_section != NULL && bfd_section != snew) 1328 place->section = &bfd_section->next; 1329 } 1330 1331 if (place->section != NULL) 1332 { 1333 /* Unlink the section. */ 1334 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next) 1335 ; 1336 bfd_section_list_remove (output_bfd, pps); 1337 1338 /* Now tack it on to the "place->os" section list. */ 1339 bfd_section_list_insert (output_bfd, place->section, snew); 1340 } 1341 1342 /* Save the end of this list. Further ophans of this type will 1343 follow the one we've just added. */ 1344 place->section = &snew->next; 1345 1346 /* The following is non-cosmetic. We try to put the output 1347 statements in some sort of reasonable order here, because 1348 they determine the final load addresses of the orphan 1349 sections. In addition, placing output statements in the 1350 wrong order may require extra segments. For instance, 1351 given a typical situation of all read-only sections placed 1352 in one segment and following that a segment containing all 1353 the read-write sections, we wouldn't want to place an orphan 1354 read/write section before or amongst the read-only ones. */ 1355 if (add.head != NULL) 1356 { 1357 lang_statement_union_type *newly_added_os; 1358 1359 if (place->stmt == NULL) 1360 { 1361 /* Put the new statement list right at the head. */ 1362 *add.tail = place->os->header.next; 1363 place->os->header.next = add.head; 1364 1365 place->os_tail = &place->os->next; 1366 } 1367 else 1368 { 1369 /* Put it after the last orphan statement we added. */ 1370 *add.tail = *place->stmt; 1371 *place->stmt = add.head; 1372 } 1373 1374 /* Fix the global list pointer if we happened to tack our 1375 new list at the tail. */ 1376 if (*old->tail == add.head) 1377 old->tail = add.tail; 1378 1379 /* Save the end of this list. */ 1380 place->stmt = add.tail; 1381 1382 /* Do the same for the list of output section statements. */ 1383 newly_added_os = *os_tail; 1384 *os_tail = NULL; 1385 newly_added_os->output_section_statement.next = *place->os_tail; 1386 *place->os_tail = newly_added_os; 1387 place->os_tail = &newly_added_os->output_section_statement.next; 1388 1389 /* Fixing the global list pointer here is a little different. 1390 We added to the list in lang_enter_output_section_statement, 1391 trimmed off the new output_section_statment above when 1392 assigning *os_tail = NULL, but possibly added it back in 1393 the same place when assigning *place->os_tail. */ 1394 if (*os_tail == NULL) 1395 lang_output_section_statement.tail = os_tail; 1396 } 1397 } 1398 1399 return TRUE; 1400} 1401EOF 1402fi 1403 1404if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then 1405cat >>e${EMULATION_NAME}.c <<EOF 1406 1407static void 1408gld${EMULATION_NAME}_finish (void) 1409{ 1410 if (bfd_elf_discard_info (output_bfd, &link_info)) 1411 { 1412 lang_reset_memory_regions (); 1413 1414 /* Resize the sections. */ 1415 lang_size_sections (stat_ptr->head, abs_output_section, 1416 &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE); 1417 1418 /* Redo special stuff. */ 1419 ldemul_after_allocation (); 1420 1421 /* Do the assignments again. */ 1422 lang_do_assignments (stat_ptr->head, abs_output_section, 1423 (fill_type *) 0, (bfd_vma) 0); 1424 } 1425} 1426EOF 1427fi 1428 1429if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then 1430cat >>e${EMULATION_NAME}.c <<EOF 1431 1432static char * 1433gld${EMULATION_NAME}_get_script (int *isfile) 1434EOF 1435 1436if test -n "$COMPILE_IN" 1437then 1438# Scripts compiled in. 1439 1440# sed commands to quote an ld script as a C string. 1441sc="-f stringify.sed" 1442 1443cat >>e${EMULATION_NAME}.c <<EOF 1444{ 1445 *isfile = 0; 1446 1447 if (link_info.relocatable && config.build_constructors) 1448 return 1449EOF 1450sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c 1451echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c 1452sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c 1453echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c 1454sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c 1455if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else 1456echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c 1457sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c 1458fi 1459if test -n "$GENERATE_PIE_SCRIPT" ; then 1460if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1461echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c 1462sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c 1463fi 1464echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c 1465sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c 1466fi 1467if test -n "$GENERATE_SHLIB_SCRIPT" ; then 1468if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1469echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c 1470sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c 1471fi 1472echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c 1473sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c 1474fi 1475if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1476echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c 1477sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c 1478fi 1479echo ' ; else return' >> e${EMULATION_NAME}.c 1480sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c 1481echo '; }' >> e${EMULATION_NAME}.c 1482 1483else 1484# Scripts read from the filesystem. 1485 1486cat >>e${EMULATION_NAME}.c <<EOF 1487{ 1488 *isfile = 1; 1489 1490 if (link_info.relocatable && config.build_constructors) 1491 return "ldscripts/${EMULATION_NAME}.xu"; 1492 else if (link_info.relocatable) 1493 return "ldscripts/${EMULATION_NAME}.xr"; 1494 else if (!config.text_read_only) 1495 return "ldscripts/${EMULATION_NAME}.xbn"; 1496EOF 1497if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : 1498else 1499cat >>e${EMULATION_NAME}.c <<EOF 1500 else if (!config.magic_demand_paged) 1501 return "ldscripts/${EMULATION_NAME}.xn"; 1502EOF 1503fi 1504if test -n "$GENERATE_PIE_SCRIPT" ; then 1505if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1506cat >>e${EMULATION_NAME}.c <<EOF 1507 else if (link_info.pie && link_info.combreloc) 1508 return "ldscripts/${EMULATION_NAME}.xdc"; 1509EOF 1510fi 1511cat >>e${EMULATION_NAME}.c <<EOF 1512 else if (link_info.pie) 1513 return "ldscripts/${EMULATION_NAME}.xd"; 1514EOF 1515fi 1516if test -n "$GENERATE_SHLIB_SCRIPT" ; then 1517if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1518cat >>e${EMULATION_NAME}.c <<EOF 1519 else if (link_info.shared && link_info.combreloc) 1520 return "ldscripts/${EMULATION_NAME}.xsc"; 1521EOF 1522fi 1523cat >>e${EMULATION_NAME}.c <<EOF 1524 else if (link_info.shared) 1525 return "ldscripts/${EMULATION_NAME}.xs"; 1526EOF 1527fi 1528if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1529cat >>e${EMULATION_NAME}.c <<EOF 1530 else if (link_info.combreloc) 1531 return "ldscripts/${EMULATION_NAME}.xc"; 1532EOF 1533fi 1534cat >>e${EMULATION_NAME}.c <<EOF 1535 else 1536 return "ldscripts/${EMULATION_NAME}.x"; 1537} 1538 1539EOF 1540fi 1541fi 1542 1543if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1544 1545if test -n "$PARSE_AND_LIST_PROLOGUE" ; then 1546cat >>e${EMULATION_NAME}.c <<EOF 1547 $PARSE_AND_LIST_PROLOGUE 1548EOF 1549fi 1550 1551cat >>e${EMULATION_NAME}.c <<EOF 1552 1553#define OPTION_DISABLE_NEW_DTAGS (400) 1554#define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1) 1555#define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1) 1556#define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1) 1557 1558static void 1559gld${EMULATION_NAME}_add_options 1560 (int ns, char **shortopts, int nl, struct option **longopts, 1561 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED) 1562{ 1563 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:"; 1564 static const struct option xtra_long[] = { 1565EOF 1566 1567if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1568cat >>e${EMULATION_NAME}.c <<EOF 1569 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS}, 1570 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS}, 1571 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR}, 1572 {"Bgroup", no_argument, NULL, OPTION_GROUP}, 1573EOF 1574fi 1575 1576if test -n "$PARSE_AND_LIST_LONGOPTS" ; then 1577cat >>e${EMULATION_NAME}.c <<EOF 1578 $PARSE_AND_LIST_LONGOPTS 1579EOF 1580fi 1581 1582cat >>e${EMULATION_NAME}.c <<EOF 1583 {NULL, no_argument, NULL, 0} 1584 }; 1585 1586 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short)); 1587 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short)); 1588 *longopts = (struct option *) 1589 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long)); 1590 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long)); 1591} 1592 1593static bfd_boolean 1594gld${EMULATION_NAME}_handle_option (int optc) 1595{ 1596 switch (optc) 1597 { 1598 default: 1599 return FALSE; 1600 1601EOF 1602 1603if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1604cat >>e${EMULATION_NAME}.c <<EOF 1605 case OPTION_DISABLE_NEW_DTAGS: 1606 link_info.new_dtags = FALSE; 1607 break; 1608 1609 case OPTION_ENABLE_NEW_DTAGS: 1610 link_info.new_dtags = TRUE; 1611 break; 1612 1613 case OPTION_EH_FRAME_HDR: 1614 link_info.eh_frame_hdr = TRUE; 1615 break; 1616 1617 case OPTION_GROUP: 1618 link_info.flags_1 |= (bfd_vma) DF_1_GROUP; 1619 /* Groups must be self-contained. */ 1620 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR; 1621 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR; 1622 break; 1623 1624 case 'z': 1625 if (strcmp (optarg, "initfirst") == 0) 1626 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST; 1627 else if (strcmp (optarg, "interpose") == 0) 1628 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE; 1629 else if (strcmp (optarg, "loadfltr") == 0) 1630 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR; 1631 else if (strcmp (optarg, "nodefaultlib") == 0) 1632 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB; 1633 else if (strcmp (optarg, "nodelete") == 0) 1634 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE; 1635 else if (strcmp (optarg, "nodlopen") == 0) 1636 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN; 1637 else if (strcmp (optarg, "nodump") == 0) 1638 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP; 1639 else if (strcmp (optarg, "now") == 0) 1640 { 1641 link_info.flags |= (bfd_vma) DF_BIND_NOW; 1642 link_info.flags_1 |= (bfd_vma) DF_1_NOW; 1643 } 1644 else if (strcmp (optarg, "origin") == 0) 1645 { 1646 link_info.flags |= (bfd_vma) DF_ORIGIN; 1647 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN; 1648 } 1649 else if (strcmp (optarg, "defs") == 0) 1650 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR; 1651 else if (strcmp (optarg, "muldefs") == 0) 1652 link_info.allow_multiple_definition = TRUE; 1653 else if (strcmp (optarg, "combreloc") == 0) 1654 link_info.combreloc = TRUE; 1655 else if (strcmp (optarg, "nocombreloc") == 0) 1656 link_info.combreloc = FALSE; 1657 else if (strcmp (optarg, "nocopyreloc") == 0) 1658 link_info.nocopyreloc = TRUE; 1659 else if (strcmp (optarg, "execstack") == 0) 1660 { 1661 link_info.execstack = TRUE; 1662 link_info.noexecstack = FALSE; 1663 } 1664 else if (strcmp (optarg, "noexecstack") == 0) 1665 { 1666 link_info.noexecstack = TRUE; 1667 link_info.execstack = FALSE; 1668 } 1669 /* What about the other Solaris -z options? FIXME. */ 1670 break; 1671EOF 1672fi 1673 1674if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then 1675cat >>e${EMULATION_NAME}.c <<EOF 1676 $PARSE_AND_LIST_ARGS_CASES 1677EOF 1678fi 1679 1680cat >>e${EMULATION_NAME}.c <<EOF 1681 } 1682 1683 return TRUE; 1684} 1685 1686EOF 1687 1688if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then 1689cat >>e${EMULATION_NAME}.c <<EOF 1690 1691static void 1692gld${EMULATION_NAME}_list_options (FILE * file) 1693{ 1694EOF 1695 1696if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1697cat >>e${EMULATION_NAME}.c <<EOF 1698 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n")); 1699 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n")); 1700 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n")); 1701 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n")); 1702 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n")); 1703 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n")); 1704 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n")); 1705 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n")); 1706 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n")); 1707 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n")); 1708 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n")); 1709 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n")); 1710 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n")); 1711 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n")); 1712 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n")); 1713 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n")); 1714 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n")); 1715 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n")); 1716 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n")); 1717 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n")); 1718 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n")); 1719EOF 1720fi 1721 1722if test -n "$PARSE_AND_LIST_OPTIONS" ; then 1723cat >>e${EMULATION_NAME}.c <<EOF 1724 $PARSE_AND_LIST_OPTIONS 1725EOF 1726fi 1727 1728cat >>e${EMULATION_NAME}.c <<EOF 1729} 1730EOF 1731 1732if test -n "$PARSE_AND_LIST_EPILOGUE" ; then 1733cat >>e${EMULATION_NAME}.c <<EOF 1734 $PARSE_AND_LIST_EPILOGUE 1735EOF 1736fi 1737fi 1738else 1739cat >>e${EMULATION_NAME}.c <<EOF 1740#define gld${EMULATION_NAME}_add_options NULL 1741#define gld${EMULATION_NAME}_handle_option NULL 1742EOF 1743if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then 1744cat >>e${EMULATION_NAME}.c <<EOF 1745#define gld${EMULATION_NAME}_list_options NULL 1746EOF 1747fi 1748fi 1749 1750cat >>e${EMULATION_NAME}.c <<EOF 1751 1752struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = 1753{ 1754 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse}, 1755 ${LDEMUL_SYSLIB-syslib_default}, 1756 ${LDEMUL_HLL-hll_default}, 1757 ${LDEMUL_AFTER_PARSE-after_parse_default}, 1758 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open}, 1759 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default}, 1760 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default}, 1761 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target}, 1762 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation}, 1763 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script}, 1764 "${EMULATION_NAME}", 1765 "${OUTPUT_FORMAT}", 1766 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish}, 1767 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL}, 1768 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive}, 1769 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan}, 1770 ${LDEMUL_SET_SYMBOLS-NULL}, 1771 ${LDEMUL_PARSE_ARGS-NULL}, 1772 gld${EMULATION_NAME}_add_options, 1773 gld${EMULATION_NAME}_handle_option, 1774 ${LDEMUL_UNRECOGNIZED_FILE-NULL}, 1775 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options}, 1776 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols}, 1777 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL}, 1778 ${LDEMUL_NEW_VERS_PATTERN-NULL} 1779}; 1780EOF 1781