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