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