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 /* If we've already seen this file, skip it. */ 895 for (ll = needed; ll != l; ll = ll->next) 896 if ((ll->by == NULL 897 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0) 898 && strcmp (ll->name, l->name) == 0) 899 break; 900 if (ll != l) 901 continue; 902 903 /* See if this file was included in the link explicitly. */ 904 global_needed = l; 905 global_found = NULL; 906 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed); 907 if (global_found != NULL 908 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd) 909 & DYN_AS_NEEDED) == 0) 910 continue; 911 912 n.by = l->by; 913 n.name = l->name; 914 nn.by = l->by; 915 if (trace_file_tries) 916 info_msg (_("%s needed by %B\n"), l->name, l->by); 917 918 /* As-needed libs specified on the command line (or linker script) 919 take priority over libs found in search dirs. */ 920 if (global_found != NULL) 921 { 922 nn.name = global_found->filename; 923 if (gld${EMULATION_NAME}_try_needed (&nn, TRUE)) 924 continue; 925 } 926 927 /* We need to find this file and include the symbol table. We 928 want to search for the file in the same way that the dynamic 929 linker will search. That means that we want to use 930 rpath_link, rpath, then the environment variable 931 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH 932 entries (native only), then the linker script LIB_SEARCH_DIRS. 933 We do not search using the -L arguments. 934 935 We search twice. The first time, we skip objects which may 936 introduce version mismatches. The second time, we force 937 their use. See gld${EMULATION_NAME}_vercheck comment. */ 938 for (force = 0; force < 2; force++) 939 { 940 size_t len; 941 search_dirs_type *search; 942EOF 943if [ "x${NATIVE}" = xyes ] ; then 944cat >>e${EMULATION_NAME}.c <<EOF 945 const char *lib_path; 946EOF 947fi 948if [ "x${USE_LIBPATH}" = xyes ] ; then 949cat >>e${EMULATION_NAME}.c <<EOF 950 struct bfd_link_needed_list *rp; 951 int found; 952EOF 953fi 954cat >>e${EMULATION_NAME}.c <<EOF 955 956 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link, 957 &n, force)) 958 break; 959EOF 960if [ "x${USE_LIBPATH}" = xyes ] ; then 961cat >>e${EMULATION_NAME}.c <<EOF 962 if (gld${EMULATION_NAME}_search_needed (command_line.rpath, 963 &n, force)) 964 break; 965EOF 966fi 967if [ "x${NATIVE}" = xyes ] ; then 968cat >>e${EMULATION_NAME}.c <<EOF 969 if (command_line.rpath_link == NULL 970 && command_line.rpath == NULL) 971 { 972 lib_path = (const char *) getenv ("LD_RUN_PATH"); 973 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, 974 force)) 975 break; 976 } 977 lib_path = (const char *) getenv ("LD_LIBRARY_PATH"); 978 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force)) 979 break; 980EOF 981fi 982if [ "x${USE_LIBPATH}" = xyes ] ; then 983cat >>e${EMULATION_NAME}.c <<EOF 984 found = 0; 985 rp = bfd_elf_get_runpath_list (output_bfd, &link_info); 986 for (; !found && rp != NULL; rp = rp->next) 987 { 988 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name); 989 found = (rp->by == l->by 990 && gld${EMULATION_NAME}_search_needed (tmpname, 991 &n, 992 force)); 993 free (tmpname); 994 } 995 if (found) 996 break; 997 998EOF 999fi 1000if [ "x${USE_LIBPATH}" = xyes ] ; then 1001 case ${target} in 1002 *-*-freebsd* | *-*-dragonfly*) 1003 cat >>e${EMULATION_NAME}.c <<EOF 1004 if (gld${EMULATION_NAME}_check_ld_elf_hints (l->name, force)) 1005 break; 1006EOF 1007 # FreeBSD 1008 ;; 1009 1010 *-*-linux-* | *-*-k*bsd*-*) 1011 # Linux 1012 cat >>e${EMULATION_NAME}.c <<EOF 1013 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force)) 1014 break; 1015 1016EOF 1017 ;; 1018 esac 1019fi 1020cat >>e${EMULATION_NAME}.c <<EOF 1021 len = strlen (l->name); 1022 for (search = search_head; search != NULL; search = search->next) 1023 { 1024 char *filename; 1025 1026 if (search->cmdline) 1027 continue; 1028 filename = (char *) xmalloc (strlen (search->name) + len + 2); 1029 sprintf (filename, "%s/%s", search->name, l->name); 1030 nn.name = filename; 1031 if (gld${EMULATION_NAME}_try_needed (&nn, force)) 1032 break; 1033 free (filename); 1034 } 1035 if (search != NULL) 1036 break; 1037EOF 1038cat >>e${EMULATION_NAME}.c <<EOF 1039 } 1040 1041 if (force < 2) 1042 continue; 1043 1044 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n", 1045 l->name, l->by); 1046 } 1047} 1048 1049EOF 1050fi 1051 1052cat >>e${EMULATION_NAME}.c <<EOF 1053 1054/* Look through an expression for an assignment statement. */ 1055 1056static void 1057gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp) 1058{ 1059 bfd_boolean provide = FALSE; 1060 1061 switch (exp->type.node_class) 1062 { 1063 case etree_provide: 1064 provide = TRUE; 1065 /* Fall thru */ 1066 case etree_assign: 1067 /* We call record_link_assignment even if the symbol is defined. 1068 This is because if it is defined by a dynamic object, we 1069 actually want to use the value defined by the linker script, 1070 not the value from the dynamic object (because we are setting 1071 symbols like etext). If the symbol is defined by a regular 1072 object, then, as it happens, calling record_link_assignment 1073 will do no harm. */ 1074 if (strcmp (exp->assign.dst, ".") != 0) 1075 { 1076 if (!bfd_elf_record_link_assignment (output_bfd, &link_info, 1077 exp->assign.dst, provide, 1078 exp->assign.hidden)) 1079 einfo ("%P%F: failed to record assignment to %s: %E\n", 1080 exp->assign.dst); 1081 } 1082 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src); 1083 break; 1084 1085 case etree_binary: 1086 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs); 1087 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs); 1088 break; 1089 1090 case etree_trinary: 1091 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond); 1092 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs); 1093 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs); 1094 break; 1095 1096 case etree_unary: 1097 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child); 1098 break; 1099 1100 default: 1101 break; 1102 } 1103} 1104 1105 1106/* This is called by the before_allocation routine via 1107 lang_for_each_statement. It locates any assignment statements, and 1108 tells the ELF backend about them, in case they are assignments to 1109 symbols which are referred to by dynamic objects. */ 1110 1111static void 1112gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s) 1113{ 1114 if (s->header.type == lang_assignment_statement_enum) 1115 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp); 1116} 1117 1118EOF 1119 1120if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then 1121 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then 1122 ELF_INTERPRETER_SET_DEFAULT=" 1123 if (sinterp != NULL) 1124 { 1125 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME}; 1126 sinterp->size = strlen ((char *) sinterp->contents) + 1; 1127 } 1128 1129" 1130 else 1131 ELF_INTERPRETER_SET_DEFAULT= 1132 fi 1133cat >>e${EMULATION_NAME}.c <<EOF 1134 1135/* This is called after the sections have been attached to output 1136 sections, but before any sizes or addresses have been set. */ 1137 1138static void 1139gld${EMULATION_NAME}_before_allocation (void) 1140{ 1141 const char *rpath; 1142 asection *sinterp; 1143 1144 if (link_info.hash->type == bfd_link_elf_hash_table) 1145 _bfd_elf_tls_setup (output_bfd, &link_info); 1146 1147 /* If we are going to make any variable assignments, we need to let 1148 the ELF backend know about them in case the variables are 1149 referred to by dynamic objects. */ 1150 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment); 1151 1152 /* Let the ELF backend work out the sizes of any sections required 1153 by dynamic linking. */ 1154 rpath = command_line.rpath; 1155 if (rpath == NULL) 1156 rpath = (const char *) getenv ("LD_RUN_PATH"); 1157 if (! (bfd_elf_size_dynamic_sections 1158 (output_bfd, command_line.soname, rpath, 1159 command_line.filter_shlib, 1160 (const char * const *) command_line.auxiliary_filters, 1161 &link_info, &sinterp, lang_elf_version_info))) 1162 einfo ("%P%F: failed to set dynamic section sizes: %E\n"); 1163 1164${ELF_INTERPRETER_SET_DEFAULT} 1165 /* Let the user override the dynamic linker we are using. */ 1166 if (command_line.interpreter != NULL 1167 && sinterp != NULL) 1168 { 1169 sinterp->contents = (bfd_byte *) command_line.interpreter; 1170 sinterp->size = strlen (command_line.interpreter) + 1; 1171 } 1172 1173 /* Look for any sections named .gnu.warning. As a GNU extensions, 1174 we treat such sections as containing warning messages. We print 1175 out the warning message, and then zero out the section size so 1176 that it does not get copied into the output file. */ 1177 1178 { 1179 LANG_FOR_EACH_INPUT_STATEMENT (is) 1180 { 1181 asection *s; 1182 bfd_size_type sz; 1183 bfd_size_type prefix_len; 1184 char *msg; 1185 bfd_boolean ret; 1186 const char * gnu_warning_prefix = _("warning: "); 1187 1188 if (is->just_syms_flag) 1189 continue; 1190 1191 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning"); 1192 if (s == NULL) 1193 continue; 1194 1195 sz = s->size; 1196 prefix_len = strlen (gnu_warning_prefix); 1197 msg = xmalloc ((size_t) (prefix_len + sz + 1)); 1198 strcpy (msg, gnu_warning_prefix); 1199 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len, 1200 (file_ptr) 0, sz)) 1201 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n", 1202 is->the_bfd); 1203 msg[prefix_len + sz] = '\0'; 1204 ret = link_info.callbacks->warning (&link_info, msg, 1205 (const char *) NULL, 1206 is->the_bfd, (asection *) NULL, 1207 (bfd_vma) 0); 1208 ASSERT (ret); 1209 free (msg); 1210 1211 /* Clobber the section size, so that we don't waste copying the 1212 warning into the output file. */ 1213 s->size = 0; 1214 1215 /* Also set SEC_EXCLUDE, so that symbols defined in the warning 1216 section don't get copied to the output. */ 1217 s->flags |= SEC_EXCLUDE; 1218 } 1219 } 1220 1221 before_allocation_default (); 1222 1223 if (!bfd_elf_size_dynsym_hash_dynstr (output_bfd, &link_info)) 1224 einfo ("%P%F: failed to set dynamic section sizes: %E\n"); 1225} 1226 1227EOF 1228fi 1229 1230if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then 1231cat >>e${EMULATION_NAME}.c <<EOF 1232 1233/* Try to open a dynamic archive. This is where we know that ELF 1234 dynamic libraries have an extension of .so (or .sl on oddball systems 1235 like hpux). */ 1236 1237static bfd_boolean 1238gld${EMULATION_NAME}_open_dynamic_archive 1239 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry) 1240{ 1241 const char *filename; 1242 char *string; 1243 1244 if (! entry->is_archive) 1245 return FALSE; 1246 1247 filename = entry->filename; 1248 1249 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION 1250 is defined, but it does not seem worth the headache to optimize 1251 away those two bytes of space. */ 1252 string = (char *) xmalloc (strlen (search->name) 1253 + strlen (filename) 1254 + strlen (arch) 1255#ifdef EXTRA_SHLIB_EXTENSION 1256 + strlen (EXTRA_SHLIB_EXTENSION) 1257#endif 1258 + sizeof "/lib.so"); 1259 1260 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch); 1261 1262#ifdef EXTRA_SHLIB_EXTENSION 1263 /* Try the .so extension first. If that fails build a new filename 1264 using EXTRA_SHLIB_EXTENSION. */ 1265 if (! ldfile_try_open_bfd (string, entry)) 1266 sprintf (string, "%s/lib%s%s%s", search->name, 1267 filename, arch, EXTRA_SHLIB_EXTENSION); 1268#endif 1269 1270 if (! ldfile_try_open_bfd (string, entry)) 1271 { 1272 free (string); 1273 return FALSE; 1274 } 1275 1276 entry->filename = string; 1277 1278 /* We have found a dynamic object to include in the link. The ELF 1279 backend linker will create a DT_NEEDED entry in the .dynamic 1280 section naming this file. If this file includes a DT_SONAME 1281 entry, it will be used. Otherwise, the ELF linker will just use 1282 the name of the file. For an archive found by searching, like 1283 this one, the DT_NEEDED entry should consist of just the name of 1284 the file, without the path information used to find it. Note 1285 that we only need to do this if we have a dynamic object; an 1286 archive will never be referenced by a DT_NEEDED entry. 1287 1288 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not 1289 very pretty. I haven't been able to think of anything that is 1290 pretty, though. */ 1291 if (bfd_check_format (entry->the_bfd, bfd_object) 1292 && (entry->the_bfd->flags & DYNAMIC) != 0) 1293 { 1294 ASSERT (entry->is_archive && entry->search_dirs_flag); 1295 1296 /* Rather than duplicating the logic above. Just use the 1297 filename we recorded earlier. */ 1298 1299 filename = lbasename (entry->filename); 1300 bfd_elf_set_dt_needed_name (entry->the_bfd, filename); 1301 } 1302 1303 return TRUE; 1304} 1305 1306EOF 1307fi 1308 1309if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then 1310cat >>e${EMULATION_NAME}.c <<EOF 1311 1312/* A variant of lang_output_section_find used by place_orphan. */ 1313 1314static lang_output_section_statement_type * 1315output_rel_find (asection *sec, int isdyn) 1316{ 1317 lang_output_section_statement_type *lookup; 1318 lang_output_section_statement_type *last = NULL; 1319 lang_output_section_statement_type *last_alloc = NULL; 1320 lang_output_section_statement_type *last_rel = NULL; 1321 lang_output_section_statement_type *last_rel_alloc = NULL; 1322 int rela = sec->name[4] == 'a'; 1323 1324 for (lookup = &lang_output_section_statement.head->output_section_statement; 1325 lookup != NULL; 1326 lookup = lookup->next) 1327 { 1328 if (lookup->constraint != -1 1329 && strncmp (".rel", lookup->name, 4) == 0) 1330 { 1331 int lookrela = lookup->name[4] == 'a'; 1332 1333 /* .rel.dyn must come before all other reloc sections, to suit 1334 GNU ld.so. */ 1335 if (isdyn) 1336 break; 1337 1338 /* Don't place after .rel.plt as doing so results in wrong 1339 dynamic tags. */ 1340 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0) 1341 break; 1342 1343 if (rela == lookrela || last_rel == NULL) 1344 last_rel = lookup; 1345 if ((rela == lookrela || last_rel_alloc == NULL) 1346 && lookup->bfd_section != NULL 1347 && (lookup->bfd_section->flags & SEC_ALLOC) != 0) 1348 last_rel_alloc = lookup; 1349 } 1350 1351 last = lookup; 1352 if (lookup->bfd_section != NULL 1353 && (lookup->bfd_section->flags & SEC_ALLOC) != 0) 1354 last_alloc = lookup; 1355 } 1356 1357 if (last_rel_alloc) 1358 return last_rel_alloc; 1359 1360 if (last_rel) 1361 return last_rel; 1362 1363 if (last_alloc) 1364 return last_alloc; 1365 1366 return last; 1367} 1368 1369/* Place an orphan section. We use this to put random SHF_ALLOC 1370 sections in the right segment. */ 1371 1372static bfd_boolean 1373gld${EMULATION_NAME}_place_orphan (asection *s) 1374{ 1375 static struct orphan_save hold[] = 1376 { 1377 { ".text", 1378 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE, 1379 0, 0, 0, 0 }, 1380 { ".rodata", 1381 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA, 1382 0, 0, 0, 0 }, 1383 { ".data", 1384 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA, 1385 0, 0, 0, 0 }, 1386 { ".bss", 1387 SEC_ALLOC, 1388 0, 0, 0, 0 }, 1389 { 0, 1390 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA, 1391 0, 0, 0, 0 }, 1392 { ".interp", 1393 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA, 1394 0, 0, 0, 0 }, 1395 { ".sdata", 1396 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA, 1397 0, 0, 0, 0 } 1398 }; 1399 enum orphan_save_index 1400 { 1401 orphan_text = 0, 1402 orphan_rodata, 1403 orphan_data, 1404 orphan_bss, 1405 orphan_rel, 1406 orphan_interp, 1407 orphan_sdata 1408 }; 1409 static int orphan_init_done = 0; 1410 struct orphan_save *place; 1411 const char *secname; 1412 lang_output_section_statement_type *after; 1413 lang_output_section_statement_type *os; 1414 int isdyn = 0; 1415 int iself = s->owner->xvec->flavour == bfd_target_elf_flavour; 1416 unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL; 1417 1418 secname = bfd_get_section_name (s->owner, s); 1419 1420 if (! link_info.relocatable 1421 && link_info.combreloc 1422 && (s->flags & SEC_ALLOC)) 1423 { 1424 if (iself) 1425 switch (sh_type) 1426 { 1427 case SHT_RELA: 1428 secname = ".rela.dyn"; 1429 isdyn = 1; 1430 break; 1431 case SHT_REL: 1432 secname = ".rel.dyn"; 1433 isdyn = 1; 1434 break; 1435 default: 1436 break; 1437 } 1438 else if (strncmp (secname, ".rel", 4) == 0) 1439 { 1440 secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn"; 1441 isdyn = 1; 1442 } 1443 } 1444 1445 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s))) 1446 { 1447 /* Look through the script to see where to place this section. */ 1448 os = lang_output_section_find (secname); 1449 1450 if (os != NULL 1451 && (os->bfd_section == NULL 1452 || os->bfd_section->flags == 0 1453 || (_bfd_elf_match_sections_by_type (output_bfd, 1454 os->bfd_section, 1455 s->owner, s) 1456 && ((s->flags ^ os->bfd_section->flags) 1457 & (SEC_LOAD | SEC_ALLOC)) == 0))) 1458 { 1459 /* We already have an output section statement with this 1460 name, and its bfd section, if any, has compatible flags. 1461 If the section already exists but does not have any flags 1462 set, then it has been created by the linker, probably as a 1463 result of a --section-start command line switch. */ 1464 lang_add_section (&os->children, s, os); 1465 return TRUE; 1466 } 1467 } 1468 1469 if (!orphan_init_done) 1470 { 1471 struct orphan_save *ho; 1472 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho) 1473 if (ho->name != NULL) 1474 { 1475 ho->os = lang_output_section_find (ho->name); 1476 if (ho->os != NULL && ho->os->flags == 0) 1477 ho->os->flags = ho->flags; 1478 } 1479 orphan_init_done = 1; 1480 } 1481 1482 /* If this is a final link, then always put .gnu.warning.SYMBOL 1483 sections into the .text section to get them out of the way. */ 1484 if (link_info.executable 1485 && ! link_info.relocatable 1486 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0 1487 && hold[orphan_text].os != NULL) 1488 { 1489 lang_add_section (&hold[orphan_text].os->children, s, 1490 hold[orphan_text].os); 1491 return TRUE; 1492 } 1493 1494 /* Decide which segment the section should go in based on the 1495 section name and section flags. We put loadable .note sections 1496 right after the .interp section, so that the PT_NOTE segment is 1497 stored right after the program headers where the OS can read it 1498 in the first page. */ 1499 1500 place = NULL; 1501 if ((s->flags & SEC_ALLOC) == 0) 1502 ; 1503 else if ((s->flags & SEC_LOAD) != 0 1504 && ((iself && sh_type == SHT_NOTE) 1505 || (!iself && strncmp (secname, ".note", 5) == 0))) 1506 place = &hold[orphan_interp]; 1507 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 1508 place = &hold[orphan_bss]; 1509 else if ((s->flags & SEC_SMALL_DATA) != 0) 1510 place = &hold[orphan_sdata]; 1511 else if ((s->flags & SEC_READONLY) == 0) 1512 place = &hold[orphan_data]; 1513 else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL)) 1514 || (!iself && strncmp (secname, ".rel", 4) == 0)) 1515 && (s->flags & SEC_LOAD) != 0) 1516 place = &hold[orphan_rel]; 1517 else if ((s->flags & SEC_CODE) == 0) 1518 place = &hold[orphan_rodata]; 1519 else 1520 place = &hold[orphan_text]; 1521 1522 after = NULL; 1523 if (place != NULL) 1524 { 1525 if (place->os == NULL) 1526 { 1527 if (place->name != NULL) 1528 place->os = lang_output_section_find (place->name); 1529 else 1530 place->os = output_rel_find (s, isdyn); 1531 } 1532 after = place->os; 1533 if (after == NULL) 1534 after = lang_output_section_find_by_flags 1535 (s, &place->os, _bfd_elf_match_sections_by_type); 1536 if (after == NULL) 1537 /* *ABS* is always the first output section statement. */ 1538 after = &lang_output_section_statement.head->output_section_statement; 1539 } 1540 1541 /* Choose a unique name for the section. This will be needed if the 1542 same section name appears in the input file with different 1543 loadable or allocatable characteristics. */ 1544 if (bfd_get_section_by_name (output_bfd, secname) != NULL) 1545 { 1546 static int count = 1; 1547 secname = bfd_get_unique_section_name (output_bfd, secname, &count); 1548 if (secname == NULL) 1549 einfo ("%F%P: place_orphan failed: %E\n"); 1550 } 1551 1552 lang_insert_orphan (s, secname, after, place, NULL, NULL); 1553 1554 return TRUE; 1555} 1556EOF 1557fi 1558 1559if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then 1560cat >>e${EMULATION_NAME}.c <<EOF 1561 1562static void 1563gld${EMULATION_NAME}_layout_sections_again (void) 1564{ 1565 lang_reset_memory_regions (); 1566 1567 /* Resize the sections. */ 1568 lang_size_sections (NULL, TRUE); 1569 1570 /* Redo special stuff. */ 1571 ldemul_after_allocation (); 1572 1573 /* Do the assignments again. */ 1574 lang_do_assignments (); 1575} 1576 1577static void 1578gld${EMULATION_NAME}_finish (void) 1579{ 1580 if (bfd_elf_discard_info (output_bfd, &link_info)) 1581 gld${EMULATION_NAME}_layout_sections_again (); 1582 1583 finish_default (); 1584} 1585EOF 1586fi 1587 1588if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then 1589cat >>e${EMULATION_NAME}.c <<EOF 1590 1591static char * 1592gld${EMULATION_NAME}_get_script (int *isfile) 1593EOF 1594 1595if test -n "$COMPILE_IN" 1596then 1597# Scripts compiled in. 1598 1599# sed commands to quote an ld script as a C string. 1600sc="-f stringify.sed" 1601 1602cat >>e${EMULATION_NAME}.c <<EOF 1603{ 1604 *isfile = 0; 1605 1606 if (link_info.relocatable && config.build_constructors) 1607 return 1608EOF 1609sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c 1610echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c 1611sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c 1612echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c 1613sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c 1614if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else 1615echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c 1616sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c 1617fi 1618if test -n "$GENERATE_PIE_SCRIPT" ; then 1619if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1620echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c 1621echo ' && link_info.relro' >> e${EMULATION_NAME}.c 1622echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c 1623sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c 1624echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c 1625sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c 1626fi 1627echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c 1628sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c 1629fi 1630if test -n "$GENERATE_SHLIB_SCRIPT" ; then 1631if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1632echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c 1633echo ' && link_info.relro' >> e${EMULATION_NAME}.c 1634echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c 1635sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c 1636echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c 1637sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c 1638fi 1639echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c 1640sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c 1641fi 1642if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1643echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c 1644echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c 1645sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c 1646echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c 1647sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c 1648fi 1649echo ' ; else return' >> e${EMULATION_NAME}.c 1650sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c 1651echo '; }' >> e${EMULATION_NAME}.c 1652 1653else 1654# Scripts read from the filesystem. 1655 1656cat >>e${EMULATION_NAME}.c <<EOF 1657{ 1658 *isfile = 1; 1659 1660 if (link_info.relocatable && config.build_constructors) 1661 return "ldscripts/${EMULATION_NAME}.xu"; 1662 else if (link_info.relocatable) 1663 return "ldscripts/${EMULATION_NAME}.xr"; 1664 else if (!config.text_read_only) 1665 return "ldscripts/${EMULATION_NAME}.xbn"; 1666EOF 1667if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : 1668else 1669cat >>e${EMULATION_NAME}.c <<EOF 1670 else if (!config.magic_demand_paged) 1671 return "ldscripts/${EMULATION_NAME}.xn"; 1672EOF 1673fi 1674if test -n "$GENERATE_PIE_SCRIPT" ; then 1675if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1676cat >>e${EMULATION_NAME}.c <<EOF 1677 else if (link_info.pie && link_info.combreloc 1678 && link_info.relro && (link_info.flags & DT_BIND_NOW)) 1679 return "ldscripts/${EMULATION_NAME}.xdw"; 1680 else if (link_info.pie && link_info.combreloc) 1681 return "ldscripts/${EMULATION_NAME}.xdc"; 1682EOF 1683fi 1684cat >>e${EMULATION_NAME}.c <<EOF 1685 else if (link_info.pie) 1686 return "ldscripts/${EMULATION_NAME}.xd"; 1687EOF 1688fi 1689if test -n "$GENERATE_SHLIB_SCRIPT" ; then 1690if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1691cat >>e${EMULATION_NAME}.c <<EOF 1692 else if (link_info.shared && link_info.combreloc 1693 && link_info.relro && (link_info.flags & DT_BIND_NOW)) 1694 return "ldscripts/${EMULATION_NAME}.xsw"; 1695 else if (link_info.shared && link_info.combreloc) 1696 return "ldscripts/${EMULATION_NAME}.xsc"; 1697EOF 1698fi 1699cat >>e${EMULATION_NAME}.c <<EOF 1700 else if (link_info.shared) 1701 return "ldscripts/${EMULATION_NAME}.xs"; 1702EOF 1703fi 1704if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1705cat >>e${EMULATION_NAME}.c <<EOF 1706 else if (link_info.combreloc && link_info.relro 1707 && (link_info.flags & DT_BIND_NOW)) 1708 return "ldscripts/${EMULATION_NAME}.xw"; 1709 else if (link_info.combreloc) 1710 return "ldscripts/${EMULATION_NAME}.xc"; 1711EOF 1712fi 1713cat >>e${EMULATION_NAME}.c <<EOF 1714 else 1715 return "ldscripts/${EMULATION_NAME}.x"; 1716} 1717 1718EOF 1719fi 1720fi 1721 1722if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1723 1724if test -n "$PARSE_AND_LIST_PROLOGUE" ; then 1725cat >>e${EMULATION_NAME}.c <<EOF 1726 $PARSE_AND_LIST_PROLOGUE 1727EOF 1728fi 1729 1730cat >>e${EMULATION_NAME}.c <<EOF 1731 1732#define OPTION_DISABLE_NEW_DTAGS (400) 1733#define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1) 1734#define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1) 1735#define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1) 1736#define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1) 1737 1738static void 1739gld${EMULATION_NAME}_add_options 1740 (int ns, char **shortopts, int nl, struct option **longopts, 1741 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED) 1742{ 1743 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:"; 1744 static const struct option xtra_long[] = { 1745EOF 1746 1747if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1748cat >>e${EMULATION_NAME}.c <<EOF 1749 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS}, 1750 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS}, 1751 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR}, 1752 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS}, 1753 {"Bgroup", no_argument, NULL, OPTION_GROUP}, 1754EOF 1755fi 1756 1757if test -n "$PARSE_AND_LIST_LONGOPTS" ; then 1758cat >>e${EMULATION_NAME}.c <<EOF 1759 $PARSE_AND_LIST_LONGOPTS 1760EOF 1761fi 1762 1763cat >>e${EMULATION_NAME}.c <<EOF 1764 {NULL, no_argument, NULL, 0} 1765 }; 1766 1767 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short)); 1768 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short)); 1769 *longopts = (struct option *) 1770 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long)); 1771 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long)); 1772} 1773 1774static bfd_boolean 1775gld${EMULATION_NAME}_handle_option (int optc) 1776{ 1777 switch (optc) 1778 { 1779 default: 1780 return FALSE; 1781 1782EOF 1783 1784if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1785cat >>e${EMULATION_NAME}.c <<EOF 1786 case OPTION_DISABLE_NEW_DTAGS: 1787 link_info.new_dtags = FALSE; 1788 break; 1789 1790 case OPTION_ENABLE_NEW_DTAGS: 1791 link_info.new_dtags = TRUE; 1792 break; 1793 1794 case OPTION_EH_FRAME_HDR: 1795 link_info.eh_frame_hdr = TRUE; 1796 break; 1797 1798 case OPTION_GROUP: 1799 link_info.flags_1 |= (bfd_vma) DF_1_GROUP; 1800 /* Groups must be self-contained. */ 1801 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR; 1802 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR; 1803 break; 1804 1805 case OPTION_EXCLUDE_LIBS: 1806 add_excluded_libs (optarg); 1807 break; 1808 1809 case 'z': 1810 if (strcmp (optarg, "initfirst") == 0) 1811 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST; 1812 else if (strcmp (optarg, "interpose") == 0) 1813 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE; 1814 else if (strcmp (optarg, "loadfltr") == 0) 1815 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR; 1816 else if (strcmp (optarg, "nodefaultlib") == 0) 1817 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB; 1818 else if (strcmp (optarg, "nodelete") == 0) 1819 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE; 1820 else if (strcmp (optarg, "nodlopen") == 0) 1821 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN; 1822 else if (strcmp (optarg, "nodump") == 0) 1823 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP; 1824 else if (strcmp (optarg, "now") == 0) 1825 { 1826 link_info.flags |= (bfd_vma) DF_BIND_NOW; 1827 link_info.flags_1 |= (bfd_vma) DF_1_NOW; 1828 } 1829 else if (strcmp (optarg, "origin") == 0) 1830 { 1831 link_info.flags |= (bfd_vma) DF_ORIGIN; 1832 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN; 1833 } 1834 else if (strcmp (optarg, "defs") == 0) 1835 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR; 1836 else if (strcmp (optarg, "muldefs") == 0) 1837 link_info.allow_multiple_definition = TRUE; 1838 else if (strcmp (optarg, "combreloc") == 0) 1839 link_info.combreloc = TRUE; 1840 else if (strcmp (optarg, "nocombreloc") == 0) 1841 link_info.combreloc = FALSE; 1842 else if (strcmp (optarg, "nocopyreloc") == 0) 1843 link_info.nocopyreloc = TRUE; 1844 else if (strcmp (optarg, "execstack") == 0) 1845 { 1846 link_info.execstack = TRUE; 1847 link_info.noexecstack = FALSE; 1848 } 1849 else if (strcmp (optarg, "noexecstack") == 0) 1850 { 1851 link_info.noexecstack = TRUE; 1852 link_info.execstack = FALSE; 1853 } 1854 else if (strcmp (optarg, "relro") == 0) 1855 link_info.relro = TRUE; 1856 else if (strcmp (optarg, "norelro") == 0) 1857 link_info.relro = FALSE; 1858 /* What about the other Solaris -z options? FIXME. */ 1859 break; 1860EOF 1861fi 1862 1863if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then 1864cat >>e${EMULATION_NAME}.c <<EOF 1865 $PARSE_AND_LIST_ARGS_CASES 1866EOF 1867fi 1868 1869cat >>e${EMULATION_NAME}.c <<EOF 1870 } 1871 1872 return TRUE; 1873} 1874 1875EOF 1876 1877if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then 1878cat >>e${EMULATION_NAME}.c <<EOF 1879 1880static void 1881gld${EMULATION_NAME}_list_options (FILE * file) 1882{ 1883EOF 1884 1885if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 1886cat >>e${EMULATION_NAME}.c <<EOF 1887 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n")); 1888 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n")); 1889 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n")); 1890 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n")); 1891 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n")); 1892 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n")); 1893 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n")); 1894 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n")); 1895 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n")); 1896 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n")); 1897 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n")); 1898 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n")); 1899 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n")); 1900 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n")); 1901 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n")); 1902 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n")); 1903 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n")); 1904 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n")); 1905 fprintf (file, _(" -z norelro\t\tDon't create RELRO program header\n")); 1906 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n")); 1907 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n")); 1908 fprintf (file, _(" -z relro\t\tCreate RELRO program header\n")); 1909 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n")); 1910EOF 1911fi 1912 1913if test -n "$PARSE_AND_LIST_OPTIONS" ; then 1914cat >>e${EMULATION_NAME}.c <<EOF 1915 $PARSE_AND_LIST_OPTIONS 1916EOF 1917fi 1918 1919cat >>e${EMULATION_NAME}.c <<EOF 1920} 1921EOF 1922 1923if test -n "$PARSE_AND_LIST_EPILOGUE" ; then 1924cat >>e${EMULATION_NAME}.c <<EOF 1925 $PARSE_AND_LIST_EPILOGUE 1926EOF 1927fi 1928fi 1929else 1930cat >>e${EMULATION_NAME}.c <<EOF 1931#define gld${EMULATION_NAME}_add_options NULL 1932#define gld${EMULATION_NAME}_handle_option NULL 1933EOF 1934if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then 1935cat >>e${EMULATION_NAME}.c <<EOF 1936#define gld${EMULATION_NAME}_list_options NULL 1937EOF 1938fi 1939fi 1940 1941cat >>e${EMULATION_NAME}.c <<EOF 1942 1943struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = 1944{ 1945 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse}, 1946 ${LDEMUL_SYSLIB-syslib_default}, 1947 ${LDEMUL_HLL-hll_default}, 1948 ${LDEMUL_AFTER_PARSE-after_parse_default}, 1949 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open}, 1950 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default}, 1951 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default}, 1952 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target}, 1953 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation}, 1954 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script}, 1955 "${EMULATION_NAME}", 1956 "${OUTPUT_FORMAT}", 1957 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish}, 1958 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL}, 1959 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive}, 1960 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan}, 1961 ${LDEMUL_SET_SYMBOLS-NULL}, 1962 ${LDEMUL_PARSE_ARGS-NULL}, 1963 gld${EMULATION_NAME}_add_options, 1964 gld${EMULATION_NAME}_handle_option, 1965 ${LDEMUL_UNRECOGNIZED_FILE-NULL}, 1966 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options}, 1967 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols}, 1968 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL}, 1969 ${LDEMUL_NEW_VERS_PATTERN-NULL} 1970}; 1971EOF 1972