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