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 11fragment <<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 (C) 1991-2014 Free Software Foundation, Inc. 16 Written by Steve Chamberlain <sac@cygnus.com> 17 ELF support by Ian Lance Taylor <ian@cygnus.com> 18 19 This file is part of the GNU Binutils. 20 21 This program is free software; you can redistribute it and/or modify 22 it under the terms of the GNU General Public License as published by 23 the Free Software Foundation; either version 3 of the License, or 24 (at your option) any later version. 25 26 This program is distributed in the hope that it will be useful, 27 but WITHOUT ANY WARRANTY; without even the implied warranty of 28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 29 GNU General Public License for more details. 30 31 You should have received a copy of the GNU General Public License 32 along with this program; if not, write to the Free Software 33 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 34 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 "filenames.h" 43#include "getopt.h" 44#include <fcntl.h> 45 46#include "bfdlink.h" 47 48#include "ld.h" 49#include "ldmain.h" 50#include "ldmisc.h" 51#include "ldexp.h" 52#include "ldlang.h" 53#include "ldfile.h" 54#include "ldemul.h" 55#include "ldbuildid.h" 56#include <ldgram.h> 57#include "elf/common.h" 58#include "elf-bfd.h" 59#include "filenames.h" 60 61/* Declare functions used by various EXTRA_EM_FILEs. */ 62static void gld${EMULATION_NAME}_before_parse (void); 63static void gld${EMULATION_NAME}_after_open (void); 64static void gld${EMULATION_NAME}_before_allocation (void); 65static void gld${EMULATION_NAME}_after_allocation (void); 66static lang_output_section_statement_type *gld${EMULATION_NAME}_place_orphan 67 (asection *, const char *, int); 68EOF 69 70if [ "x${USE_LIBPATH}" = xyes ] ; then 71 case ${target} in 72 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*) 73 fragment <<EOF 74#ifdef HAVE_GLOB 75#include <glob.h> 76#endif 77EOF 78 ;; 79 esac 80fi 81 82# Import any needed special functions and/or overrides. 83# 84source_em ${srcdir}/emultempl/elf-generic.em 85if test -n "$EXTRA_EM_FILE" ; then 86 source_em ${srcdir}/emultempl/${EXTRA_EM_FILE}.em 87fi 88 89# Functions in this file can be overridden by setting the LDEMUL_* shell 90# variables. If the name of the overriding function is the same as is 91# defined in this file, then don't output this file's version. 92# If a different overriding name is given then output the standard function 93# as presumably it is called from the overriding function. 94# 95if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then 96fragment <<EOF 97 98static void 99gld${EMULATION_NAME}_before_parse (void) 100{ 101 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`); 102 input_flags.dynamic = ${DYNAMIC_LINK-TRUE}; 103 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`; 104 config.separate_code = `if test "x${SEPARATE_CODE}" = xyes ; then echo TRUE ; else echo FALSE ; fi`; 105} 106 107EOF 108fi 109 110if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then 111fragment <<EOF 112/* Handle the generation of DT_NEEDED tags. */ 113 114static bfd_boolean 115gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry) 116{ 117 int link_class = 0; 118 119 /* Tell the ELF linker that we don't want the output file to have a 120 DT_NEEDED entry for this file, unless it is used to resolve 121 references in a regular object. */ 122 if (entry->flags.add_DT_NEEDED_for_regular) 123 link_class = DYN_AS_NEEDED; 124 125 /* Tell the ELF linker that we don't want the output file to have a 126 DT_NEEDED entry for any dynamic library in DT_NEEDED tags from 127 this file at all. */ 128 if (!entry->flags.add_DT_NEEDED_for_dynamic) 129 link_class |= DYN_NO_ADD_NEEDED; 130 131 if (entry->flags.just_syms 132 && (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) != 0) 133 einfo (_("%P%F: --just-symbols may not be used on DSO: %B\n"), 134 entry->the_bfd); 135 136 if (link_class == 0 137 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0) 138 return FALSE; 139 140 bfd_elf_set_dyn_lib_class (entry->the_bfd, 141 (enum dynamic_lib_link_class) link_class); 142 143 /* Continue on with normal load_symbols processing. */ 144 return FALSE; 145} 146EOF 147fi 148 149fragment <<EOF 150 151/* These variables are required to pass information back and forth 152 between after_open and check_needed and stat_needed and vercheck. */ 153 154static struct bfd_link_needed_list *global_needed; 155static struct stat global_stat; 156static lang_input_statement_type *global_found; 157static struct bfd_link_needed_list *global_vercheck_needed; 158static bfd_boolean global_vercheck_failed; 159 160/* These variables are used to implement target options */ 161 162static char *audit; /* colon (typically) separated list of libs */ 163static char *depaudit; /* colon (typically) separated list of libs */ 164 165/* Style of .note.gnu.build-id section. */ 166static const char *emit_note_gnu_build_id; 167 168/* On Linux, it's possible to have different versions of the same 169 shared library linked against different versions of libc. The 170 dynamic linker somehow tags which libc version to use in 171 /etc/ld.so.cache, and, based on the libc that it sees in the 172 executable, chooses which version of the shared library to use. 173 174 We try to do a similar check here by checking whether this shared 175 library needs any other shared libraries which may conflict with 176 libraries we have already included in the link. If it does, we 177 skip it, and try to find another shared library farther on down the 178 link path. 179 180 This is called via lang_for_each_input_file. 181 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object 182 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find 183 a conflicting version. */ 184 185static void 186gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s) 187{ 188 const char *soname; 189 struct bfd_link_needed_list *l; 190 191 if (global_vercheck_failed) 192 return; 193 if (s->the_bfd == NULL 194 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0) 195 return; 196 197 soname = bfd_elf_get_dt_soname (s->the_bfd); 198 if (soname == NULL) 199 soname = lbasename (bfd_get_filename (s->the_bfd)); 200 201 for (l = global_vercheck_needed; l != NULL; l = l->next) 202 { 203 const char *suffix; 204 205 if (filename_cmp (soname, l->name) == 0) 206 { 207 /* Probably can't happen, but it's an easy check. */ 208 continue; 209 } 210 211 if (strchr (l->name, '/') != NULL) 212 continue; 213 214 suffix = strstr (l->name, ".so."); 215 if (suffix == NULL) 216 continue; 217 218 suffix += sizeof ".so." - 1; 219 220 if (filename_ncmp (soname, l->name, suffix - l->name) == 0) 221 { 222 /* Here we know that S is a dynamic object FOO.SO.VER1, and 223 the object we are considering needs a dynamic object 224 FOO.SO.VER2, and VER1 and VER2 are different. This 225 appears to be a version mismatch, so we tell the caller 226 to try a different version of this library. */ 227 global_vercheck_failed = TRUE; 228 return; 229 } 230 } 231} 232 233 234/* See if an input file matches a DT_NEEDED entry by running stat on 235 the file. */ 236 237static void 238gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s) 239{ 240 struct stat st; 241 const char *suffix; 242 const char *soname; 243 244 if (global_found != NULL) 245 return; 246 if (s->the_bfd == NULL) 247 return; 248 249 /* If this input file was an as-needed entry, and wasn't found to be 250 needed at the stage it was linked, then don't say we have loaded it. */ 251 if ((bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0) 252 return; 253 254 if (bfd_stat (s->the_bfd, &st) != 0) 255 { 256 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd); 257 return; 258 } 259 260 /* Some operating systems, e.g. Windows, do not provide a meaningful 261 st_ino; they always set it to zero. (Windows does provide a 262 meaningful st_dev.) Do not indicate a duplicate library in that 263 case. While there is no guarantee that a system that provides 264 meaningful inode numbers will never set st_ino to zero, this is 265 merely an optimization, so we do not need to worry about false 266 negatives. */ 267 if (st.st_dev == global_stat.st_dev 268 && st.st_ino == global_stat.st_ino 269 && st.st_ino != 0) 270 { 271 global_found = s; 272 return; 273 } 274 275 /* We issue a warning if it looks like we are including two 276 different versions of the same shared library. For example, 277 there may be a problem if -lc picks up libc.so.6 but some other 278 shared library has a DT_NEEDED entry of libc.so.5. This is a 279 heuristic test, and it will only work if the name looks like 280 NAME.so.VERSION. FIXME: Depending on file names is error-prone. 281 If we really want to issue warnings about mixing version numbers 282 of shared libraries, we need to find a better way. */ 283 284 if (strchr (global_needed->name, '/') != NULL) 285 return; 286 suffix = strstr (global_needed->name, ".so."); 287 if (suffix == NULL) 288 return; 289 suffix += sizeof ".so." - 1; 290 291 soname = bfd_elf_get_dt_soname (s->the_bfd); 292 if (soname == NULL) 293 soname = lbasename (s->filename); 294 295 if (filename_ncmp (soname, global_needed->name, suffix - global_needed->name) == 0) 296 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n", 297 global_needed->name, global_needed->by, soname); 298} 299 300struct dt_needed 301{ 302 bfd *by; 303 const char *name; 304}; 305 306/* This function is called for each possible name for a dynamic object 307 named by a DT_NEEDED entry. The FORCE parameter indicates whether 308 to skip the check for a conflicting version. */ 309 310static bfd_boolean 311gld${EMULATION_NAME}_try_needed (struct dt_needed *needed, 312 int force) 313{ 314 bfd *abfd; 315 const char *name = needed->name; 316 const char *soname; 317 int link_class; 318 319 abfd = bfd_openr (name, bfd_get_target (link_info.output_bfd)); 320 if (abfd == NULL) 321 return FALSE; 322 323 /* Linker needs to decompress sections. */ 324 abfd->flags |= BFD_DECOMPRESS; 325 326 if (! bfd_check_format (abfd, bfd_object)) 327 { 328 bfd_close (abfd); 329 return FALSE; 330 } 331 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0) 332 { 333 bfd_close (abfd); 334 return FALSE; 335 } 336 337 /* For DT_NEEDED, they have to match. */ 338 if (abfd->xvec != link_info.output_bfd->xvec) 339 { 340 bfd_close (abfd); 341 return FALSE; 342 } 343 344 /* Check whether this object would include any conflicting library 345 versions. If FORCE is set, then we skip this check; we use this 346 the second time around, if we couldn't find any compatible 347 instance of the shared library. */ 348 349 if (! force) 350 { 351 struct bfd_link_needed_list *needs; 352 353 if (! bfd_elf_get_bfd_needed_list (abfd, &needs)) 354 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd); 355 356 if (needs != NULL) 357 { 358 global_vercheck_needed = needs; 359 global_vercheck_failed = FALSE; 360 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck); 361 if (global_vercheck_failed) 362 { 363 bfd_close (abfd); 364 /* Return FALSE to force the caller to move on to try 365 another file on the search path. */ 366 return FALSE; 367 } 368 369 /* But wait! It gets much worse. On Linux, if a shared 370 library does not use libc at all, we are supposed to skip 371 it the first time around in case we encounter a shared 372 library later on with the same name which does use the 373 version of libc that we want. This is much too horrible 374 to use on any system other than Linux. */ 375 376EOF 377case ${target} in 378 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*) 379 fragment <<EOF 380 { 381 struct bfd_link_needed_list *l; 382 383 for (l = needs; l != NULL; l = l->next) 384 if (CONST_STRNEQ (l->name, "libc.so")) 385 break; 386 if (l == NULL) 387 { 388 bfd_close (abfd); 389 return FALSE; 390 } 391 } 392 393EOF 394 ;; 395esac 396fragment <<EOF 397 } 398 } 399 400 /* We've found a dynamic object matching the DT_NEEDED entry. */ 401 402 /* We have already checked that there is no other input file of the 403 same name. We must now check again that we are not including the 404 same file twice. We need to do this because on many systems 405 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will 406 reference libc.so.1. If we have already included libc.so, we 407 don't want to include libc.so.1 if they are the same file, and we 408 can only check that using stat. */ 409 410 if (bfd_stat (abfd, &global_stat) != 0) 411 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd); 412 413 /* First strip off everything before the last '/'. */ 414 soname = lbasename (abfd->filename); 415 416 if (verbose) 417 info_msg (_("found %s at %s\n"), soname, name); 418 419 global_found = NULL; 420 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed); 421 if (global_found != NULL) 422 { 423 /* Return TRUE to indicate that we found the file, even though 424 we aren't going to do anything with it. */ 425 return TRUE; 426 } 427 428 /* Specify the soname to use. */ 429 bfd_elf_set_dt_needed_name (abfd, soname); 430 431 /* Tell the ELF linker that we don't want the output file to have a 432 DT_NEEDED entry for this file, unless it is used to resolve 433 references in a regular object. */ 434 link_class = DYN_DT_NEEDED; 435 436 /* Tell the ELF linker that we don't want the output file to have a 437 DT_NEEDED entry for this file at all if the entry is from a file 438 with DYN_NO_ADD_NEEDED. */ 439 if (needed->by != NULL 440 && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0) 441 link_class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED; 442 443 bfd_elf_set_dyn_lib_class (abfd, (enum dynamic_lib_link_class) link_class); 444 445 /* Add this file into the symbol table. */ 446 if (! bfd_link_add_symbols (abfd, &link_info)) 447 einfo ("%F%B: error adding symbols: %E\n", abfd); 448 449 return TRUE; 450} 451 452 453/* Search for a needed file in a path. */ 454 455static bfd_boolean 456gld${EMULATION_NAME}_search_needed (const char *path, 457 struct dt_needed *n, int force) 458{ 459 const char *s; 460 const char *name = n->name; 461 size_t len; 462 struct dt_needed needed; 463 464 if (name[0] == '/') 465 return gld${EMULATION_NAME}_try_needed (n, force); 466 467 if (path == NULL || *path == '\0') 468 return FALSE; 469 470 needed.by = n->by; 471 needed.name = n->name; 472 473 len = strlen (name); 474 while (1) 475 { 476 char *filename, *sset; 477 478 s = strchr (path, config.rpath_separator); 479 if (s == NULL) 480 s = path + strlen (path); 481 482#if HAVE_DOS_BASED_FILE_SYSTEM 483 /* Assume a match on the second char is part of drive specifier. */ 484 else if (config.rpath_separator == ':' 485 && s == path + 1 486 && ISALPHA (*path)) 487 { 488 s = strchr (s + 1, config.rpath_separator); 489 if (s == NULL) 490 s = path + strlen (path); 491 } 492#endif 493 filename = (char *) xmalloc (s - path + len + 2); 494 if (s == path) 495 sset = filename; 496 else 497 { 498 memcpy (filename, path, s - path); 499 filename[s - path] = '/'; 500 sset = filename + (s - path) + 1; 501 } 502 strcpy (sset, name); 503 504 needed.name = filename; 505 if (gld${EMULATION_NAME}_try_needed (&needed, force)) 506 return TRUE; 507 508 free (filename); 509 510 if (*s == '\0') 511 break; 512 path = s + 1; 513 } 514 515 return FALSE; 516} 517 518EOF 519if [ "x${USE_LIBPATH}" = xyes ] ; then 520 fragment <<EOF 521 522/* Add the sysroot to every entry in a path separated by 523 config.rpath_separator. */ 524 525static char * 526gld${EMULATION_NAME}_add_sysroot (const char *path) 527{ 528 int len, colons, i; 529 char *ret, *p; 530 531 len = strlen (path); 532 colons = 0; 533 i = 0; 534 while (path[i]) 535 if (path[i++] == config.rpath_separator) 536 colons++; 537 538 if (path[i]) 539 colons++; 540 541 len = len + (colons + 1) * strlen (ld_sysroot); 542 ret = xmalloc (len + 1); 543 strcpy (ret, ld_sysroot); 544 p = ret + strlen (ret); 545 i = 0; 546 while (path[i]) 547 if (path[i] == config.rpath_separator) 548 { 549 *p++ = path[i++]; 550 strcpy (p, ld_sysroot); 551 p = p + strlen (p); 552 } 553 else 554 *p++ = path[i++]; 555 556 *p = 0; 557 return ret; 558} 559 560EOF 561 case ${target} in 562 *-*-freebsd* | *-*-dragonfly*) 563 fragment <<EOF 564/* Read the system search path the FreeBSD way rather than the Linux way. */ 565#ifdef HAVE_ELF_HINTS_H 566#include <elf-hints.h> 567#else 568#include "elf-hints-local.h" 569#endif 570 571static bfd_boolean 572gld${EMULATION_NAME}_check_ld_elf_hints (const struct bfd_link_needed_list *l, 573 int force) 574{ 575 static bfd_boolean initialized; 576 static char *ld_elf_hints; 577 struct dt_needed needed; 578 579 if (!initialized) 580 { 581 FILE *f; 582 char *tmppath; 583 584 tmppath = concat (ld_sysroot, _PATH_ELF_HINTS, (const char *) NULL); 585 f = fopen (tmppath, FOPEN_RB); 586 free (tmppath); 587 if (f != NULL) 588 { 589 struct elfhints_hdr hdr; 590 591 if (fread (&hdr, 1, sizeof (hdr), f) == sizeof (hdr) 592 && hdr.magic == ELFHINTS_MAGIC 593 && hdr.version == 1) 594 { 595 if (fseek (f, hdr.strtab + hdr.dirlist, SEEK_SET) != -1) 596 { 597 char *b; 598 599 b = xmalloc (hdr.dirlistlen + 1); 600 if (fread (b, 1, hdr.dirlistlen + 1, f) == 601 hdr.dirlistlen + 1) 602 ld_elf_hints = gld${EMULATION_NAME}_add_sysroot (b); 603 604 free (b); 605 } 606 } 607 fclose (f); 608 } 609 610 initialized = TRUE; 611 } 612 613 if (ld_elf_hints == NULL) 614 return FALSE; 615 616 needed.by = l->by; 617 needed.name = l->name; 618 return gld${EMULATION_NAME}_search_needed (ld_elf_hints, &needed, force); 619} 620EOF 621 # FreeBSD 622 ;; 623 624 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*) 625 fragment <<EOF 626/* For a native linker, check the file /etc/ld.so.conf for directories 627 in which we may find shared libraries. /etc/ld.so.conf is really 628 only meaningful on Linux. */ 629 630struct gld${EMULATION_NAME}_ld_so_conf 631{ 632 char *path; 633 size_t len, alloc; 634}; 635 636static bfd_boolean 637gld${EMULATION_NAME}_parse_ld_so_conf 638 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename); 639 640static void 641gld${EMULATION_NAME}_parse_ld_so_conf_include 642 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename, 643 const char *pattern) 644{ 645 char *newp = NULL; 646#ifdef HAVE_GLOB 647 glob_t gl; 648#endif 649 650 if (pattern[0] != '/') 651 { 652 char *p = strrchr (filename, '/'); 653 size_t patlen = strlen (pattern) + 1; 654 655 newp = xmalloc (p - filename + 1 + patlen); 656 memcpy (newp, filename, p - filename + 1); 657 memcpy (newp + (p - filename + 1), pattern, patlen); 658 pattern = newp; 659 } 660 661#ifdef HAVE_GLOB 662 if (glob (pattern, 0, NULL, &gl) == 0) 663 { 664 size_t i; 665 666 for (i = 0; i < gl.gl_pathc; ++i) 667 gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]); 668 globfree (&gl); 669 } 670#else 671 /* If we do not have glob, treat the pattern as a literal filename. */ 672 gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern); 673#endif 674 675 if (newp) 676 free (newp); 677} 678 679static bfd_boolean 680gld${EMULATION_NAME}_parse_ld_so_conf 681 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename) 682{ 683 FILE *f = fopen (filename, FOPEN_RT); 684 char *line; 685 size_t linelen; 686 687 if (f == NULL) 688 return FALSE; 689 690 linelen = 256; 691 line = xmalloc (linelen); 692 do 693 { 694 char *p = line, *q; 695 696 /* Normally this would use getline(3), but we need to be portable. */ 697 while ((q = fgets (p, linelen - (p - line), f)) != NULL 698 && strlen (q) == linelen - (p - line) - 1 699 && line[linelen - 2] != '\n') 700 { 701 line = xrealloc (line, 2 * linelen); 702 p = line + linelen - 1; 703 linelen += linelen; 704 } 705 706 if (q == NULL && p == line) 707 break; 708 709 p = strchr (line, '\n'); 710 if (p) 711 *p = '\0'; 712 713 /* Because the file format does not know any form of quoting we 714 can search forward for the next '#' character and if found 715 make it terminating the line. */ 716 p = strchr (line, '#'); 717 if (p) 718 *p = '\0'; 719 720 /* Remove leading whitespace. NUL is no whitespace character. */ 721 p = line; 722 while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v') 723 ++p; 724 725 /* If the line is blank it is ignored. */ 726 if (p[0] == '\0') 727 continue; 728 729 if (CONST_STRNEQ (p, "include") && (p[7] == ' ' || p[7] == '\t')) 730 { 731 char *dir, c; 732 p += 8; 733 do 734 { 735 while (*p == ' ' || *p == '\t') 736 ++p; 737 738 if (*p == '\0') 739 break; 740 741 dir = p; 742 743 while (*p != ' ' && *p != '\t' && *p) 744 ++p; 745 746 c = *p; 747 *p++ = '\0'; 748 if (dir[0] != '\0') 749 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename, 750 dir); 751 } 752 while (c != '\0'); 753 } 754 else 755 { 756 char *dir = p; 757 while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f' 758 && *p != '\r' && *p != '\v') 759 ++p; 760 761 while (p != dir && p[-1] == '/') 762 --p; 763 if (info->path == NULL) 764 { 765 info->alloc = p - dir + 1 + 256; 766 info->path = xmalloc (info->alloc); 767 info->len = 0; 768 } 769 else 770 { 771 if (info->len + 1 + (p - dir) >= info->alloc) 772 { 773 info->alloc += p - dir + 256; 774 info->path = xrealloc (info->path, info->alloc); 775 } 776 info->path[info->len++] = config.rpath_separator; 777 } 778 memcpy (info->path + info->len, dir, p - dir); 779 info->len += p - dir; 780 info->path[info->len] = '\0'; 781 } 782 } 783 while (! feof (f)); 784 free (line); 785 fclose (f); 786 return TRUE; 787} 788 789static bfd_boolean 790gld${EMULATION_NAME}_check_ld_so_conf (const struct bfd_link_needed_list *l, 791 int force) 792{ 793 static bfd_boolean initialized; 794 static char *ld_so_conf; 795 struct dt_needed needed; 796 797 if (! initialized) 798 { 799 char *tmppath; 800 struct gld${EMULATION_NAME}_ld_so_conf info; 801 802 info.path = NULL; 803 info.len = info.alloc = 0; 804 tmppath = concat (ld_sysroot, "${prefix}/etc/ld.so.conf", 805 (const char *) NULL); 806 if (!gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath)) 807 { 808 free (tmppath); 809 tmppath = concat (ld_sysroot, "/etc/ld.so.conf", 810 (const char *) NULL); 811 gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath); 812 } 813 free (tmppath); 814 815 if (info.path) 816 { 817 char *d = gld${EMULATION_NAME}_add_sysroot (info.path); 818 free (info.path); 819 ld_so_conf = d; 820 } 821 initialized = TRUE; 822 } 823 824 if (ld_so_conf == NULL) 825 return FALSE; 826 827 828 needed.by = l->by; 829 needed.name = l->name; 830 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force); 831} 832 833EOF 834 # Linux 835 ;; 836 esac 837fi 838fragment <<EOF 839 840/* See if an input file matches a DT_NEEDED entry by name. */ 841 842static void 843gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s) 844{ 845 const char *soname; 846 847 /* Stop looking if we've found a loaded lib. */ 848 if (global_found != NULL 849 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd) 850 & DYN_AS_NEEDED) == 0) 851 return; 852 853 if (s->filename == NULL || s->the_bfd == NULL) 854 return; 855 856 /* Don't look for a second non-loaded as-needed lib. */ 857 if (global_found != NULL 858 && (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0) 859 return; 860 861 if (filename_cmp (s->filename, global_needed->name) == 0) 862 { 863 global_found = s; 864 return; 865 } 866 867 if (s->flags.search_dirs) 868 { 869 const char *f = strrchr (s->filename, '/'); 870 if (f != NULL 871 && filename_cmp (f + 1, global_needed->name) == 0) 872 { 873 global_found = s; 874 return; 875 } 876 } 877 878 soname = bfd_elf_get_dt_soname (s->the_bfd); 879 if (soname != NULL 880 && filename_cmp (soname, global_needed->name) == 0) 881 { 882 global_found = s; 883 return; 884 } 885} 886 887EOF 888 889if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then 890fragment <<EOF 891 892static bfd_size_type 893id_note_section_size (bfd *abfd ATTRIBUTE_UNUSED) 894{ 895 const char *style = emit_note_gnu_build_id; 896 bfd_size_type size; 897 bfd_size_type build_id_size; 898 899 size = offsetof (Elf_External_Note, name[sizeof "GNU"]); 900 size = (size + 3) & -(bfd_size_type) 4; 901 902 build_id_size = compute_build_id_size (style); 903 if (build_id_size) 904 size += build_id_size; 905 else 906 size = 0; 907 908 return size; 909} 910 911static bfd_boolean 912write_build_id (bfd *abfd) 913{ 914 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 915 struct elf_obj_tdata *t = elf_tdata (abfd); 916 const char *style; 917 asection *asec; 918 Elf_Internal_Shdr *i_shdr; 919 unsigned char *contents, *id_bits; 920 bfd_size_type size; 921 file_ptr position; 922 Elf_External_Note *e_note; 923 924 style = t->o->build_id.style; 925 asec = t->o->build_id.sec; 926 if (bfd_is_abs_section (asec->output_section)) 927 { 928 einfo (_("%P: warning: .note.gnu.build-id section discarded," 929 " --build-id ignored.\n")); 930 return TRUE; 931 } 932 i_shdr = &elf_section_data (asec->output_section)->this_hdr; 933 934 if (i_shdr->contents == NULL) 935 { 936 if (asec->contents == NULL) 937 asec->contents = (unsigned char *) xmalloc (asec->size); 938 contents = asec->contents; 939 } 940 else 941 contents = i_shdr->contents + asec->output_offset; 942 943 e_note = (Elf_External_Note *) contents; 944 size = offsetof (Elf_External_Note, name[sizeof "GNU"]); 945 size = (size + 3) & -(bfd_size_type) 4; 946 id_bits = contents + size; 947 size = asec->size - size; 948 949 bfd_h_put_32 (abfd, sizeof "GNU", &e_note->namesz); 950 bfd_h_put_32 (abfd, size, &e_note->descsz); 951 bfd_h_put_32 (abfd, NT_GNU_BUILD_ID, &e_note->type); 952 memcpy (e_note->name, "GNU", sizeof "GNU"); 953 954 generate_build_id (abfd, style, bed->s->checksum_contents, id_bits, size); 955 956 position = i_shdr->sh_offset + asec->output_offset; 957 size = asec->size; 958 return (bfd_seek (abfd, position, SEEK_SET) == 0 959 && bfd_bwrite (contents, size, abfd) == size); 960} 961 962/* Make .note.gnu.build-id section, and set up elf_tdata->build_id. */ 963 964static bfd_boolean 965setup_build_id (bfd *ibfd) 966{ 967 asection *s; 968 bfd_size_type size; 969 flagword flags; 970 971 size = id_note_section_size (ibfd); 972 if (size == 0) 973 { 974 einfo ("%P: warning: unrecognized --build-id style ignored.\n"); 975 return FALSE; 976 } 977 978 flags = (SEC_ALLOC | SEC_LOAD | SEC_IN_MEMORY 979 | SEC_LINKER_CREATED | SEC_READONLY | SEC_DATA); 980 s = bfd_make_section_with_flags (ibfd, ".note.gnu.build-id", flags); 981 if (s != NULL && bfd_set_section_alignment (ibfd, s, 2)) 982 { 983 struct elf_obj_tdata *t = elf_tdata (link_info.output_bfd); 984 t->o->build_id.after_write_object_contents = &write_build_id; 985 t->o->build_id.style = emit_note_gnu_build_id; 986 t->o->build_id.sec = s; 987 elf_section_type (s) = SHT_NOTE; 988 s->size = size; 989 return TRUE; 990 } 991 992 einfo ("%P: warning: Cannot create .note.gnu.build-id section," 993 " --build-id ignored.\n"); 994 return FALSE; 995} 996 997/* This is called after all the input files have been opened. */ 998 999static void 1000gld${EMULATION_NAME}_after_open (void) 1001{ 1002 struct bfd_link_needed_list *needed, *l; 1003 struct elf_link_hash_table *htab; 1004 1005 after_open_default (); 1006 1007 htab = elf_hash_table (&link_info); 1008 if (!is_elf_hash_table (htab)) 1009 return; 1010 1011 if (emit_note_gnu_build_id != NULL) 1012 { 1013 bfd *abfd; 1014 1015 /* Find an ELF input. */ 1016 for (abfd = link_info.input_bfds; 1017 abfd != (bfd *) NULL; abfd = abfd->link.next) 1018 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1019 break; 1020 1021 /* PR 10555: If there are no ELF input files do not try to 1022 create a .note.gnu-build-id section. */ 1023 if (abfd == NULL 1024 || !setup_build_id (abfd)) 1025 { 1026 free ((char *) emit_note_gnu_build_id); 1027 emit_note_gnu_build_id = NULL; 1028 } 1029 } 1030 1031 if (link_info.relocatable) 1032 { 1033 if (link_info.execstack == ! link_info.noexecstack) 1034 /* PR ld/16744: If "-z [no]execstack" has been specified on the 1035 command line and we are perfoming a relocatable link then no 1036 PT_GNU_STACK segment will be created and so the 1037 linkinfo.[no]execstack values set in _handle_option() will have no 1038 effect. Instead we create a .note.GNU-stack section in much the 1039 same way as the assembler does with its --[no]execstack option. */ 1040 (void) bfd_make_section_with_flags (link_info.input_bfds, 1041 ".note.GNU-stack", 1042 SEC_READONLY | (link_info.execstack ? SEC_CODE : 0)); 1043 1044 return; 1045 } 1046 1047 if (link_info.eh_frame_hdr 1048 && !link_info.traditional_format) 1049 { 1050 bfd *abfd, *elfbfd = NULL; 1051 bfd_boolean warn_eh_frame = FALSE; 1052 asection *s; 1053 1054 for (abfd = link_info.input_bfds; abfd; abfd = abfd->link.next) 1055 { 1056 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1057 elfbfd = abfd; 1058 if (!warn_eh_frame) 1059 { 1060 s = bfd_get_section_by_name (abfd, ".eh_frame"); 1061 while (s != NULL 1062 && (s->size <= 8 1063 || bfd_is_abs_section (s->output_section))) 1064 s = bfd_get_next_section_by_name (s); 1065 warn_eh_frame = s != NULL; 1066 } 1067 if (elfbfd && warn_eh_frame) 1068 break; 1069 } 1070 if (elfbfd) 1071 { 1072 const struct elf_backend_data *bed; 1073 1074 bed = get_elf_backend_data (elfbfd); 1075 s = bfd_make_section_with_flags (elfbfd, ".eh_frame_hdr", 1076 bed->dynamic_sec_flags 1077 | SEC_READONLY); 1078 if (s != NULL 1079 && bfd_set_section_alignment (elfbfd, s, 2)) 1080 { 1081 htab->eh_info.hdr_sec = s; 1082 warn_eh_frame = FALSE; 1083 } 1084 } 1085 if (warn_eh_frame) 1086 einfo ("%P: warning: Cannot create .eh_frame_hdr section," 1087 " --eh-frame-hdr ignored.\n"); 1088 } 1089 1090 /* Get the list of files which appear in DT_NEEDED entries in 1091 dynamic objects included in the link (often there will be none). 1092 For each such file, we want to track down the corresponding 1093 library, and include the symbol table in the link. This is what 1094 the runtime dynamic linker will do. Tracking the files down here 1095 permits one dynamic object to include another without requiring 1096 special action by the person doing the link. Note that the 1097 needed list can actually grow while we are stepping through this 1098 loop. */ 1099 needed = bfd_elf_get_needed_list (link_info.output_bfd, &link_info); 1100 for (l = needed; l != NULL; l = l->next) 1101 { 1102 struct bfd_link_needed_list *ll; 1103 struct dt_needed n, nn; 1104 int force; 1105 1106 /* If the lib that needs this one was --as-needed and wasn't 1107 found to be needed, then this lib isn't needed either. */ 1108 if (l->by != NULL 1109 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0) 1110 continue; 1111 1112 /* Skip the lib if --no-copy-dt-needed-entries and 1113 --allow-shlib-undefined is in effect. */ 1114 if (l->by != NULL 1115 && link_info.unresolved_syms_in_shared_libs == RM_IGNORE 1116 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_NO_ADD_NEEDED) != 0) 1117 continue; 1118 1119 /* If we've already seen this file, skip it. */ 1120 for (ll = needed; ll != l; ll = ll->next) 1121 if ((ll->by == NULL 1122 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0) 1123 && strcmp (ll->name, l->name) == 0) 1124 break; 1125 if (ll != l) 1126 continue; 1127 1128 /* See if this file was included in the link explicitly. */ 1129 global_needed = l; 1130 global_found = NULL; 1131 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed); 1132 if (global_found != NULL 1133 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd) 1134 & DYN_AS_NEEDED) == 0) 1135 continue; 1136 1137 n.by = l->by; 1138 n.name = l->name; 1139 nn.by = l->by; 1140 if (verbose) 1141 info_msg (_("%s needed by %B\n"), l->name, l->by); 1142 1143 /* As-needed libs specified on the command line (or linker script) 1144 take priority over libs found in search dirs. */ 1145 if (global_found != NULL) 1146 { 1147 nn.name = global_found->filename; 1148 if (gld${EMULATION_NAME}_try_needed (&nn, TRUE)) 1149 continue; 1150 } 1151 1152 /* We need to find this file and include the symbol table. We 1153 want to search for the file in the same way that the dynamic 1154 linker will search. That means that we want to use 1155 rpath_link, rpath, then the environment variable 1156 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH 1157 entries (native only), then the linker script LIB_SEARCH_DIRS. 1158 We do not search using the -L arguments. 1159 1160 We search twice. The first time, we skip objects which may 1161 introduce version mismatches. The second time, we force 1162 their use. See gld${EMULATION_NAME}_vercheck comment. */ 1163 for (force = 0; force < 2; force++) 1164 { 1165 size_t len; 1166 search_dirs_type *search; 1167EOF 1168if [ "x${NATIVE}" = xyes ] ; then 1169fragment <<EOF 1170 const char *lib_path; 1171EOF 1172fi 1173if [ "x${USE_LIBPATH}" = xyes ] ; then 1174fragment <<EOF 1175 struct bfd_link_needed_list *rp; 1176 int found; 1177EOF 1178fi 1179fragment <<EOF 1180 1181 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link, 1182 &n, force)) 1183 break; 1184EOF 1185if [ "x${USE_LIBPATH}" = xyes ] ; then 1186fragment <<EOF 1187 if (gld${EMULATION_NAME}_search_needed (command_line.rpath, 1188 &n, force)) 1189 break; 1190EOF 1191fi 1192if [ "x${NATIVE}" = xyes ] ; then 1193fragment <<EOF 1194 if (command_line.rpath_link == NULL 1195 && command_line.rpath == NULL) 1196 { 1197 lib_path = (const char *) getenv ("LD_RUN_PATH"); 1198 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, 1199 force)) 1200 break; 1201 } 1202 lib_path = (const char *) getenv ("LD_LIBRARY_PATH"); 1203 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force)) 1204 break; 1205EOF 1206fi 1207if [ "x${USE_LIBPATH}" = xyes ] ; then 1208fragment <<EOF 1209 found = 0; 1210 rp = bfd_elf_get_runpath_list (link_info.output_bfd, &link_info); 1211 for (; !found && rp != NULL; rp = rp->next) 1212 { 1213 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name); 1214 found = (rp->by == l->by 1215 && gld${EMULATION_NAME}_search_needed (tmpname, 1216 &n, 1217 force)); 1218 free (tmpname); 1219 } 1220 if (found) 1221 break; 1222 1223EOF 1224fi 1225if [ "x${USE_LIBPATH}" = xyes ] ; then 1226 case ${target} in 1227 *-*-freebsd* | *-*-dragonfly*) 1228 fragment <<EOF 1229 if (gld${EMULATION_NAME}_check_ld_elf_hints (l, force)) 1230 break; 1231EOF 1232 # FreeBSD 1233 ;; 1234 1235 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*) 1236 fragment <<EOF 1237 if (gld${EMULATION_NAME}_check_ld_so_conf (l, force)) 1238 break; 1239 1240EOF 1241 # Linux 1242 ;; 1243 esac 1244fi 1245fragment <<EOF 1246 len = strlen (l->name); 1247 for (search = search_head; search != NULL; search = search->next) 1248 { 1249 char *filename; 1250 1251 if (search->cmdline) 1252 continue; 1253 filename = (char *) xmalloc (strlen (search->name) + len + 2); 1254 sprintf (filename, "%s/%s", search->name, l->name); 1255 nn.name = filename; 1256 if (gld${EMULATION_NAME}_try_needed (&nn, force)) 1257 break; 1258 free (filename); 1259 } 1260 if (search != NULL) 1261 break; 1262EOF 1263fragment <<EOF 1264 } 1265 1266 if (force < 2) 1267 continue; 1268 1269 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n", 1270 l->name, l->by); 1271 } 1272} 1273 1274EOF 1275fi 1276 1277fragment <<EOF 1278 1279/* Look through an expression for an assignment statement. */ 1280 1281static void 1282gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp) 1283{ 1284 bfd_boolean provide = FALSE; 1285 1286 switch (exp->type.node_class) 1287 { 1288 case etree_provide: 1289 case etree_provided: 1290 provide = TRUE; 1291 /* Fall thru */ 1292 case etree_assign: 1293 /* We call record_link_assignment even if the symbol is defined. 1294 This is because if it is defined by a dynamic object, we 1295 actually want to use the value defined by the linker script, 1296 not the value from the dynamic object (because we are setting 1297 symbols like etext). If the symbol is defined by a regular 1298 object, then, as it happens, calling record_link_assignment 1299 will do no harm. */ 1300 if (strcmp (exp->assign.dst, ".") != 0) 1301 { 1302 if (!bfd_elf_record_link_assignment (link_info.output_bfd, 1303 &link_info, 1304 exp->assign.dst, provide, 1305 exp->assign.hidden)) 1306 einfo ("%P%F: failed to record assignment to %s: %E\n", 1307 exp->assign.dst); 1308 } 1309 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src); 1310 break; 1311 1312 case etree_binary: 1313 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs); 1314 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs); 1315 break; 1316 1317 case etree_trinary: 1318 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond); 1319 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs); 1320 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs); 1321 break; 1322 1323 case etree_unary: 1324 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child); 1325 break; 1326 1327 default: 1328 break; 1329 } 1330} 1331 1332 1333/* This is called by the before_allocation routine via 1334 lang_for_each_statement. It locates any assignment statements, and 1335 tells the ELF backend about them, in case they are assignments to 1336 symbols which are referred to by dynamic objects. */ 1337 1338static void 1339gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s) 1340{ 1341 if (s->header.type == lang_assignment_statement_enum) 1342 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp); 1343} 1344 1345EOF 1346 1347if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then 1348 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then 1349 ELF_INTERPRETER_SET_DEFAULT=" 1350 if (sinterp != NULL) 1351 { 1352 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME}; 1353 sinterp->size = strlen ((char *) sinterp->contents) + 1; 1354 } 1355 1356" 1357 else 1358 ELF_INTERPRETER_SET_DEFAULT= 1359 fi 1360fragment <<EOF 1361 1362/* used by before_allocation and handle_option. */ 1363static void 1364gld${EMULATION_NAME}_append_to_separated_string (char **to, char *op_arg) 1365{ 1366 if (*to == NULL) 1367 *to = xstrdup (op_arg); 1368 else 1369 { 1370 size_t to_len = strlen (*to); 1371 size_t op_arg_len = strlen (op_arg); 1372 char *buf; 1373 char *cp = *to; 1374 1375 /* First see whether OPTARG is already in the path. */ 1376 do 1377 { 1378 if (strncmp (op_arg, cp, op_arg_len) == 0 1379 && (cp[op_arg_len] == 0 1380 || cp[op_arg_len] == config.rpath_separator)) 1381 /* We found it. */ 1382 break; 1383 1384 /* Not yet found. */ 1385 cp = strchr (cp, config.rpath_separator); 1386 if (cp != NULL) 1387 ++cp; 1388 } 1389 while (cp != NULL); 1390 1391 if (cp == NULL) 1392 { 1393 buf = xmalloc (to_len + op_arg_len + 2); 1394 sprintf (buf, "%s%c%s", *to, 1395 config.rpath_separator, op_arg); 1396 free (*to); 1397 *to = buf; 1398 } 1399 } 1400} 1401 1402/* This is called after the sections have been attached to output 1403 sections, but before any sizes or addresses have been set. */ 1404 1405static void 1406gld${EMULATION_NAME}_before_allocation (void) 1407{ 1408 const char *rpath; 1409 asection *sinterp; 1410 bfd *abfd; 1411 struct elf_link_hash_entry *ehdr_start = NULL; 1412 struct bfd_link_hash_entry ehdr_start_save = ehdr_start_save; 1413 1414 if (is_elf_hash_table (link_info.hash)) 1415 { 1416 _bfd_elf_tls_setup (link_info.output_bfd, &link_info); 1417 1418 /* Make __ehdr_start hidden if it has been referenced, to 1419 prevent the symbol from being dynamic. */ 1420 if (!link_info.relocatable) 1421 { 1422 struct elf_link_hash_entry *h 1423 = elf_link_hash_lookup (elf_hash_table (&link_info), "__ehdr_start", 1424 FALSE, FALSE, TRUE); 1425 1426 /* Only adjust the export class if the symbol was referenced 1427 and not defined, otherwise leave it alone. */ 1428 if (h != NULL 1429 && (h->root.type == bfd_link_hash_new 1430 || h->root.type == bfd_link_hash_undefined 1431 || h->root.type == bfd_link_hash_undefweak 1432 || h->root.type == bfd_link_hash_common)) 1433 { 1434 _bfd_elf_link_hash_hide_symbol (&link_info, h, TRUE); 1435 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL) 1436 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN; 1437 /* Don't leave the symbol undefined. Undefined hidden 1438 symbols typically won't have dynamic relocations, but 1439 we most likely will need dynamic relocations for 1440 __ehdr_start if we are building a PIE or shared 1441 library. */ 1442 ehdr_start = h; 1443 ehdr_start_save = h->root; 1444 h->root.type = bfd_link_hash_defined; 1445 h->root.u.def.section = bfd_abs_section_ptr; 1446 h->root.u.def.value = 0; 1447 } 1448 } 1449 1450 /* If we are going to make any variable assignments, we need to 1451 let the ELF backend know about them in case the variables are 1452 referred to by dynamic objects. */ 1453 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment); 1454 } 1455 1456 /* Let the ELF backend work out the sizes of any sections required 1457 by dynamic linking. */ 1458 rpath = command_line.rpath; 1459 if (rpath == NULL) 1460 rpath = (const char *) getenv ("LD_RUN_PATH"); 1461 1462 for (abfd = link_info.input_bfds; abfd; abfd = abfd->link.next) 1463 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1464 { 1465 const char *audit_libs = elf_dt_audit (abfd); 1466 1467 /* If the input bfd contains an audit entry, we need to add it as 1468 a dep audit entry. */ 1469 if (audit_libs && *audit_libs != '\0') 1470 { 1471 char *cp = xstrdup (audit_libs); 1472 do 1473 { 1474 int more = 0; 1475 char *cp2 = strchr (cp, config.rpath_separator); 1476 1477 if (cp2) 1478 { 1479 *cp2 = '\0'; 1480 more = 1; 1481 } 1482 1483 if (cp != NULL && *cp != '\0') 1484 gld${EMULATION_NAME}_append_to_separated_string (&depaudit, cp); 1485 1486 cp = more ? ++cp2 : NULL; 1487 } 1488 while (cp != NULL); 1489 } 1490 } 1491 1492 if (! (bfd_elf_size_dynamic_sections 1493 (link_info.output_bfd, command_line.soname, rpath, 1494 command_line.filter_shlib, audit, depaudit, 1495 (const char * const *) command_line.auxiliary_filters, 1496 &link_info, &sinterp))) 1497 einfo ("%P%F: failed to set dynamic section sizes: %E\n"); 1498 1499${ELF_INTERPRETER_SET_DEFAULT} 1500 /* Let the user override the dynamic linker we are using. */ 1501 if (command_line.interpreter != NULL 1502 && sinterp != NULL) 1503 { 1504 sinterp->contents = (bfd_byte *) command_line.interpreter; 1505 sinterp->size = strlen (command_line.interpreter) + 1; 1506 } 1507 1508 /* Look for any sections named .gnu.warning. As a GNU extensions, 1509 we treat such sections as containing warning messages. We print 1510 out the warning message, and then zero out the section size so 1511 that it does not get copied into the output file. */ 1512 1513 { 1514 LANG_FOR_EACH_INPUT_STATEMENT (is) 1515 { 1516 asection *s; 1517 bfd_size_type sz; 1518 char *msg; 1519 bfd_boolean ret; 1520 1521 if (is->flags.just_syms) 1522 continue; 1523 1524 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning"); 1525 if (s == NULL) 1526 continue; 1527 1528 sz = s->size; 1529 msg = (char *) xmalloc ((size_t) (sz + 1)); 1530 if (! bfd_get_section_contents (is->the_bfd, s, msg, 1531 (file_ptr) 0, sz)) 1532 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n", 1533 is->the_bfd); 1534 msg[sz] = '\0'; 1535 ret = link_info.callbacks->warning (&link_info, msg, 1536 (const char *) NULL, 1537 is->the_bfd, (asection *) NULL, 1538 (bfd_vma) 0); 1539 ASSERT (ret); 1540 free (msg); 1541 1542 /* Clobber the section size, so that we don't waste space 1543 copying the warning into the output file. If we've already 1544 sized the output section, adjust its size. The adjustment 1545 is on rawsize because targets that size sections early will 1546 have called lang_reset_memory_regions after sizing. */ 1547 if (s->output_section != NULL 1548 && s->output_section->rawsize >= s->size) 1549 s->output_section->rawsize -= s->size; 1550 1551 s->size = 0; 1552 1553 /* Also set SEC_EXCLUDE, so that local symbols defined in the 1554 warning section don't get copied to the output. */ 1555 s->flags |= SEC_EXCLUDE | SEC_KEEP; 1556 } 1557 } 1558 1559 before_allocation_default (); 1560 1561 if (!bfd_elf_size_dynsym_hash_dynstr (link_info.output_bfd, &link_info)) 1562 einfo ("%P%F: failed to set dynamic section sizes: %E\n"); 1563 1564 if (ehdr_start != NULL) 1565 { 1566 /* If we twiddled __ehdr_start to defined earlier, put it back 1567 as it was. */ 1568 ehdr_start->root.type = ehdr_start_save.type; 1569 ehdr_start->root.u = ehdr_start_save.u; 1570 } 1571} 1572 1573EOF 1574fi 1575 1576if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then 1577fragment <<EOF 1578 1579/* Try to open a dynamic archive. This is where we know that ELF 1580 dynamic libraries have an extension of .so (or .sl on oddball systems 1581 like hpux). */ 1582 1583static bfd_boolean 1584gld${EMULATION_NAME}_open_dynamic_archive 1585 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry) 1586{ 1587 const char *filename; 1588 char *string; 1589 size_t len; 1590 bfd_boolean opened = FALSE; 1591 1592 if (! entry->flags.maybe_archive) 1593 return FALSE; 1594 1595 filename = entry->filename; 1596 len = strlen (search->name) + strlen (filename); 1597 if (entry->flags.full_name_provided) 1598 { 1599 len += sizeof "/"; 1600 string = (char *) xmalloc (len); 1601 sprintf (string, "%s/%s", search->name, filename); 1602 } 1603 else 1604 { 1605 size_t xlen = 0; 1606 1607 len += strlen (arch) + sizeof "/lib.so"; 1608#ifdef EXTRA_SHLIB_EXTENSION 1609 xlen = (strlen (EXTRA_SHLIB_EXTENSION) > 3 1610 ? strlen (EXTRA_SHLIB_EXTENSION) - 3 1611 : 0); 1612#endif 1613 string = (char *) xmalloc (len + xlen); 1614 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch); 1615#ifdef EXTRA_SHLIB_EXTENSION 1616 /* Try the .so extension first. If that fails build a new filename 1617 using EXTRA_SHLIB_EXTENSION. */ 1618 opened = ldfile_try_open_bfd (string, entry); 1619 if (!opened) 1620 strcpy (string + len - 4, EXTRA_SHLIB_EXTENSION); 1621#endif 1622 } 1623 1624 if (!opened && !ldfile_try_open_bfd (string, entry)) 1625 { 1626 free (string); 1627 return FALSE; 1628 } 1629 1630 entry->filename = string; 1631 1632 /* We have found a dynamic object to include in the link. The ELF 1633 backend linker will create a DT_NEEDED entry in the .dynamic 1634 section naming this file. If this file includes a DT_SONAME 1635 entry, it will be used. Otherwise, the ELF linker will just use 1636 the name of the file. For an archive found by searching, like 1637 this one, the DT_NEEDED entry should consist of just the name of 1638 the file, without the path information used to find it. Note 1639 that we only need to do this if we have a dynamic object; an 1640 archive will never be referenced by a DT_NEEDED entry. 1641 1642 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not 1643 very pretty. I haven't been able to think of anything that is 1644 pretty, though. */ 1645 if (bfd_check_format (entry->the_bfd, bfd_object) 1646 && (entry->the_bfd->flags & DYNAMIC) != 0) 1647 { 1648 ASSERT (entry->flags.maybe_archive && entry->flags.search_dirs); 1649 1650 /* Rather than duplicating the logic above. Just use the 1651 filename we recorded earlier. */ 1652 1653 if (!entry->flags.full_name_provided) 1654 filename = lbasename (entry->filename); 1655 bfd_elf_set_dt_needed_name (entry->the_bfd, filename); 1656 } 1657 1658 return TRUE; 1659} 1660 1661EOF 1662fi 1663 1664if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then 1665fragment <<EOF 1666 1667/* A variant of lang_output_section_find used by place_orphan. */ 1668 1669static lang_output_section_statement_type * 1670output_rel_find (asection *sec, int isdyn) 1671{ 1672 lang_output_section_statement_type *lookup; 1673 lang_output_section_statement_type *last = NULL; 1674 lang_output_section_statement_type *last_alloc = NULL; 1675 lang_output_section_statement_type *last_ro_alloc = NULL; 1676 lang_output_section_statement_type *last_rel = NULL; 1677 lang_output_section_statement_type *last_rel_alloc = NULL; 1678 int rela = sec->name[4] == 'a'; 1679 1680 for (lookup = &lang_output_section_statement.head->output_section_statement; 1681 lookup != NULL; 1682 lookup = lookup->next) 1683 { 1684 if (lookup->constraint >= 0 1685 && CONST_STRNEQ (lookup->name, ".rel")) 1686 { 1687 int lookrela = lookup->name[4] == 'a'; 1688 1689 /* .rel.dyn must come before all other reloc sections, to suit 1690 GNU ld.so. */ 1691 if (isdyn) 1692 break; 1693 1694 /* Don't place after .rel.plt as doing so results in wrong 1695 dynamic tags. */ 1696 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0) 1697 break; 1698 1699 if (rela == lookrela || last_rel == NULL) 1700 last_rel = lookup; 1701 if ((rela == lookrela || last_rel_alloc == NULL) 1702 && lookup->bfd_section != NULL 1703 && (lookup->bfd_section->flags & SEC_ALLOC) != 0) 1704 last_rel_alloc = lookup; 1705 } 1706 1707 last = lookup; 1708 if (lookup->bfd_section != NULL 1709 && (lookup->bfd_section->flags & SEC_ALLOC) != 0) 1710 { 1711 last_alloc = lookup; 1712 if ((lookup->bfd_section->flags & SEC_READONLY) != 0) 1713 last_ro_alloc = lookup; 1714 } 1715 } 1716 1717 if (last_rel_alloc) 1718 return last_rel_alloc; 1719 1720 if (last_rel) 1721 return last_rel; 1722 1723 if (last_ro_alloc) 1724 return last_ro_alloc; 1725 1726 if (last_alloc) 1727 return last_alloc; 1728 1729 return last; 1730} 1731 1732/* Place an orphan section. We use this to put random SHF_ALLOC 1733 sections in the right segment. */ 1734 1735static lang_output_section_statement_type * 1736gld${EMULATION_NAME}_place_orphan (asection *s, 1737 const char *secname, 1738 int constraint) 1739{ 1740 static struct orphan_save hold[] = 1741 { 1742 { ".text", 1743 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE, 1744 0, 0, 0, 0 }, 1745 { ".rodata", 1746 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA, 1747 0, 0, 0, 0 }, 1748 { ".tdata", 1749 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_THREAD_LOCAL, 1750 0, 0, 0, 0 }, 1751 { ".data", 1752 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA, 1753 0, 0, 0, 0 }, 1754 { ".bss", 1755 SEC_ALLOC, 1756 0, 0, 0, 0 }, 1757 { 0, 1758 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA, 1759 0, 0, 0, 0 }, 1760 { ".interp", 1761 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA, 1762 0, 0, 0, 0 }, 1763 { ".sdata", 1764 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA, 1765 0, 0, 0, 0 }, 1766 { ".comment", 1767 SEC_HAS_CONTENTS, 1768 0, 0, 0, 0 }, 1769 }; 1770 enum orphan_save_index 1771 { 1772 orphan_text = 0, 1773 orphan_rodata, 1774 orphan_tdata, 1775 orphan_data, 1776 orphan_bss, 1777 orphan_rel, 1778 orphan_interp, 1779 orphan_sdata, 1780 orphan_nonalloc 1781 }; 1782 static int orphan_init_done = 0; 1783 struct orphan_save *place; 1784 lang_output_section_statement_type *after; 1785 lang_output_section_statement_type *os; 1786 lang_output_section_statement_type *match_by_name = NULL; 1787 int isdyn = 0; 1788 int iself = s->owner->xvec->flavour == bfd_target_elf_flavour; 1789 unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL; 1790 1791 if (! link_info.relocatable 1792 && link_info.combreloc 1793 && (s->flags & SEC_ALLOC)) 1794 { 1795 if (iself) 1796 switch (sh_type) 1797 { 1798 case SHT_RELA: 1799 secname = ".rela.dyn"; 1800 isdyn = 1; 1801 break; 1802 case SHT_REL: 1803 secname = ".rel.dyn"; 1804 isdyn = 1; 1805 break; 1806 default: 1807 break; 1808 } 1809 else if (CONST_STRNEQ (secname, ".rel")) 1810 { 1811 secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn"; 1812 isdyn = 1; 1813 } 1814 } 1815 1816 /* Look through the script to see where to place this section. */ 1817 if (constraint == 0) 1818 for (os = lang_output_section_find (secname); 1819 os != NULL; 1820 os = next_matching_output_section_statement (os, 0)) 1821 { 1822 /* If we don't match an existing output section, tell 1823 lang_insert_orphan to create a new output section. */ 1824 constraint = SPECIAL; 1825 1826 if (os->bfd_section != NULL 1827 && (os->bfd_section->flags == 0 1828 || (_bfd_elf_match_sections_by_type (link_info.output_bfd, 1829 os->bfd_section, 1830 s->owner, s) 1831 && ((s->flags ^ os->bfd_section->flags) 1832 & (SEC_LOAD | SEC_ALLOC)) == 0))) 1833 { 1834 /* We already have an output section statement with this 1835 name, and its bfd section has compatible flags. 1836 If the section already exists but does not have any flags 1837 set, then it has been created by the linker, probably as a 1838 result of a --section-start command line switch. */ 1839 lang_add_section (&os->children, s, NULL, os); 1840 return os; 1841 } 1842 1843 /* Save unused output sections in case we can match them 1844 against orphans later. */ 1845 if (os->bfd_section == NULL) 1846 match_by_name = os; 1847 } 1848 1849 /* If we didn't match an active output section, see if we matched an 1850 unused one and use that. */ 1851 if (match_by_name) 1852 { 1853 lang_add_section (&match_by_name->children, s, NULL, match_by_name); 1854 return match_by_name; 1855 } 1856 1857 if (!orphan_init_done) 1858 { 1859 struct orphan_save *ho; 1860 1861 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho) 1862 if (ho->name != NULL) 1863 { 1864 ho->os = lang_output_section_find (ho->name); 1865 if (ho->os != NULL && ho->os->flags == 0) 1866 ho->os->flags = ho->flags; 1867 } 1868 orphan_init_done = 1; 1869 } 1870 1871 /* If this is a final link, then always put .gnu.warning.SYMBOL 1872 sections into the .text section to get them out of the way. */ 1873 if (link_info.executable 1874 && ! link_info.relocatable 1875 && CONST_STRNEQ (s->name, ".gnu.warning.") 1876 && hold[orphan_text].os != NULL) 1877 { 1878 os = hold[orphan_text].os; 1879 lang_add_section (&os->children, s, NULL, os); 1880 return os; 1881 } 1882 1883 /* Decide which segment the section should go in based on the 1884 section name and section flags. We put loadable .note sections 1885 right after the .interp section, so that the PT_NOTE segment is 1886 stored right after the program headers where the OS can read it 1887 in the first page. */ 1888 1889 place = NULL; 1890 if ((s->flags & (SEC_ALLOC | SEC_DEBUGGING)) == 0) 1891 place = &hold[orphan_nonalloc]; 1892 else if ((s->flags & SEC_ALLOC) == 0) 1893 ; 1894 else if ((s->flags & SEC_LOAD) != 0 1895 && ((iself && sh_type == SHT_NOTE) 1896 || (!iself && CONST_STRNEQ (secname, ".note")))) 1897 place = &hold[orphan_interp]; 1898 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) == 0) 1899 place = &hold[orphan_bss]; 1900 else if ((s->flags & SEC_SMALL_DATA) != 0) 1901 place = &hold[orphan_sdata]; 1902 else if ((s->flags & SEC_THREAD_LOCAL) != 0) 1903 place = &hold[orphan_tdata]; 1904 else if ((s->flags & SEC_READONLY) == 0) 1905 place = &hold[orphan_data]; 1906 else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL)) 1907 || (!iself && CONST_STRNEQ (secname, ".rel"))) 1908 && (s->flags & SEC_LOAD) != 0) 1909 place = &hold[orphan_rel]; 1910 else if ((s->flags & SEC_CODE) == 0) 1911 place = &hold[orphan_rodata]; 1912 else 1913 place = &hold[orphan_text]; 1914 1915 after = NULL; 1916 if (place != NULL) 1917 { 1918 if (place->os == NULL) 1919 { 1920 if (place->name != NULL) 1921 place->os = lang_output_section_find (place->name); 1922 else 1923 place->os = output_rel_find (s, isdyn); 1924 } 1925 after = place->os; 1926 if (after == NULL) 1927 after = lang_output_section_find_by_flags 1928 (s, &place->os, _bfd_elf_match_sections_by_type); 1929 if (after == NULL) 1930 /* *ABS* is always the first output section statement. */ 1931 after = &lang_output_section_statement.head->output_section_statement; 1932 } 1933 1934 return lang_insert_orphan (s, secname, constraint, after, place, NULL, NULL); 1935} 1936EOF 1937fi 1938 1939if test x"$LDEMUL_AFTER_ALLOCATION" != xgld"$EMULATION_NAME"_after_allocation; then 1940fragment <<EOF 1941 1942static void 1943gld${EMULATION_NAME}_after_allocation (void) 1944{ 1945 int need_layout = bfd_elf_discard_info (link_info.output_bfd, &link_info); 1946 1947 if (need_layout < 0) 1948 einfo ("%X%P: .eh_frame/.stab edit: %E\n"); 1949 else 1950 gld${EMULATION_NAME}_map_segments (need_layout); 1951} 1952EOF 1953fi 1954 1955if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then 1956fragment <<EOF 1957 1958static char * 1959gld${EMULATION_NAME}_get_script (int *isfile) 1960EOF 1961 1962if test x"$COMPILE_IN" = xyes 1963then 1964# Scripts compiled in. 1965 1966# sed commands to quote an ld script as a C string. 1967sc="-f stringify.sed" 1968 1969fragment <<EOF 1970{ 1971 *isfile = 0; 1972 1973 if (link_info.relocatable && config.build_constructors) 1974 return 1975EOF 1976sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c 1977echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c 1978sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c 1979echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c 1980sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c 1981if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else 1982echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c 1983sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c 1984fi 1985if test -n "$GENERATE_PIE_SCRIPT" ; then 1986if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1987echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c 1988echo ' && link_info.relro' >> e${EMULATION_NAME}.c 1989echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c 1990sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c 1991echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c 1992sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c 1993fi 1994echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c 1995sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c 1996fi 1997if test -n "$GENERATE_SHLIB_SCRIPT" ; then 1998if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 1999echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c 2000echo ' && link_info.relro' >> e${EMULATION_NAME}.c 2001echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c 2002sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c 2003echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c 2004sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c 2005fi 2006echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c 2007sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c 2008fi 2009if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 2010echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c 2011echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c 2012sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c 2013echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c 2014sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c 2015fi 2016echo ' ; else return' >> e${EMULATION_NAME}.c 2017sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c 2018echo '; }' >> e${EMULATION_NAME}.c 2019 2020else 2021# Scripts read from the filesystem. 2022 2023fragment <<EOF 2024{ 2025 *isfile = 1; 2026 2027 if (link_info.relocatable && config.build_constructors) 2028 return "ldscripts/${EMULATION_NAME}.xu"; 2029 else if (link_info.relocatable) 2030 return "ldscripts/${EMULATION_NAME}.xr"; 2031 else if (!config.text_read_only) 2032 return "ldscripts/${EMULATION_NAME}.xbn"; 2033EOF 2034if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : 2035else 2036fragment <<EOF 2037 else if (!config.magic_demand_paged) 2038 return "ldscripts/${EMULATION_NAME}.xn"; 2039EOF 2040fi 2041if test -n "$GENERATE_PIE_SCRIPT" ; then 2042if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 2043fragment <<EOF 2044 else if (link_info.pie && link_info.combreloc 2045 && link_info.relro && (link_info.flags & DF_BIND_NOW)) 2046 return "ldscripts/${EMULATION_NAME}.xdw"; 2047 else if (link_info.pie && link_info.combreloc) 2048 return "ldscripts/${EMULATION_NAME}.xdc"; 2049EOF 2050fi 2051fragment <<EOF 2052 else if (link_info.pie) 2053 return "ldscripts/${EMULATION_NAME}.xd"; 2054EOF 2055fi 2056if test -n "$GENERATE_SHLIB_SCRIPT" ; then 2057if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 2058fragment <<EOF 2059 else if (link_info.shared && link_info.combreloc 2060 && link_info.relro && (link_info.flags & DF_BIND_NOW)) 2061 return "ldscripts/${EMULATION_NAME}.xsw"; 2062 else if (link_info.shared && link_info.combreloc) 2063 return "ldscripts/${EMULATION_NAME}.xsc"; 2064EOF 2065fi 2066fragment <<EOF 2067 else if (link_info.shared) 2068 return "ldscripts/${EMULATION_NAME}.xs"; 2069EOF 2070fi 2071if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then 2072fragment <<EOF 2073 else if (link_info.combreloc && link_info.relro 2074 && (link_info.flags & DF_BIND_NOW)) 2075 return "ldscripts/${EMULATION_NAME}.xw"; 2076 else if (link_info.combreloc) 2077 return "ldscripts/${EMULATION_NAME}.xc"; 2078EOF 2079fi 2080fragment <<EOF 2081 else 2082 return "ldscripts/${EMULATION_NAME}.x"; 2083} 2084 2085EOF 2086fi 2087fi 2088 2089if test -n "$PARSE_AND_LIST_PROLOGUE" ; then 2090fragment <<EOF 2091 $PARSE_AND_LIST_PROLOGUE 2092EOF 2093fi 2094 2095fragment <<EOF 2096 2097#define OPTION_DISABLE_NEW_DTAGS (400) 2098#define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1) 2099#define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1) 2100#define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1) 2101#define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1) 2102#define OPTION_HASH_STYLE (OPTION_EXCLUDE_LIBS + 1) 2103#define OPTION_BUILD_ID (OPTION_HASH_STYLE + 1) 2104#define OPTION_AUDIT (OPTION_BUILD_ID + 1) 2105 2106static void 2107gld${EMULATION_NAME}_add_options 2108 (int ns, char **shortopts, int nl, struct option **longopts, 2109 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED) 2110{ 2111EOF 2112if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2113fragment <<EOF 2114 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:P:"; 2115EOF 2116else 2117fragment <<EOF 2118 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:"; 2119EOF 2120fi 2121fragment <<EOF 2122 static const struct option xtra_long[] = { 2123EOF 2124if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2125fragment <<EOF 2126 {"audit", required_argument, NULL, OPTION_AUDIT}, 2127 {"Bgroup", no_argument, NULL, OPTION_GROUP}, 2128EOF 2129fi 2130fragment <<EOF 2131 {"build-id", optional_argument, NULL, OPTION_BUILD_ID}, 2132EOF 2133if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2134fragment <<EOF 2135 {"depaudit", required_argument, NULL, 'P'}, 2136 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS}, 2137 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS}, 2138 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR}, 2139 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS}, 2140 {"hash-style", required_argument, NULL, OPTION_HASH_STYLE}, 2141EOF 2142fi 2143if test -n "$PARSE_AND_LIST_LONGOPTS" ; then 2144fragment <<EOF 2145 $PARSE_AND_LIST_LONGOPTS 2146EOF 2147fi 2148fragment <<EOF 2149 {NULL, no_argument, NULL, 0} 2150 }; 2151 2152 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short)); 2153 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short)); 2154 *longopts = (struct option *) 2155 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long)); 2156 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long)); 2157} 2158 2159#define DEFAULT_BUILD_ID_STYLE "sha1" 2160 2161static bfd_boolean 2162gld${EMULATION_NAME}_handle_option (int optc) 2163{ 2164 switch (optc) 2165 { 2166 default: 2167 return FALSE; 2168 2169 case OPTION_BUILD_ID: 2170 if (emit_note_gnu_build_id != NULL) 2171 { 2172 free ((char *) emit_note_gnu_build_id); 2173 emit_note_gnu_build_id = NULL; 2174 } 2175 if (optarg == NULL) 2176 optarg = DEFAULT_BUILD_ID_STYLE; 2177 if (strcmp (optarg, "none")) 2178 emit_note_gnu_build_id = xstrdup (optarg); 2179 break; 2180 2181EOF 2182 2183if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2184fragment <<EOF 2185 case OPTION_AUDIT: 2186 gld${EMULATION_NAME}_append_to_separated_string (&audit, optarg); 2187 break; 2188 2189 case 'P': 2190 gld${EMULATION_NAME}_append_to_separated_string (&depaudit, optarg); 2191 break; 2192 2193 case OPTION_DISABLE_NEW_DTAGS: 2194 link_info.new_dtags = FALSE; 2195 break; 2196 2197 case OPTION_ENABLE_NEW_DTAGS: 2198 link_info.new_dtags = TRUE; 2199 break; 2200 2201 case OPTION_EH_FRAME_HDR: 2202 link_info.eh_frame_hdr = TRUE; 2203 break; 2204 2205 case OPTION_GROUP: 2206 link_info.flags_1 |= (bfd_vma) DF_1_GROUP; 2207 /* Groups must be self-contained. */ 2208 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR; 2209 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR; 2210 break; 2211 2212 case OPTION_EXCLUDE_LIBS: 2213 add_excluded_libs (optarg); 2214 break; 2215 2216 case OPTION_HASH_STYLE: 2217 link_info.emit_hash = FALSE; 2218 link_info.emit_gnu_hash = FALSE; 2219 if (strcmp (optarg, "sysv") == 0) 2220 link_info.emit_hash = TRUE; 2221 else if (strcmp (optarg, "gnu") == 0) 2222 link_info.emit_gnu_hash = TRUE; 2223 else if (strcmp (optarg, "both") == 0) 2224 { 2225 link_info.emit_hash = TRUE; 2226 link_info.emit_gnu_hash = TRUE; 2227 } 2228 else 2229 einfo (_("%P%F: invalid hash style \`%s'\n"), optarg); 2230 break; 2231 2232EOF 2233fi 2234fragment <<EOF 2235 case 'z': 2236 if (strcmp (optarg, "defs") == 0) 2237 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR; 2238 else if (strcmp (optarg, "muldefs") == 0) 2239 link_info.allow_multiple_definition = TRUE; 2240 else if (CONST_STRNEQ (optarg, "max-page-size=")) 2241 { 2242 char *end; 2243 2244 config.maxpagesize = strtoul (optarg + 14, &end, 0); 2245 if (*end || (config.maxpagesize & (config.maxpagesize - 1)) != 0) 2246 einfo (_("%P%F: invalid maxium page size \`%s'\n"), 2247 optarg + 14); 2248 } 2249 else if (CONST_STRNEQ (optarg, "common-page-size=")) 2250 { 2251 char *end; 2252 config.commonpagesize = strtoul (optarg + 17, &end, 0); 2253 if (*end 2254 || (config.commonpagesize & (config.commonpagesize - 1)) != 0) 2255 einfo (_("%P%F: invalid common page size \`%s'\n"), 2256 optarg + 17); 2257 } 2258 else if (CONST_STRNEQ (optarg, "stack-size=")) 2259 { 2260 char *end; 2261 link_info.stacksize = strtoul (optarg + 11, &end, 0); 2262 if (*end || link_info.stacksize < 0) 2263 einfo (_("%P%F: invalid stack size \`%s'\n"), optarg + 11); 2264 if (!link_info.stacksize) 2265 /* Use -1 for explicit no-stack, because zero means 2266 'default'. */ 2267 link_info.stacksize = -1; 2268 } 2269 else if (strcmp (optarg, "execstack") == 0) 2270 { 2271 link_info.execstack = TRUE; 2272 link_info.noexecstack = FALSE; 2273 } 2274 else if (strcmp (optarg, "noexecstack") == 0) 2275 { 2276 link_info.noexecstack = TRUE; 2277 link_info.execstack = FALSE; 2278 } 2279EOF 2280if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2281fragment <<EOF 2282 else if (strcmp (optarg, "global") == 0) 2283 link_info.flags_1 |= (bfd_vma) DF_1_GLOBAL; 2284 else if (strcmp (optarg, "initfirst") == 0) 2285 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST; 2286 else if (strcmp (optarg, "interpose") == 0) 2287 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE; 2288 else if (strcmp (optarg, "loadfltr") == 0) 2289 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR; 2290 else if (strcmp (optarg, "nodefaultlib") == 0) 2291 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB; 2292 else if (strcmp (optarg, "nodelete") == 0) 2293 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE; 2294 else if (strcmp (optarg, "nodlopen") == 0) 2295 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN; 2296 else if (strcmp (optarg, "nodump") == 0) 2297 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP; 2298 else if (strcmp (optarg, "now") == 0) 2299 { 2300 link_info.flags |= (bfd_vma) DF_BIND_NOW; 2301 link_info.flags_1 |= (bfd_vma) DF_1_NOW; 2302 } 2303 else if (strcmp (optarg, "lazy") == 0) 2304 { 2305 link_info.flags &= ~(bfd_vma) DF_BIND_NOW; 2306 link_info.flags_1 &= ~(bfd_vma) DF_1_NOW; 2307 } 2308 else if (strcmp (optarg, "origin") == 0) 2309 { 2310 link_info.flags |= (bfd_vma) DF_ORIGIN; 2311 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN; 2312 } 2313 else if (strcmp (optarg, "combreloc") == 0) 2314 link_info.combreloc = TRUE; 2315 else if (strcmp (optarg, "nocombreloc") == 0) 2316 link_info.combreloc = FALSE; 2317 else if (strcmp (optarg, "nocopyreloc") == 0) 2318 link_info.nocopyreloc = TRUE; 2319 else if (strcmp (optarg, "relro") == 0) 2320 link_info.relro = TRUE; 2321 else if (strcmp (optarg, "norelro") == 0) 2322 link_info.relro = FALSE; 2323 else if (strcmp (optarg, "text") == 0) 2324 link_info.error_textrel = TRUE; 2325 else if (strcmp (optarg, "notext") == 0) 2326 link_info.error_textrel = FALSE; 2327 else if (strcmp (optarg, "textoff") == 0) 2328 link_info.error_textrel = FALSE; 2329EOF 2330fi 2331 2332fragment <<EOF 2333 else 2334 einfo (_("%P: warning: -z %s ignored.\n"), optarg); 2335 break; 2336EOF 2337 2338if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then 2339fragment <<EOF 2340 $PARSE_AND_LIST_ARGS_CASES 2341EOF 2342fi 2343 2344fragment <<EOF 2345 } 2346 2347 return TRUE; 2348} 2349 2350EOF 2351 2352if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then 2353fragment <<EOF 2354 2355static void 2356gld${EMULATION_NAME}_list_options (FILE * file) 2357{ 2358EOF 2359if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2360fragment <<EOF 2361 fprintf (file, _("\ 2362 --audit=AUDITLIB Specify a library to use for auditing\n")); 2363 fprintf (file, _("\ 2364 -Bgroup Selects group name lookup rules for DSO\n")); 2365EOF 2366fi 2367fragment <<EOF 2368 fprintf (file, _("\ 2369 --build-id[=STYLE] Generate build ID note\n")); 2370EOF 2371if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2372fragment <<EOF 2373 fprintf (file, _("\ 2374 -P AUDITLIB, --depaudit=AUDITLIB\n" "\ 2375 Specify a library to use for auditing dependencies\n")); 2376 fprintf (file, _("\ 2377 --disable-new-dtags Disable new dynamic tags\n")); 2378 fprintf (file, _("\ 2379 --enable-new-dtags Enable new dynamic tags\n")); 2380 fprintf (file, _("\ 2381 --eh-frame-hdr Create .eh_frame_hdr section\n")); 2382 fprintf (file, _("\ 2383 --exclude-libs=LIBS Make all symbols in LIBS hidden\n")); 2384 fprintf (file, _("\ 2385 --hash-style=STYLE Set hash style to sysv, gnu or both\n")); 2386 fprintf (file, _("\ 2387 -z combreloc Merge dynamic relocs into one section and sort\n")); 2388EOF 2389fi 2390 2391fragment <<EOF 2392 fprintf (file, _("\ 2393 -z common-page-size=SIZE Set common page size to SIZE\n")); 2394 fprintf (file, _("\ 2395 -z defs Report unresolved symbols in object files.\n")); 2396 fprintf (file, _("\ 2397 -z execstack Mark executable as requiring executable stack\n")); 2398EOF 2399 2400if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2401fragment <<EOF 2402 fprintf (file, _("\ 2403 -z global Make symbols in DSO available for subsequently\n\ 2404 loaded objects\n")); 2405 fprintf (file, _("\ 2406 -z initfirst Mark DSO to be initialized first at runtime\n")); 2407 fprintf (file, _("\ 2408 -z interpose Mark object to interpose all DSOs but executable\n")); 2409 fprintf (file, _("\ 2410 -z lazy Mark object lazy runtime binding (default)\n")); 2411 fprintf (file, _("\ 2412 -z loadfltr Mark object requiring immediate process\n")); 2413EOF 2414fi 2415 2416fragment <<EOF 2417 fprintf (file, _("\ 2418 -z max-page-size=SIZE Set maximum page size to SIZE\n")); 2419 fprintf (file, _("\ 2420 -z muldefs Allow multiple definitions\n")); 2421EOF 2422 2423if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2424fragment <<EOF 2425 fprintf (file, _("\ 2426 -z nocombreloc Don't merge dynamic relocs into one section\n")); 2427 fprintf (file, _("\ 2428 -z nocopyreloc Don't create copy relocs\n")); 2429 fprintf (file, _("\ 2430 -z nodefaultlib Mark object not to use default search paths\n")); 2431 fprintf (file, _("\ 2432 -z nodelete Mark DSO non-deletable at runtime\n")); 2433 fprintf (file, _("\ 2434 -z nodlopen Mark DSO not available to dlopen\n")); 2435 fprintf (file, _("\ 2436 -z nodump Mark DSO not available to dldump\n")); 2437EOF 2438fi 2439fragment <<EOF 2440 fprintf (file, _("\ 2441 -z noexecstack Mark executable as not requiring executable stack\n")); 2442EOF 2443if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then 2444fragment <<EOF 2445 fprintf (file, _("\ 2446 -z norelro Don't create RELRO program header\n")); 2447 fprintf (file, _("\ 2448 -z now Mark object non-lazy runtime binding\n")); 2449 fprintf (file, _("\ 2450 -z origin Mark object requiring immediate \$ORIGIN\n\ 2451 processing at runtime\n")); 2452 fprintf (file, _("\ 2453 -z relro Create RELRO program header\n")); 2454 fprintf (file, _("\ 2455 -z stacksize=SIZE Set size of stack segment\n")); 2456EOF 2457fi 2458 2459if test -n "$PARSE_AND_LIST_OPTIONS" ; then 2460fragment <<EOF 2461 $PARSE_AND_LIST_OPTIONS 2462EOF 2463fi 2464 2465fragment <<EOF 2466} 2467EOF 2468 2469if test -n "$PARSE_AND_LIST_EPILOGUE" ; then 2470fragment <<EOF 2471 $PARSE_AND_LIST_EPILOGUE 2472EOF 2473fi 2474fi 2475 2476fragment <<EOF 2477 2478struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = 2479{ 2480 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse}, 2481 ${LDEMUL_SYSLIB-syslib_default}, 2482 ${LDEMUL_HLL-hll_default}, 2483 ${LDEMUL_AFTER_PARSE-after_parse_default}, 2484 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open}, 2485 ${LDEMUL_AFTER_ALLOCATION-gld${EMULATION_NAME}_after_allocation}, 2486 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default}, 2487 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target}, 2488 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation}, 2489 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script}, 2490 "${EMULATION_NAME}", 2491 "${OUTPUT_FORMAT}", 2492 ${LDEMUL_FINISH-finish_default}, 2493 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL}, 2494 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive}, 2495 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan}, 2496 ${LDEMUL_SET_SYMBOLS-NULL}, 2497 ${LDEMUL_PARSE_ARGS-NULL}, 2498 gld${EMULATION_NAME}_add_options, 2499 gld${EMULATION_NAME}_handle_option, 2500 ${LDEMUL_UNRECOGNIZED_FILE-NULL}, 2501 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options}, 2502 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols}, 2503 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL}, 2504 ${LDEMUL_NEW_VERS_PATTERN-NULL}, 2505 ${LDEMUL_EXTRA_MAP_FILE_TEXT-NULL} 2506}; 2507EOF 2508