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
5 test -z "${ELFSIZE}" && ELFSIZE=32
6 if [ -z "$MACHINE" ]; then
9 OUTPUT_ARCH=${ARCH}:${MACHINE}
12 /* This file is is generated by a shell script. DO NOT EDIT! */
14 /* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
15 Copyright (C) 1991-2018 Free Software Foundation, Inc.
16 Written by Steve Chamberlain <sac@cygnus.com>
17 ELF support by Ian Lance Taylor <ian@cygnus.com>
19 This file is part of the GNU Binutils.
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.
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.
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. */
36 #define TARGET_IS_${EMULATION_NAME}
40 #include "libiberty.h"
41 #include "safe-ctype.h"
42 #include "filenames.h"
55 #include "ldbuildid.h"
57 #include "elf/common.h"
59 #include "filenames.h"
61 /* Declare functions used by various EXTRA_EM_FILEs. */
62 static void gld${EMULATION_NAME}_before_parse (void);
63 static void gld${EMULATION_NAME}_after_parse (void);
64 static void gld${EMULATION_NAME}_after_open (void);
65 static void gld${EMULATION_NAME}_before_allocation (void);
66 static void gld${EMULATION_NAME}_after_allocation (void);
67 static lang_output_section_statement_type *gld${EMULATION_NAME}_place_orphan
68 (asection *, const char *, int);
71 if [ "x${USE_LIBPATH}" = xyes ] ; then
73 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
83 # Import any needed special functions and/or overrides.
85 source_em ${srcdir}/emultempl/elf-generic.em
86 if test -n "$EXTRA_EM_FILE" ; then
87 source_em ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
90 # Functions in this file can be overridden by setting the LDEMUL_* shell
91 # variables. If the name of the overriding function is the same as is
92 # defined in this file, then don't output this file's version.
93 # If a different overriding name is given then output the standard function
94 # as presumably it is called from the overriding function.
96 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
100 gld${EMULATION_NAME}_before_parse (void)
102 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
103 input_flags.dynamic = ${DYNAMIC_LINK-TRUE};
104 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
105 config.separate_code = `if test "x${SEPARATE_CODE}" = xyes ; then echo TRUE ; else echo FALSE ; fi`;
106 `if test -n "$CALL_NOP_BYTE" ; then echo link_info.call_nop_byte = $CALL_NOP_BYTE; fi`;
107 link_info.check_relocs_after_open_input = TRUE;
108 link_info.relro = DEFAULT_LD_Z_RELRO;
109 link_info.separate_code = DEFAULT_LD_Z_SEPARATE_CODE;
115 if test x"$LDEMUL_AFTER_PARSE" != xgld"$EMULATION_NAME"_after_parse; then
119 gld${EMULATION_NAME}_after_parse (void)
121 if (bfd_link_pie (&link_info))
122 link_info.flags_1 |= (bfd_vma) DF_1_PIE;
124 if (bfd_link_executable (&link_info)
125 && link_info.nointerp)
127 if (link_info.dynamic_undefined_weak > 0)
128 einfo (_("%P: warning: -z dynamic-undefined-weak ignored\n"));
129 link_info.dynamic_undefined_weak = 0;
131 after_parse_default ();
137 if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
139 /* Handle the generation of DT_NEEDED tags. */
142 gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
146 /* Tell the ELF linker that we don't want the output file to have a
147 DT_NEEDED entry for this file, unless it is used to resolve
148 references in a regular object. */
149 if (entry->flags.add_DT_NEEDED_for_regular)
150 link_class = DYN_AS_NEEDED;
152 /* Tell the ELF linker that we don't want the output file to have a
153 DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
155 if (!entry->flags.add_DT_NEEDED_for_dynamic)
156 link_class |= DYN_NO_ADD_NEEDED;
158 if (entry->flags.just_syms
159 && (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) != 0)
160 einfo (_("%F%P: %pB: --just-symbols may not be used on DSO\n"),
164 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
167 bfd_elf_set_dyn_lib_class (entry->the_bfd,
168 (enum dynamic_lib_link_class) link_class);
170 /* Continue on with normal load_symbols processing. */
178 /* These variables are required to pass information back and forth
179 between after_open and check_needed and stat_needed and vercheck. */
181 static struct bfd_link_needed_list *global_needed;
182 static struct stat global_stat;
183 static lang_input_statement_type *global_found;
184 static struct bfd_link_needed_list *global_vercheck_needed;
185 static bfd_boolean global_vercheck_failed;
187 /* These variables are used to implement target options */
189 static char *audit; /* colon (typically) separated list of libs */
190 static char *depaudit; /* colon (typically) separated list of libs */
192 /* Style of .note.gnu.build-id section. */
193 static const char *emit_note_gnu_build_id;
195 /* On Linux, it's possible to have different versions of the same
196 shared library linked against different versions of libc. The
197 dynamic linker somehow tags which libc version to use in
198 /etc/ld.so.cache, and, based on the libc that it sees in the
199 executable, chooses which version of the shared library to use.
201 We try to do a similar check here by checking whether this shared
202 library needs any other shared libraries which may conflict with
203 libraries we have already included in the link. If it does, we
204 skip it, and try to find another shared library farther on down the
207 This is called via lang_for_each_input_file.
208 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
209 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
210 a conflicting version. */
213 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
216 struct bfd_link_needed_list *l;
218 if (global_vercheck_failed)
220 if (s->the_bfd == NULL
221 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
224 soname = bfd_elf_get_dt_soname (s->the_bfd);
226 soname = lbasename (bfd_get_filename (s->the_bfd));
228 for (l = global_vercheck_needed; l != NULL; l = l->next)
232 if (filename_cmp (soname, l->name) == 0)
234 /* Probably can't happen, but it's an easy check. */
238 if (strchr (l->name, '/') != NULL)
241 suffix = strstr (l->name, ".so.");
245 suffix += sizeof ".so." - 1;
247 if (filename_ncmp (soname, l->name, suffix - l->name) == 0)
249 /* Here we know that S is a dynamic object FOO.SO.VER1, and
250 the object we are considering needs a dynamic object
251 FOO.SO.VER2, and VER1 and VER2 are different. This
252 appears to be a version mismatch, so we tell the caller
253 to try a different version of this library. */
254 global_vercheck_failed = TRUE;
261 /* See if an input file matches a DT_NEEDED entry by running stat on
265 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
271 if (global_found != NULL)
273 if (s->the_bfd == NULL)
276 /* If this input file was an as-needed entry, and wasn't found to be
277 needed at the stage it was linked, then don't say we have loaded it. */
278 if ((bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
281 if (bfd_stat (s->the_bfd, &st) != 0)
283 einfo (_("%P: %pB: bfd_stat failed: %E\n"), s->the_bfd);
287 /* Some operating systems, e.g. Windows, do not provide a meaningful
288 st_ino; they always set it to zero. (Windows does provide a
289 meaningful st_dev.) Do not indicate a duplicate library in that
290 case. While there is no guarantee that a system that provides
291 meaningful inode numbers will never set st_ino to zero, this is
292 merely an optimization, so we do not need to worry about false
294 if (st.st_dev == global_stat.st_dev
295 && st.st_ino == global_stat.st_ino
302 /* We issue a warning if it looks like we are including two
303 different versions of the same shared library. For example,
304 there may be a problem if -lc picks up libc.so.6 but some other
305 shared library has a DT_NEEDED entry of libc.so.5. This is a
306 heuristic test, and it will only work if the name looks like
307 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
308 If we really want to issue warnings about mixing version numbers
309 of shared libraries, we need to find a better way. */
311 if (strchr (global_needed->name, '/') != NULL)
313 suffix = strstr (global_needed->name, ".so.");
316 suffix += sizeof ".so." - 1;
318 soname = bfd_elf_get_dt_soname (s->the_bfd);
320 soname = lbasename (s->filename);
322 if (filename_ncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
323 einfo (_("%P: warning: %s, needed by %pB, may conflict with %s\n"),
324 global_needed->name, global_needed->by, soname);
333 /* This function is called for each possible name for a dynamic object
334 named by a DT_NEEDED entry. The FORCE parameter indicates whether
335 to skip the check for a conflicting version. */
338 gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
342 const char *name = needed->name;
346 abfd = bfd_openr (name, bfd_get_target (link_info.output_bfd));
350 info_msg (_("attempt to open %s failed\n"), name);
354 /* Linker needs to decompress sections. */
355 abfd->flags |= BFD_DECOMPRESS;
357 if (! bfd_check_format (abfd, bfd_object))
362 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
368 /* For DT_NEEDED, they have to match. */
369 if (abfd->xvec != link_info.output_bfd->xvec)
375 /* Check whether this object would include any conflicting library
376 versions. If FORCE is set, then we skip this check; we use this
377 the second time around, if we couldn't find any compatible
378 instance of the shared library. */
382 struct bfd_link_needed_list *needs;
384 if (! bfd_elf_get_bfd_needed_list (abfd, &needs))
385 einfo (_("%F%P: %pB: bfd_elf_get_bfd_needed_list failed: %E\n"), abfd);
389 global_vercheck_needed = needs;
390 global_vercheck_failed = FALSE;
391 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
392 if (global_vercheck_failed)
395 /* Return FALSE to force the caller to move on to try
396 another file on the search path. */
400 /* But wait! It gets much worse. On Linux, if a shared
401 library does not use libc at all, we are supposed to skip
402 it the first time around in case we encounter a shared
403 library later on with the same name which does use the
404 version of libc that we want. This is much too horrible
405 to use on any system other than Linux. */
409 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
412 struct bfd_link_needed_list *l;
414 for (l = needs; l != NULL; l = l->next)
415 if (CONST_STRNEQ (l->name, "libc.so"))
431 /* We've found a dynamic object matching the DT_NEEDED entry. */
433 /* We have already checked that there is no other input file of the
434 same name. We must now check again that we are not including the
435 same file twice. We need to do this because on many systems
436 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
437 reference libc.so.1. If we have already included libc.so, we
438 don't want to include libc.so.1 if they are the same file, and we
439 can only check that using stat. */
441 if (bfd_stat (abfd, &global_stat) != 0)
442 einfo (_("%F%P: %pB: bfd_stat failed: %E\n"), abfd);
444 /* First strip off everything before the last '/'. */
445 soname = lbasename (abfd->filename);
448 info_msg (_("found %s at %s\n"), soname, name);
451 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
452 if (global_found != NULL)
454 /* Return TRUE to indicate that we found the file, even though
455 we aren't going to do anything with it. */
459 /* Specify the soname to use. */
460 bfd_elf_set_dt_needed_name (abfd, soname);
462 /* Tell the ELF linker that we don't want the output file to have a
463 DT_NEEDED entry for this file, unless it is used to resolve
464 references in a regular object. */
465 link_class = DYN_DT_NEEDED;
467 /* Tell the ELF linker that we don't want the output file to have a
468 DT_NEEDED entry for this file at all if the entry is from a file
469 with DYN_NO_ADD_NEEDED. */
470 if (needed->by != NULL
471 && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
472 link_class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
474 bfd_elf_set_dyn_lib_class (abfd, (enum dynamic_lib_link_class) link_class);
476 /* Add this file into the symbol table. */
477 if (! bfd_link_add_symbols (abfd, &link_info))
478 einfo (_("%F%P: %pB: error adding symbols: %E\n"), abfd);
483 /* Search for a needed file in a path. */
486 gld${EMULATION_NAME}_search_needed (const char *path,
487 struct dt_needed *n, int force)
490 const char *name = n->name;
492 struct dt_needed needed;
495 return gld${EMULATION_NAME}_try_needed (n, force);
497 if (path == NULL || *path == '\0')
501 needed.name = n->name;
508 char *filename, *sset;
510 s = strchr (path, config.rpath_separator);
512 s = path + strlen (path);
514 #if HAVE_DOS_BASED_FILE_SYSTEM
515 /* Assume a match on the second char is part of drive specifier. */
516 else if (config.rpath_separator == ':'
520 s = strchr (s + 1, config.rpath_separator);
522 s = path + strlen (path);
525 filename = (char *) xmalloc (s - path + len + 2);
530 memcpy (filename, path, s - path);
531 filename[s - path] = '/';
532 sset = filename + (s - path) + 1;
536 /* PR 20535: Support the same pseudo-environment variables that
537 are supported by ld.so. Namely, $ORIGIN, $LIB and $PLATFORM.
538 Since there can be more than one occurrence of these tokens in
539 the path we loop until no more are found. Since we might not
540 be able to substitute some of the tokens we maintain an offset
541 into the filename for where we should begin our scan. */
542 while ((var = strchr (filename + offset, '$')) != NULL)
544 /* The ld.so manual page does not say, but I am going to assume that
545 these tokens are terminated by a directory separator character
546 (/) or the end of the string. There is also an implication that
547 $ORIGIN should only be used at the start of a path, but that is
550 The ld.so manual page also states that it allows ${ORIGIN},
551 ${LIB} and ${PLATFORM}, so these are supported as well.
553 FIXME: The code could be a lot cleverer about allocating space
554 for the processed string. */
555 char * end = strchr (var, '/');
556 char * replacement = NULL;
558 char * freeme = NULL;
559 unsigned flen = strlen (filename);
562 /* Temporarily terminate the filename at the end of the token. */
570 if (strcmp (v, "RIGIN") == 0 || strcmp (v, "RIGIN}") == 0)
572 /* ORIGIN - replace with the full path to the directory
573 containing the program or shared object. */
574 if (needed.by == NULL)
576 if (link_info.output_bfd == NULL)
581 replacement = bfd_get_filename (link_info.output_bfd);
584 replacement = bfd_get_filename (needed.by);
590 if (replacement[0] == '/')
591 freeme = xstrdup (replacement);
594 char * current_dir = getpwd ();
596 freeme = xmalloc (strlen (replacement) + strlen (current_dir) + 2);
597 sprintf (freeme, "%s/%s", current_dir, replacement);
600 replacement = freeme;
601 if ((slash = strrchr (replacement, '/')) != NULL)
608 if (strcmp (v, "IB") == 0 || strcmp (v, "IB}") == 0)
610 /* LIB - replace with "lib" in 32-bit environments
611 and "lib64" in 64-bit environments. */
613 /* Note - we could replace this switch statement by
614 conditional fragments of shell script, but that is messy.
615 Any compiler worth its salt is going to optimize away
616 all but one of these case statements anyway. */
619 case 32: replacement = "lib"; break;
620 case 64: replacement = "lib64"; break;
622 /* $ELFSIZE is not 32 or 64 ... */
629 /* Supporting $PLATFORM in a cross-hosted environment is not
630 possible. Supporting it in a native environment involves
631 loading the <sys/auxv.h> header file which loads the
632 system <elf.h> header file, which conflicts with the
633 "include/elf/mips.h" header file. */
641 char * filename2 = xmalloc (flen + strlen (replacement));
645 sprintf (filename2, "%.*s%s/%s",
646 (int)(var - filename), filename,
647 replacement, end + 1);
648 offset = (var - filename) + 1 + strlen (replacement);
652 sprintf (filename2, "%.*s%s",
653 (int)(var - filename), filename,
655 offset = var - filename + strlen (replacement);
659 filename = filename2;
660 /* There is no need to restore the path separator (when
661 end != NULL) as we have replaced the entire string. */
666 /* We only issue an "unrecognised" message in verbose mode
667 as the $<foo> token might be a legitimate component of
668 a path name in the target's file system. */
669 info_msg (_("unrecognised or unsupported token '%s' in search path\n"), var);
672 /* Restore the path separator. */
675 /* PR 20784: Make sure that we resume the scan *after*
676 the token that we could not replace. */
677 offset = (var + 1) - filename;
683 needed.name = filename;
685 if (gld${EMULATION_NAME}_try_needed (&needed, force))
699 if [ "x${USE_LIBPATH}" = xyes ] ; then
702 /* Prefix the sysroot to absolute paths in PATH, a string containing
703 paths separated by config.rpath_separator. If running on a DOS
704 file system, paths containing a drive spec won't have the sysroot
705 prefix added, unless the sysroot also specifies the same drive. */
708 gld${EMULATION_NAME}_add_sysroot (const char *path)
713 int dos_drive_sysroot = HAS_DRIVE_SPEC (ld_sysroot);
715 len = strlen (ld_sysroot);
716 for (extra = 0, p = path; ; )
718 int dos_drive = HAS_DRIVE_SPEC (p);
722 if (IS_DIR_SEPARATOR (*p)
724 || (dos_drive_sysroot
725 && ld_sysroot[0] == p[-2])))
727 if (dos_drive && dos_drive_sysroot)
732 p = strchr (p, config.rpath_separator);
738 ret = xmalloc (strlen (path) + extra + 1);
740 for (q = ret, p = path; ; )
743 int dos_drive = HAS_DRIVE_SPEC (p);
750 if (IS_DIR_SEPARATOR (*p)
752 || (dos_drive_sysroot
753 && ld_sysroot[0] == p[-2])))
755 if (dos_drive && dos_drive_sysroot)
757 strcpy (q, ld_sysroot + 2);
762 strcpy (q, ld_sysroot);
766 end = strchr (p, config.rpath_separator);
769 size_t n = end - p + 1;
786 *-*-freebsd* | *-*-dragonfly*)
788 /* Read the system search path the FreeBSD way rather than the Linux way. */
789 #ifdef HAVE_ELF_HINTS_H
790 #include <elf-hints.h>
792 #include "elf-hints-local.h"
796 gld${EMULATION_NAME}_check_ld_elf_hints (const struct bfd_link_needed_list *l,
799 static bfd_boolean initialized;
800 static const char *ld_elf_hints;
801 struct dt_needed needed;
808 tmppath = concat (ld_sysroot, _PATH_ELF_HINTS, (const char *) NULL);
809 f = fopen (tmppath, FOPEN_RB);
813 struct elfhints_hdr hdr;
815 if (fread (&hdr, 1, sizeof (hdr), f) == sizeof (hdr)
816 && hdr.magic == ELFHINTS_MAGIC
819 if (fseek (f, hdr.strtab + hdr.dirlist, SEEK_SET) != -1)
823 b = xmalloc (hdr.dirlistlen + 1);
824 if (fread (b, 1, hdr.dirlistlen + 1, f) ==
826 ld_elf_hints = gld${EMULATION_NAME}_add_sysroot (b);
837 if (ld_elf_hints == NULL)
841 needed.name = l->name;
842 return gld${EMULATION_NAME}_search_needed (ld_elf_hints, &needed, force);
848 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
850 /* For a native linker, check the file /etc/ld.so.conf for directories
851 in which we may find shared libraries. /etc/ld.so.conf is really
852 only meaningful on Linux. */
854 struct gld${EMULATION_NAME}_ld_so_conf
861 gld${EMULATION_NAME}_parse_ld_so_conf
862 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
865 gld${EMULATION_NAME}_parse_ld_so_conf_include
866 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
874 if (pattern[0] != '/')
876 char *p = strrchr (filename, '/');
877 size_t patlen = strlen (pattern) + 1;
879 newp = xmalloc (p - filename + 1 + patlen);
880 memcpy (newp, filename, p - filename + 1);
881 memcpy (newp + (p - filename + 1), pattern, patlen);
886 if (glob (pattern, 0, NULL, &gl) == 0)
890 for (i = 0; i < gl.gl_pathc; ++i)
891 gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
895 /* If we do not have glob, treat the pattern as a literal filename. */
896 gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
904 gld${EMULATION_NAME}_parse_ld_so_conf
905 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
907 FILE *f = fopen (filename, FOPEN_RT);
915 line = xmalloc (linelen);
920 /* Normally this would use getline(3), but we need to be portable. */
921 while ((q = fgets (p, linelen - (p - line), f)) != NULL
922 && strlen (q) == linelen - (p - line) - 1
923 && line[linelen - 2] != '\n')
925 line = xrealloc (line, 2 * linelen);
926 p = line + linelen - 1;
930 if (q == NULL && p == line)
933 p = strchr (line, '\n');
937 /* Because the file format does not know any form of quoting we
938 can search forward for the next '#' character and if found
939 make it terminating the line. */
940 p = strchr (line, '#');
944 /* Remove leading whitespace. NUL is no whitespace character. */
946 while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
949 /* If the line is blank it is ignored. */
953 if (CONST_STRNEQ (p, "include") && (p[7] == ' ' || p[7] == '\t'))
959 while (*p == ' ' || *p == '\t')
967 while (*p != ' ' && *p != '\t' && *p)
973 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
981 while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
982 && *p != '\r' && *p != '\v')
985 while (p != dir && p[-1] == '/')
987 if (info->path == NULL)
989 info->alloc = p - dir + 1 + 256;
990 info->path = xmalloc (info->alloc);
995 if (info->len + 1 + (p - dir) >= info->alloc)
997 info->alloc += p - dir + 256;
998 info->path = xrealloc (info->path, info->alloc);
1000 info->path[info->len++] = config.rpath_separator;
1002 memcpy (info->path + info->len, dir, p - dir);
1003 info->len += p - dir;
1004 info->path[info->len] = '\0';
1014 gld${EMULATION_NAME}_check_ld_so_conf (const struct bfd_link_needed_list *l,
1017 static bfd_boolean initialized;
1018 static const char *ld_so_conf;
1019 struct dt_needed needed;
1024 struct gld${EMULATION_NAME}_ld_so_conf info;
1027 info.len = info.alloc = 0;
1028 tmppath = concat (ld_sysroot, "${prefix}/etc/ld.so.conf",
1029 (const char *) NULL);
1030 if (!gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath))
1033 tmppath = concat (ld_sysroot, "/etc/ld.so.conf",
1034 (const char *) NULL);
1035 gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
1041 ld_so_conf = gld${EMULATION_NAME}_add_sysroot (info.path);
1047 if (ld_so_conf == NULL)
1052 needed.name = l->name;
1053 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
1063 /* See if an input file matches a DT_NEEDED entry by name. */
1066 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
1070 /* Stop looking if we've found a loaded lib. */
1071 if (global_found != NULL
1072 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
1073 & DYN_AS_NEEDED) == 0)
1076 if (s->filename == NULL || s->the_bfd == NULL)
1079 /* Don't look for a second non-loaded as-needed lib. */
1080 if (global_found != NULL
1081 && (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
1084 if (filename_cmp (s->filename, global_needed->name) == 0)
1090 if (s->flags.search_dirs)
1092 const char *f = strrchr (s->filename, '/');
1094 && filename_cmp (f + 1, global_needed->name) == 0)
1101 soname = bfd_elf_get_dt_soname (s->the_bfd);
1103 && filename_cmp (soname, global_needed->name) == 0)
1112 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
1115 static bfd_size_type
1116 id_note_section_size (bfd *abfd ATTRIBUTE_UNUSED)
1118 const char *style = emit_note_gnu_build_id;
1120 bfd_size_type build_id_size;
1122 size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
1123 size = (size + 3) & -(bfd_size_type) 4;
1125 build_id_size = compute_build_id_size (style);
1127 size += build_id_size;
1135 write_build_id (bfd *abfd)
1137 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1138 struct elf_obj_tdata *t = elf_tdata (abfd);
1141 Elf_Internal_Shdr *i_shdr;
1142 unsigned char *contents, *id_bits;
1145 Elf_External_Note *e_note;
1147 style = t->o->build_id.style;
1148 asec = t->o->build_id.sec;
1149 if (bfd_is_abs_section (asec->output_section))
1151 einfo (_("%P: warning: .note.gnu.build-id section discarded,"
1152 " --build-id ignored\n"));
1155 i_shdr = &elf_section_data (asec->output_section)->this_hdr;
1157 if (i_shdr->contents == NULL)
1159 if (asec->contents == NULL)
1160 asec->contents = (unsigned char *) xmalloc (asec->size);
1161 contents = asec->contents;
1164 contents = i_shdr->contents + asec->output_offset;
1166 e_note = (Elf_External_Note *) contents;
1167 size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
1168 size = (size + 3) & -(bfd_size_type) 4;
1169 id_bits = contents + size;
1170 size = asec->size - size;
1172 bfd_h_put_32 (abfd, sizeof "GNU", &e_note->namesz);
1173 bfd_h_put_32 (abfd, size, &e_note->descsz);
1174 bfd_h_put_32 (abfd, NT_GNU_BUILD_ID, &e_note->type);
1175 memcpy (e_note->name, "GNU", sizeof "GNU");
1177 generate_build_id (abfd, style, bed->s->checksum_contents, id_bits, size);
1179 position = i_shdr->sh_offset + asec->output_offset;
1181 return (bfd_seek (abfd, position, SEEK_SET) == 0
1182 && bfd_bwrite (contents, size, abfd) == size);
1185 /* Make .note.gnu.build-id section, and set up elf_tdata->build_id. */
1188 setup_build_id (bfd *ibfd)
1194 size = id_note_section_size (ibfd);
1197 einfo (_("%P: warning: unrecognized --build-id style ignored\n"));
1201 flags = (SEC_ALLOC | SEC_LOAD | SEC_IN_MEMORY
1202 | SEC_LINKER_CREATED | SEC_READONLY | SEC_DATA);
1203 s = bfd_make_section_with_flags (ibfd, ".note.gnu.build-id", flags);
1204 if (s != NULL && bfd_set_section_alignment (ibfd, s, 2))
1206 struct elf_obj_tdata *t = elf_tdata (link_info.output_bfd);
1207 t->o->build_id.after_write_object_contents = &write_build_id;
1208 t->o->build_id.style = emit_note_gnu_build_id;
1209 t->o->build_id.sec = s;
1210 elf_section_type (s) = SHT_NOTE;
1215 einfo (_("%P: warning: cannot create .note.gnu.build-id section,"
1216 " --build-id ignored\n"));
1220 /* This is called after all the input files have been opened. */
1223 gld${EMULATION_NAME}_after_open (void)
1225 struct bfd_link_needed_list *needed, *l;
1226 struct elf_link_hash_table *htab;
1230 after_open_default ();
1232 htab = elf_hash_table (&link_info);
1233 if (!is_elf_hash_table (htab))
1236 if (command_line.out_implib_filename)
1238 unlink_if_ordinary (command_line.out_implib_filename);
1239 link_info.out_implib_bfd
1240 = bfd_openw (command_line.out_implib_filename,
1241 bfd_get_target (link_info.output_bfd));
1243 if (link_info.out_implib_bfd == NULL)
1245 einfo (_("%F%P: %s: can't open for writing: %E\n"),
1246 command_line.out_implib_filename);
1250 if (emit_note_gnu_build_id != NULL)
1252 /* Find an ELF input. */
1253 for (abfd = link_info.input_bfds;
1254 abfd != (bfd *) NULL; abfd = abfd->link.next)
1255 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1256 && bfd_count_sections (abfd) != 0
1257 && !((lang_input_statement_type *) abfd->usrdata)->flags.just_syms)
1260 /* PR 10555: If there are no ELF input files do not try to
1261 create a .note.gnu-build-id section. */
1263 || !setup_build_id (abfd))
1265 free ((char *) emit_note_gnu_build_id);
1266 emit_note_gnu_build_id = NULL;
1270 get_elf_backend_data (link_info.output_bfd)->setup_gnu_properties (&link_info);
1272 if (bfd_link_relocatable (&link_info))
1274 if (link_info.execstack == ! link_info.noexecstack)
1275 /* PR ld/16744: If "-z [no]execstack" has been specified on the
1276 command line and we are perfoming a relocatable link then no
1277 PT_GNU_STACK segment will be created and so the
1278 linkinfo.[no]execstack values set in _handle_option() will have no
1279 effect. Instead we create a .note.GNU-stack section in much the
1280 same way as the assembler does with its --[no]execstack option. */
1281 (void) bfd_make_section_with_flags (link_info.input_bfds,
1283 SEC_READONLY | (link_info.execstack ? SEC_CODE : 0));
1288 if (!link_info.traditional_format)
1291 bfd_boolean warn_eh_frame = FALSE;
1294 for (abfd = link_info.input_bfds; abfd; abfd = abfd->link.next)
1298 if (((lang_input_statement_type *) abfd->usrdata)->flags.just_syms)
1301 for (s = abfd->sections; s && type < COMPACT_EH_HDR; s = s->next)
1303 const char *name = bfd_get_section_name (abfd, s);
1305 if (bfd_is_abs_section (s->output_section))
1307 if (CONST_STRNEQ (name, ".eh_frame_entry"))
1308 type = COMPACT_EH_HDR;
1309 else if (strcmp (name, ".eh_frame") == 0 && s->size > 8)
1310 type = DWARF2_EH_HDR;
1319 else if (seen_type != type)
1321 einfo (_("%F%P: compact frame descriptions incompatible with"
1322 " DWARF2 .eh_frame from %pB\n"),
1323 type == DWARF2_EH_HDR ? abfd : elfbfd);
1328 && (type == COMPACT_EH_HDR || link_info.eh_frame_hdr_type != 0))
1330 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1333 warn_eh_frame = TRUE;
1337 if (seen_type == COMPACT_EH_HDR)
1338 link_info.eh_frame_hdr_type = COMPACT_EH_HDR;
1342 const struct elf_backend_data *bed;
1344 bed = get_elf_backend_data (elfbfd);
1345 s = bfd_make_section_with_flags (elfbfd, ".eh_frame_hdr",
1346 bed->dynamic_sec_flags
1349 && bfd_set_section_alignment (elfbfd, s, 2))
1351 htab->eh_info.hdr_sec = s;
1352 warn_eh_frame = FALSE;
1356 einfo (_("%P: warning: cannot create .eh_frame_hdr section,"
1357 " --eh-frame-hdr ignored\n"));
1360 /* Get the list of files which appear in DT_NEEDED entries in
1361 dynamic objects included in the link (often there will be none).
1362 For each such file, we want to track down the corresponding
1363 library, and include the symbol table in the link. This is what
1364 the runtime dynamic linker will do. Tracking the files down here
1365 permits one dynamic object to include another without requiring
1366 special action by the person doing the link. Note that the
1367 needed list can actually grow while we are stepping through this
1369 needed = bfd_elf_get_needed_list (link_info.output_bfd, &link_info);
1370 for (l = needed; l != NULL; l = l->next)
1372 struct bfd_link_needed_list *ll;
1373 struct dt_needed n, nn;
1376 /* If the lib that needs this one was --as-needed and wasn't
1377 found to be needed, then this lib isn't needed either. */
1379 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
1382 /* Skip the lib if --no-copy-dt-needed-entries and
1383 --allow-shlib-undefined is in effect. */
1385 && link_info.unresolved_syms_in_shared_libs == RM_IGNORE
1386 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_NO_ADD_NEEDED) != 0)
1389 /* If we've already seen this file, skip it. */
1390 for (ll = needed; ll != l; ll = ll->next)
1392 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
1393 && strcmp (ll->name, l->name) == 0)
1398 /* See if this file was included in the link explicitly. */
1400 global_found = NULL;
1401 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
1402 if (global_found != NULL
1403 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
1404 & DYN_AS_NEEDED) == 0)
1411 info_msg (_("%s needed by %pB\n"), l->name, l->by);
1413 /* As-needed libs specified on the command line (or linker script)
1414 take priority over libs found in search dirs. */
1415 if (global_found != NULL)
1417 nn.name = global_found->filename;
1418 if (gld${EMULATION_NAME}_try_needed (&nn, TRUE))
1422 /* We need to find this file and include the symbol table. We
1423 want to search for the file in the same way that the dynamic
1424 linker will search. That means that we want to use
1425 rpath_link, rpath, then the environment variable
1426 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
1427 entries (native only), then the linker script LIB_SEARCH_DIRS.
1428 We do not search using the -L arguments.
1430 We search twice. The first time, we skip objects which may
1431 introduce version mismatches. The second time, we force
1432 their use. See gld${EMULATION_NAME}_vercheck comment. */
1433 for (force = 0; force < 2; force++)
1436 search_dirs_type *search;
1438 if [ "x${NATIVE}" = xyes ] || [ "x${USE_LIBPATH}" = xyes ] ; then
1443 if [ "x${USE_LIBPATH}" = xyes ] ; then
1445 struct bfd_link_needed_list *rp;
1451 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
1455 if [ "x${USE_LIBPATH}" = xyes ] ; then
1457 path = command_line.rpath;
1460 path = gld${EMULATION_NAME}_add_sysroot (path);
1461 found = gld${EMULATION_NAME}_search_needed (path, &n, force);
1462 free ((char *) path);
1468 if [ "x${NATIVE}" = xyes ] ; then
1470 if (command_line.rpath_link == NULL
1471 && command_line.rpath == NULL)
1473 path = (const char *) getenv ("LD_RUN_PATH");
1475 && gld${EMULATION_NAME}_search_needed (path, &n, force))
1478 path = (const char *) getenv ("LD_LIBRARY_PATH");
1480 && gld${EMULATION_NAME}_search_needed (path, &n, force))
1484 if [ "x${USE_LIBPATH}" = xyes ] ; then
1487 rp = bfd_elf_get_runpath_list (link_info.output_bfd, &link_info);
1488 for (; !found && rp != NULL; rp = rp->next)
1490 path = gld${EMULATION_NAME}_add_sysroot (rp->name);
1491 found = (rp->by == l->by
1492 && gld${EMULATION_NAME}_search_needed (path, &n,
1494 free ((char *) path);
1501 if [ "x${USE_LIBPATH}" = xyes ] ; then
1503 *-*-freebsd* | *-*-dragonfly*)
1505 if (gld${EMULATION_NAME}_check_ld_elf_hints (l, force))
1511 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
1513 if (gld${EMULATION_NAME}_check_ld_so_conf (l, force))
1522 len = strlen (l->name);
1523 for (search = search_head; search != NULL; search = search->next)
1527 if (search->cmdline)
1529 filename = (char *) xmalloc (strlen (search->name) + len + 2);
1530 sprintf (filename, "%s/%s", search->name, l->name);
1532 if (gld${EMULATION_NAME}_try_needed (&nn, force))
1545 einfo (_("%P: warning: %s, needed by %pB, not found "
1546 "(try using -rpath or -rpath-link)\n"),
1550 if (link_info.eh_frame_hdr_type == COMPACT_EH_HDR)
1551 if (!bfd_elf_parse_eh_frame_entries (NULL, &link_info))
1552 einfo (_("%F%P: failed to parse EH frame entries\n"));
1560 /* Look through an expression for an assignment statement. */
1563 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1565 bfd_boolean provide = FALSE;
1567 switch (exp->type.node_class)
1570 case etree_provided:
1574 /* We call record_link_assignment even if the symbol is defined.
1575 This is because if it is defined by a dynamic object, we
1576 actually want to use the value defined by the linker script,
1577 not the value from the dynamic object (because we are setting
1578 symbols like etext). If the symbol is defined by a regular
1579 object, then, as it happens, calling record_link_assignment
1581 if (strcmp (exp->assign.dst, ".") != 0)
1583 if (!bfd_elf_record_link_assignment (link_info.output_bfd,
1585 exp->assign.dst, provide,
1586 exp->assign.hidden))
1587 einfo (_("%F%P: failed to record assignment to %s: %E\n"),
1590 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1594 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1595 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1599 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1600 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1601 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1605 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1614 /* This is called by the before_allocation routine via
1615 lang_for_each_statement. It locates any assignment statements, and
1616 tells the ELF backend about them, in case they are assignments to
1617 symbols which are referred to by dynamic objects. */
1620 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1622 if (s->header.type == lang_assignment_statement_enum)
1623 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1628 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1629 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1630 ELF_INTERPRETER_SET_DEFAULT="
1631 if (sinterp != NULL)
1633 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1634 sinterp->size = strlen ((char *) sinterp->contents) + 1;
1639 ELF_INTERPRETER_SET_DEFAULT=
1643 /* used by before_allocation and handle_option. */
1645 gld${EMULATION_NAME}_append_to_separated_string (char **to, char *op_arg)
1648 *to = xstrdup (op_arg);
1651 size_t to_len = strlen (*to);
1652 size_t op_arg_len = strlen (op_arg);
1656 /* First see whether OPTARG is already in the path. */
1659 if (strncmp (op_arg, cp, op_arg_len) == 0
1660 && (cp[op_arg_len] == 0
1661 || cp[op_arg_len] == config.rpath_separator))
1665 /* Not yet found. */
1666 cp = strchr (cp, config.rpath_separator);
1674 buf = xmalloc (to_len + op_arg_len + 2);
1675 sprintf (buf, "%s%c%s", *to,
1676 config.rpath_separator, op_arg);
1683 #if defined(__GNUC__) && GCC_VERSION < 4006
1684 /* Work around a GCC uninitialized warning bug fixed in GCC 4.6. */
1685 static struct bfd_link_hash_entry ehdr_start_empty;
1688 /* This is called after the sections have been attached to output
1689 sections, but before any sizes or addresses have been set. */
1692 gld${EMULATION_NAME}_before_allocation (void)
1697 struct elf_link_hash_entry *ehdr_start = NULL;
1698 #if defined(__GNUC__) && GCC_VERSION < 4006
1699 /* Work around a GCC uninitialized warning bug fixed in GCC 4.6. */
1700 struct bfd_link_hash_entry ehdr_start_save = ehdr_start_empty;
1702 struct bfd_link_hash_entry ehdr_start_save;
1705 if (is_elf_hash_table (link_info.hash))
1707 _bfd_elf_tls_setup (link_info.output_bfd, &link_info);
1709 /* Make __ehdr_start hidden if it has been referenced, to
1710 prevent the symbol from being dynamic. */
1711 if (!bfd_link_relocatable (&link_info))
1713 struct elf_link_hash_table *htab = elf_hash_table (&link_info);
1714 struct elf_link_hash_entry *h
1715 = elf_link_hash_lookup (htab, "__ehdr_start", FALSE, FALSE, TRUE);
1717 /* Only adjust the export class if the symbol was referenced
1718 and not defined, otherwise leave it alone. */
1720 && (h->root.type == bfd_link_hash_new
1721 || h->root.type == bfd_link_hash_undefined
1722 || h->root.type == bfd_link_hash_undefweak
1723 || h->root.type == bfd_link_hash_common))
1725 const struct elf_backend_data *bed;
1726 bed = get_elf_backend_data (link_info.output_bfd);
1727 (*bed->elf_backend_hide_symbol) (&link_info, h, TRUE);
1728 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
1729 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
1730 /* Don't leave the symbol undefined. Undefined hidden
1731 symbols typically won't have dynamic relocations, but
1732 we most likely will need dynamic relocations for
1733 __ehdr_start if we are building a PIE or shared
1736 ehdr_start_save = h->root;
1737 h->root.type = bfd_link_hash_defined;
1738 h->root.u.def.section = bfd_abs_section_ptr;
1739 h->root.u.def.value = 0;
1743 /* If we are going to make any variable assignments, we need to
1744 let the ELF backend know about them in case the variables are
1745 referred to by dynamic objects. */
1746 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1749 /* Let the ELF backend work out the sizes of any sections required
1750 by dynamic linking. */
1751 rpath = command_line.rpath;
1753 rpath = (const char *) getenv ("LD_RUN_PATH");
1755 for (abfd = link_info.input_bfds; abfd; abfd = abfd->link.next)
1756 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1758 const char *audit_libs = elf_dt_audit (abfd);
1760 /* If the input bfd contains an audit entry, we need to add it as
1761 a dep audit entry. */
1762 if (audit_libs && *audit_libs != '\0')
1764 char *cp = xstrdup (audit_libs);
1768 char *cp2 = strchr (cp, config.rpath_separator);
1776 if (cp != NULL && *cp != '\0')
1777 gld${EMULATION_NAME}_append_to_separated_string (&depaudit, cp);
1779 cp = more ? ++cp2 : NULL;
1785 if (! (bfd_elf_size_dynamic_sections
1786 (link_info.output_bfd, command_line.soname, rpath,
1787 command_line.filter_shlib, audit, depaudit,
1788 (const char * const *) command_line.auxiliary_filters,
1789 &link_info, &sinterp)))
1790 einfo (_("%F%P: failed to set dynamic section sizes: %E\n"));
1792 ${ELF_INTERPRETER_SET_DEFAULT}
1793 /* Let the user override the dynamic linker we are using. */
1794 if (command_line.interpreter != NULL
1797 sinterp->contents = (bfd_byte *) command_line.interpreter;
1798 sinterp->size = strlen (command_line.interpreter) + 1;
1801 /* Look for any sections named .gnu.warning. As a GNU extensions,
1802 we treat such sections as containing warning messages. We print
1803 out the warning message, and then zero out the section size so
1804 that it does not get copied into the output file. */
1807 LANG_FOR_EACH_INPUT_STATEMENT (is)
1813 if (is->flags.just_syms)
1816 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1821 msg = (char *) xmalloc ((size_t) (sz + 1));
1822 if (! bfd_get_section_contents (is->the_bfd, s, msg,
1824 einfo (_("%F%P: %pB: can't read contents of section .gnu.warning: %E\n"),
1827 (*link_info.callbacks->warning) (&link_info, msg,
1828 (const char *) NULL, is->the_bfd,
1829 (asection *) NULL, (bfd_vma) 0);
1832 /* Clobber the section size, so that we don't waste space
1833 copying the warning into the output file. If we've already
1834 sized the output section, adjust its size. The adjustment
1835 is on rawsize because targets that size sections early will
1836 have called lang_reset_memory_regions after sizing. */
1837 if (s->output_section != NULL
1838 && s->output_section->rawsize >= s->size)
1839 s->output_section->rawsize -= s->size;
1843 /* Also set SEC_EXCLUDE, so that local symbols defined in the
1844 warning section don't get copied to the output. */
1845 s->flags |= SEC_EXCLUDE | SEC_KEEP;
1849 before_allocation_default ();
1851 if (!bfd_elf_size_dynsym_hash_dynstr (link_info.output_bfd, &link_info))
1852 einfo (_("%F%P: failed to set dynamic section sizes: %E\n"));
1854 if (ehdr_start != NULL)
1856 /* If we twiddled __ehdr_start to defined earlier, put it back
1858 ehdr_start->root.type = ehdr_start_save.type;
1859 ehdr_start->root.u = ehdr_start_save.u;
1866 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1869 /* Try to open a dynamic archive. This is where we know that ELF
1870 dynamic libraries have an extension of .so (or .sl on oddball systems
1874 gld${EMULATION_NAME}_open_dynamic_archive
1875 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1877 const char *filename;
1880 bfd_boolean opened = FALSE;
1882 if (! entry->flags.maybe_archive)
1885 filename = entry->filename;
1886 len = strlen (search->name) + strlen (filename);
1887 if (entry->flags.full_name_provided)
1890 string = (char *) xmalloc (len);
1891 sprintf (string, "%s/%s", search->name, filename);
1897 len += strlen (arch) + sizeof "/lib.so";
1898 #ifdef EXTRA_SHLIB_EXTENSION
1899 xlen = (strlen (EXTRA_SHLIB_EXTENSION) > 3
1900 ? strlen (EXTRA_SHLIB_EXTENSION) - 3
1903 string = (char *) xmalloc (len + xlen);
1904 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1905 #ifdef EXTRA_SHLIB_EXTENSION
1906 /* Try the .so extension first. If that fails build a new filename
1907 using EXTRA_SHLIB_EXTENSION. */
1908 opened = ldfile_try_open_bfd (string, entry);
1910 strcpy (string + len - 4, EXTRA_SHLIB_EXTENSION);
1914 if (!opened && !ldfile_try_open_bfd (string, entry))
1920 entry->filename = string;
1922 /* We have found a dynamic object to include in the link. The ELF
1923 backend linker will create a DT_NEEDED entry in the .dynamic
1924 section naming this file. If this file includes a DT_SONAME
1925 entry, it will be used. Otherwise, the ELF linker will just use
1926 the name of the file. For an archive found by searching, like
1927 this one, the DT_NEEDED entry should consist of just the name of
1928 the file, without the path information used to find it. Note
1929 that we only need to do this if we have a dynamic object; an
1930 archive will never be referenced by a DT_NEEDED entry.
1932 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1933 very pretty. I haven't been able to think of anything that is
1935 if (bfd_check_format (entry->the_bfd, bfd_object)
1936 && (entry->the_bfd->flags & DYNAMIC) != 0)
1938 ASSERT (entry->flags.maybe_archive && entry->flags.search_dirs);
1940 /* Rather than duplicating the logic above. Just use the
1941 filename we recorded earlier. */
1943 if (!entry->flags.full_name_provided)
1944 filename = lbasename (entry->filename);
1945 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1954 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1957 /* A variant of lang_output_section_find used by place_orphan. */
1959 static lang_output_section_statement_type *
1960 output_rel_find (asection *sec, int isdyn)
1962 lang_output_section_statement_type *lookup;
1963 lang_output_section_statement_type *last = NULL;
1964 lang_output_section_statement_type *last_alloc = NULL;
1965 lang_output_section_statement_type *last_ro_alloc = NULL;
1966 lang_output_section_statement_type *last_rel = NULL;
1967 lang_output_section_statement_type *last_rel_alloc = NULL;
1968 int rela = sec->name[4] == 'a';
1970 for (lookup = &lang_output_section_statement.head->output_section_statement;
1972 lookup = lookup->next)
1974 if (lookup->constraint >= 0
1975 && CONST_STRNEQ (lookup->name, ".rel"))
1977 int lookrela = lookup->name[4] == 'a';
1979 /* .rel.dyn must come before all other reloc sections, to suit
1984 /* Don't place after .rel.plt as doing so results in wrong
1986 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1989 if (rela == lookrela || last_rel == NULL)
1991 if ((rela == lookrela || last_rel_alloc == NULL)
1992 && lookup->bfd_section != NULL
1993 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1994 last_rel_alloc = lookup;
1998 if (lookup->bfd_section != NULL
1999 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
2001 last_alloc = lookup;
2002 if ((lookup->bfd_section->flags & SEC_READONLY) != 0)
2003 last_ro_alloc = lookup;
2008 return last_rel_alloc;
2014 return last_ro_alloc;
2022 /* Return whether IN is suitable to be part of OUT. */
2025 elf_orphan_compatible (asection *in, asection *out)
2027 /* Non-zero sh_info implies a section with SHF_INFO_LINK with
2028 unknown semantics for the generic linker, or a SHT_REL/SHT_RELA
2029 section where sh_info specifies a symbol table. (We won't see
2030 SHT_GROUP, SHT_SYMTAB or SHT_DYNSYM sections here.) We clearly
2031 can't merge SHT_REL/SHT_RELA using differing symbol tables, and
2032 shouldn't merge sections with differing unknown semantics. */
2033 if (elf_section_data (out)->this_hdr.sh_info
2034 != elf_section_data (in)->this_hdr.sh_info)
2036 /* We can't merge two sections with differing SHF_EXCLUDE when doing
2037 a relocatable link. */
2038 if (bfd_link_relocatable (&link_info)
2039 && ((elf_section_flags (out) ^ elf_section_flags (in)) & SHF_EXCLUDE) != 0)
2041 return _bfd_elf_match_sections_by_type (link_info.output_bfd, out,
2045 /* Place an orphan section. We use this to put random SHF_ALLOC
2046 sections in the right segment. */
2048 static lang_output_section_statement_type *
2049 gld${EMULATION_NAME}_place_orphan (asection *s,
2050 const char *secname,
2053 static struct orphan_save hold[] =
2056 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
2059 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
2062 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_THREAD_LOCAL,
2065 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
2071 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
2074 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
2077 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
2083 enum orphan_save_index
2095 static int orphan_init_done = 0;
2096 struct orphan_save *place;
2097 lang_output_section_statement_type *after;
2098 lang_output_section_statement_type *os;
2099 lang_output_section_statement_type *match_by_name = NULL;
2101 int elfinput = s->owner->xvec->flavour == bfd_target_elf_flavour;
2102 int elfoutput = link_info.output_bfd->xvec->flavour == bfd_target_elf_flavour;
2103 unsigned int sh_type = elfinput ? elf_section_type (s) : SHT_NULL;
2107 if (!bfd_link_relocatable (&link_info)
2108 && link_info.combreloc
2109 && (s->flags & SEC_ALLOC))
2115 secname = ".rela.dyn";
2119 secname = ".rel.dyn";
2125 else if (CONST_STRNEQ (secname, ".rel"))
2127 secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
2132 if (!bfd_link_relocatable (&link_info)
2135 && (s->flags & SEC_ALLOC) != 0
2136 && (elf_section_flags (s) & SHF_GNU_MBIND) != 0)
2138 /* Find the output mbind section with the same type, attributes
2139 and sh_info field. */
2140 for (os = &lang_output_section_statement.head->output_section_statement;
2143 if (os->bfd_section != NULL
2144 && !bfd_is_abs_section (os->bfd_section)
2145 && (elf_section_flags (os->bfd_section) & SHF_GNU_MBIND) != 0
2146 && ((s->flags & (SEC_ALLOC
2151 == (os->bfd_section->flags & (SEC_ALLOC
2156 && (elf_section_data (os->bfd_section)->this_hdr.sh_info
2157 == elf_section_data (s)->this_hdr.sh_info))
2159 lang_add_section (&os->children, s, NULL, os);
2163 /* Create the output mbind section with the ".mbind." prefix
2165 if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2166 secname = ".mbind.bss";
2167 else if ((s->flags & SEC_READONLY) == 0)
2168 secname = ".mbind.data";
2169 else if ((s->flags & SEC_CODE) == 0)
2170 secname = ".mbind.rodata";
2172 secname = ".mbind.text";
2175 /* Look through the script to see where to place this section. The
2176 script includes entries added by previous lang_insert_orphan
2177 calls, so this loop puts multiple compatible orphans of the same
2178 name into a single output section. */
2179 if (constraint == 0)
2180 for (os = lang_output_section_find (secname);
2182 os = next_matching_output_section_statement (os, 0))
2184 /* If we don't match an existing output section, tell
2185 lang_insert_orphan to create a new output section. */
2186 constraint = SPECIAL;
2188 /* Check to see if we already have an output section statement
2189 with this name, and its bfd section has compatible flags.
2190 If the section already exists but does not have any flags
2191 set, then it has been created by the linker, possibly as a
2192 result of a --section-start command line switch. */
2193 if (os->bfd_section != NULL
2194 && (os->bfd_section->flags == 0
2195 || (((s->flags ^ os->bfd_section->flags)
2196 & (SEC_LOAD | SEC_ALLOC)) == 0
2199 || elf_orphan_compatible (s, os->bfd_section)))))
2201 lang_add_section (&os->children, s, NULL, os);
2205 /* Save unused output sections in case we can match them
2206 against orphans later. */
2207 if (os->bfd_section == NULL)
2211 /* If we didn't match an active output section, see if we matched an
2212 unused one and use that. */
2215 lang_add_section (&match_by_name->children, s, NULL, match_by_name);
2216 return match_by_name;
2219 if (!orphan_init_done)
2221 struct orphan_save *ho;
2223 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
2224 if (ho->name != NULL)
2226 ho->os = lang_output_section_find (ho->name);
2227 if (ho->os != NULL && ho->os->flags == 0)
2228 ho->os->flags = ho->flags;
2230 orphan_init_done = 1;
2233 /* If this is a final link, then always put .gnu.warning.SYMBOL
2234 sections into the .text section to get them out of the way. */
2235 if (bfd_link_executable (&link_info)
2236 && CONST_STRNEQ (s->name, ".gnu.warning.")
2237 && hold[orphan_text].os != NULL)
2239 os = hold[orphan_text].os;
2240 lang_add_section (&os->children, s, NULL, os);
2245 if (!bfd_link_relocatable (&link_info))
2248 while ((nexts = bfd_get_next_section_by_name (nexts->owner, nexts))
2250 if (nexts->output_section == NULL
2251 && (nexts->flags & SEC_EXCLUDE) == 0
2252 && ((nexts->flags ^ flags) & (SEC_LOAD | SEC_ALLOC)) == 0
2253 && (nexts->owner->flags & DYNAMIC) == 0
2254 && nexts->owner->usrdata != NULL
2255 && !(((lang_input_statement_type *) nexts->owner->usrdata)
2257 && _bfd_elf_match_sections_by_type (nexts->owner, nexts,
2259 flags = (((flags ^ SEC_READONLY)
2260 | (nexts->flags ^ SEC_READONLY))
2264 /* Decide which segment the section should go in based on the
2265 section name and section flags. We put loadable .note sections
2266 right after the .interp section, so that the PT_NOTE segment is
2267 stored right after the program headers where the OS can read it
2268 in the first page. */
2271 if ((flags & (SEC_ALLOC | SEC_DEBUGGING)) == 0)
2272 place = &hold[orphan_nonalloc];
2273 else if ((flags & SEC_ALLOC) == 0)
2275 else if ((flags & SEC_LOAD) != 0
2276 && ((elfinput && sh_type == SHT_NOTE)
2277 || (!elfinput && CONST_STRNEQ (secname, ".note"))))
2278 place = &hold[orphan_interp];
2279 else if ((flags & (SEC_LOAD | SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) == 0)
2280 place = &hold[orphan_bss];
2281 else if ((flags & SEC_SMALL_DATA) != 0)
2282 place = &hold[orphan_sdata];
2283 else if ((flags & SEC_THREAD_LOCAL) != 0)
2284 place = &hold[orphan_tdata];
2285 else if ((flags & SEC_READONLY) == 0)
2286 place = &hold[orphan_data];
2287 else if (((elfinput && (sh_type == SHT_RELA || sh_type == SHT_REL))
2288 || (!elfinput && CONST_STRNEQ (secname, ".rel")))
2289 && (flags & SEC_LOAD) != 0)
2290 place = &hold[orphan_rel];
2291 else if ((flags & SEC_CODE) == 0)
2292 place = &hold[orphan_rodata];
2294 place = &hold[orphan_text];
2299 if (place->os == NULL)
2301 if (place->name != NULL)
2302 place->os = lang_output_section_find (place->name);
2304 place->os = output_rel_find (s, isdyn);
2309 = lang_output_section_find_by_flags (s, flags, &place->os,
2310 _bfd_elf_match_sections_by_type);
2312 /* *ABS* is always the first output section statement. */
2313 after = &lang_output_section_statement.head->output_section_statement;
2316 return lang_insert_orphan (s, secname, constraint, after, place, NULL, NULL);
2321 if test x"$LDEMUL_AFTER_ALLOCATION" != xgld"$EMULATION_NAME"_after_allocation; then
2325 gld${EMULATION_NAME}_after_allocation (void)
2327 int need_layout = bfd_elf_discard_info (link_info.output_bfd, &link_info);
2329 if (need_layout < 0)
2330 einfo (_("%X%P: .eh_frame/.stab edit: %E\n"));
2332 gld${EMULATION_NAME}_map_segments (need_layout);
2337 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
2341 gld${EMULATION_NAME}_get_script (int *isfile)
2344 if test x"$COMPILE_IN" = xyes
2346 # Scripts compiled in.
2348 # sed commands to quote an ld script as a C string.
2349 sc="-f stringify.sed"
2355 if (bfd_link_relocatable (&link_info) && config.build_constructors)
2358 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
2359 echo ' ; else if (bfd_link_relocatable (&link_info)) return' >> e${EMULATION_NAME}.c
2360 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
2361 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
2362 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
2363 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
2364 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
2365 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
2367 if test -n "$GENERATE_PIE_SCRIPT" ; then
2368 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2369 echo ' ; else if (bfd_link_pie (&link_info)' >> e${EMULATION_NAME}.c
2370 echo ' && link_info.combreloc' >> e${EMULATION_NAME}.c
2371 echo ' && link_info.separate_code' >> e${EMULATION_NAME}.c
2372 echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2373 sed $sc ldscripts/${EMULATION_NAME}.xdwe >> e${EMULATION_NAME}.c
2374 echo ' ; else if (bfd_link_pie (&link_info)' >> e${EMULATION_NAME}.c
2375 echo ' && link_info.combreloc' >> e${EMULATION_NAME}.c
2376 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
2377 echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2378 sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
2379 echo ' ; else if (bfd_link_pie (&link_info)' >> e${EMULATION_NAME}.c
2380 echo ' && link_info.separate_code' >> e${EMULATION_NAME}.c
2381 echo ' && link_info.combreloc) return' >> e${EMULATION_NAME}.c
2382 sed $sc ldscripts/${EMULATION_NAME}.xdce >> e${EMULATION_NAME}.c
2383 echo ' ; else if (bfd_link_pie (&link_info)' >> e${EMULATION_NAME}.c
2384 echo ' && link_info.combreloc) return' >> e${EMULATION_NAME}.c
2385 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
2387 echo ' ; else if (bfd_link_pie (&link_info)' >> e${EMULATION_NAME}.c
2388 echo ' && link_info.separate_code) return' >> e${EMULATION_NAME}.c
2389 sed $sc ldscripts/${EMULATION_NAME}.xde >> e${EMULATION_NAME}.c
2390 echo ' ; else if (bfd_link_pie (&link_info)) return' >> e${EMULATION_NAME}.c
2391 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
2393 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
2394 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2395 echo ' ; else if (bfd_link_dll (&link_info)' >> e${EMULATION_NAME}.c
2396 echo ' && link_info.combreloc' >> e${EMULATION_NAME}.c
2397 echo ' && link_info.separate_code' >> e${EMULATION_NAME}.c
2398 echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2399 sed $sc ldscripts/${EMULATION_NAME}.xswe >> e${EMULATION_NAME}.c
2400 echo ' ; else if (bfd_link_dll (&link_info)' >> e${EMULATION_NAME}.c
2401 echo ' && link_info.combreloc' >> e${EMULATION_NAME}.c
2402 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
2403 echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2404 sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
2405 echo ' ; else if (bfd_link_dll (&link_info)' >> e${EMULATION_NAME}.c
2406 echo ' && link_info.combreloc' >> e${EMULATION_NAME}.c
2407 echo ' && link_info.separate_code) return' >> e${EMULATION_NAME}.c
2408 sed $sc ldscripts/${EMULATION_NAME}.xsce >> e${EMULATION_NAME}.c
2409 echo ' ; else if (bfd_link_dll (&link_info)' >> e${EMULATION_NAME}.c
2410 echo ' && link_info.combreloc) return' >> e${EMULATION_NAME}.c
2411 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
2413 echo ' ; else if (bfd_link_dll (&link_info)' >> e${EMULATION_NAME}.c
2414 echo ' && link_info.separate_code) return' >> e${EMULATION_NAME}.c
2415 sed $sc ldscripts/${EMULATION_NAME}.xse >> e${EMULATION_NAME}.c
2416 echo ' ; else if (bfd_link_dll (&link_info)) return' >> e${EMULATION_NAME}.c
2417 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
2419 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2420 echo ' ; else if (link_info.combreloc' >> e${EMULATION_NAME}.c
2421 echo ' && link_info.separate_code' >> e${EMULATION_NAME}.c
2422 echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2423 sed $sc ldscripts/${EMULATION_NAME}.xwe >> e${EMULATION_NAME}.c
2424 echo ' ; else if (link_info.combreloc' >> e${EMULATION_NAME}.c
2425 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
2426 echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2427 sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
2428 echo ' ; else if (link_info.combreloc' >> e${EMULATION_NAME}.c
2429 echo ' && link_info.separate_code) return' >> e${EMULATION_NAME}.c
2430 sed $sc ldscripts/${EMULATION_NAME}.xce >> e${EMULATION_NAME}.c
2431 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
2432 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
2434 echo ' ; else if (link_info.separate_code) return' >> e${EMULATION_NAME}.c
2435 sed $sc ldscripts/${EMULATION_NAME}.xe >> e${EMULATION_NAME}.c
2436 echo ' ; else return' >> e${EMULATION_NAME}.c
2437 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
2438 echo '; }' >> e${EMULATION_NAME}.c
2441 # Scripts read from the filesystem.
2447 if (bfd_link_relocatable (&link_info) && config.build_constructors)
2448 return "ldscripts/${EMULATION_NAME}.xu";
2449 else if (bfd_link_relocatable (&link_info))
2450 return "ldscripts/${EMULATION_NAME}.xr";
2451 else if (!config.text_read_only)
2452 return "ldscripts/${EMULATION_NAME}.xbn";
2454 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
2457 else if (!config.magic_demand_paged)
2458 return "ldscripts/${EMULATION_NAME}.xn";
2461 if test -n "$GENERATE_PIE_SCRIPT" ; then
2462 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2464 else if (bfd_link_pie (&link_info)
2465 && link_info.combreloc
2467 && (link_info.flags & DF_BIND_NOW))
2469 if (link_info.separate_code)
2470 return "ldscripts/${EMULATION_NAME}.xdwe";
2472 return "ldscripts/${EMULATION_NAME}.xdw";
2474 else if (bfd_link_pie (&link_info)
2475 && link_info.combreloc)
2477 if (link_info.separate_code)
2478 return "ldscripts/${EMULATION_NAME}.xdce";
2480 return "ldscripts/${EMULATION_NAME}.xdc";
2485 else if (bfd_link_pie (&link_info))
2487 if (link_info.separate_code)
2488 return "ldscripts/${EMULATION_NAME}.xde";
2490 return "ldscripts/${EMULATION_NAME}.xd";
2494 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
2495 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2497 else if (bfd_link_dll (&link_info) && link_info.combreloc
2498 && link_info.relro && (link_info.flags & DF_BIND_NOW))
2500 if (link_info.separate_code)
2501 return "ldscripts/${EMULATION_NAME}.xswe";
2503 return "ldscripts/${EMULATION_NAME}.xsw";
2505 else if (bfd_link_dll (&link_info) && link_info.combreloc)
2507 if (link_info.separate_code)
2508 return "ldscripts/${EMULATION_NAME}.xsce";
2510 return "ldscripts/${EMULATION_NAME}.xsc";
2515 else if (bfd_link_dll (&link_info))
2517 if (link_info.separate_code)
2518 return "ldscripts/${EMULATION_NAME}.xse";
2520 return "ldscripts/${EMULATION_NAME}.xs";
2524 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2526 else if (link_info.combreloc && link_info.relro
2527 && (link_info.flags & DF_BIND_NOW))
2529 if (link_info.separate_code)
2530 return "ldscripts/${EMULATION_NAME}.xwe";
2532 return "ldscripts/${EMULATION_NAME}.xw";
2534 else if (link_info.combreloc)
2536 if (link_info.separate_code)
2537 return "ldscripts/${EMULATION_NAME}.xce";
2539 return "ldscripts/${EMULATION_NAME}.xc";
2546 if (link_info.separate_code)
2547 return "ldscripts/${EMULATION_NAME}.xe";
2549 return "ldscripts/${EMULATION_NAME}.x";
2557 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
2559 $PARSE_AND_LIST_PROLOGUE
2567 OPTION_DISABLE_NEW_DTAGS = 400,
2568 OPTION_ENABLE_NEW_DTAGS,
2570 OPTION_EH_FRAME_HDR,
2571 OPTION_NO_EH_FRAME_HDR,
2572 OPTION_EXCLUDE_LIBS,
2576 OPTION_COMPRESS_DEBUG
2580 gld${EMULATION_NAME}_add_options
2581 (int ns, char **shortopts, int nl, struct option **longopts,
2582 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
2585 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2587 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:P:";
2591 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
2595 static const struct option xtra_long[] = {
2597 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2599 {"audit", required_argument, NULL, OPTION_AUDIT},
2600 {"Bgroup", no_argument, NULL, OPTION_GROUP},
2604 {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
2605 {"compress-debug-sections", required_argument, NULL, OPTION_COMPRESS_DEBUG},
2607 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2609 {"depaudit", required_argument, NULL, 'P'},
2610 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
2611 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
2612 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
2613 {"no-eh-frame-hdr", no_argument, NULL, OPTION_NO_EH_FRAME_HDR},
2614 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
2615 {"hash-style", required_argument, NULL, OPTION_HASH_STYLE},
2618 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
2620 $PARSE_AND_LIST_LONGOPTS
2624 {NULL, no_argument, NULL, 0}
2627 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
2628 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
2629 *longopts = (struct option *)
2630 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
2631 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
2634 #define DEFAULT_BUILD_ID_STYLE "sha1"
2637 gld${EMULATION_NAME}_handle_option (int optc)
2644 case OPTION_BUILD_ID:
2645 if (emit_note_gnu_build_id != NULL)
2647 free ((char *) emit_note_gnu_build_id);
2648 emit_note_gnu_build_id = NULL;
2651 optarg = DEFAULT_BUILD_ID_STYLE;
2652 if (strcmp (optarg, "none"))
2653 emit_note_gnu_build_id = xstrdup (optarg);
2656 case OPTION_COMPRESS_DEBUG:
2657 if (strcasecmp (optarg, "none") == 0)
2658 link_info.compress_debug = COMPRESS_DEBUG_NONE;
2659 else if (strcasecmp (optarg, "zlib") == 0)
2660 link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
2661 else if (strcasecmp (optarg, "zlib-gnu") == 0)
2662 link_info.compress_debug = COMPRESS_DEBUG_GNU_ZLIB;
2663 else if (strcasecmp (optarg, "zlib-gabi") == 0)
2664 link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
2666 einfo (_("%F%P: invalid --compress-debug-sections option: \`%s'\n"),
2671 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2674 gld${EMULATION_NAME}_append_to_separated_string (&audit, optarg);
2678 gld${EMULATION_NAME}_append_to_separated_string (&depaudit, optarg);
2681 case OPTION_DISABLE_NEW_DTAGS:
2682 link_info.new_dtags = FALSE;
2685 case OPTION_ENABLE_NEW_DTAGS:
2686 link_info.new_dtags = TRUE;
2689 case OPTION_EH_FRAME_HDR:
2690 link_info.eh_frame_hdr_type = DWARF2_EH_HDR;
2693 case OPTION_NO_EH_FRAME_HDR:
2694 link_info.eh_frame_hdr_type = 0;
2698 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
2699 /* Groups must be self-contained. */
2700 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2701 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
2704 case OPTION_EXCLUDE_LIBS:
2705 add_excluded_libs (optarg);
2708 case OPTION_HASH_STYLE:
2709 link_info.emit_hash = FALSE;
2710 link_info.emit_gnu_hash = FALSE;
2711 if (strcmp (optarg, "sysv") == 0)
2712 link_info.emit_hash = TRUE;
2713 else if (strcmp (optarg, "gnu") == 0)
2714 link_info.emit_gnu_hash = TRUE;
2715 else if (strcmp (optarg, "both") == 0)
2717 link_info.emit_hash = TRUE;
2718 link_info.emit_gnu_hash = TRUE;
2721 einfo (_("%F%P: invalid hash style \`%s'\n"), optarg);
2728 if (strcmp (optarg, "defs") == 0)
2729 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2730 else if (strcmp (optarg, "undefs") == 0)
2731 link_info.unresolved_syms_in_objects = RM_IGNORE;
2732 else if (strcmp (optarg, "muldefs") == 0)
2733 link_info.allow_multiple_definition = TRUE;
2734 else if (CONST_STRNEQ (optarg, "max-page-size="))
2738 config.maxpagesize = strtoul (optarg + 14, &end, 0);
2739 if (*end || (config.maxpagesize & (config.maxpagesize - 1)) != 0)
2740 einfo (_("%F%P: invalid maximum page size \`%s'\n"),
2743 else if (CONST_STRNEQ (optarg, "common-page-size="))
2746 config.commonpagesize = strtoul (optarg + 17, &end, 0);
2748 || (config.commonpagesize & (config.commonpagesize - 1)) != 0)
2749 einfo (_("%F%P: invalid common page size \`%s'\n"),
2752 else if (CONST_STRNEQ (optarg, "stack-size="))
2755 link_info.stacksize = strtoul (optarg + 11, &end, 0);
2756 if (*end || link_info.stacksize < 0)
2757 einfo (_("%F%P: invalid stack size \`%s'\n"), optarg + 11);
2758 if (!link_info.stacksize)
2759 /* Use -1 for explicit no-stack, because zero means
2761 link_info.stacksize = -1;
2763 else if (strcmp (optarg, "execstack") == 0)
2765 link_info.execstack = TRUE;
2766 link_info.noexecstack = FALSE;
2768 else if (strcmp (optarg, "noexecstack") == 0)
2770 link_info.noexecstack = TRUE;
2771 link_info.execstack = FALSE;
2773 else if (strcmp (optarg, "globalaudit") == 0)
2775 link_info.flags_1 |= DF_1_GLOBAUDIT;
2779 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2781 else if (strcmp (optarg, "global") == 0)
2782 link_info.flags_1 |= (bfd_vma) DF_1_GLOBAL;
2783 else if (strcmp (optarg, "initfirst") == 0)
2784 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
2785 else if (strcmp (optarg, "interpose") == 0)
2786 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
2787 else if (strcmp (optarg, "loadfltr") == 0)
2788 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
2789 else if (strcmp (optarg, "nodefaultlib") == 0)
2790 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
2791 else if (strcmp (optarg, "nodelete") == 0)
2792 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
2793 else if (strcmp (optarg, "nodlopen") == 0)
2794 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
2795 else if (strcmp (optarg, "nodump") == 0)
2796 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
2797 else if (strcmp (optarg, "now") == 0)
2799 link_info.flags |= (bfd_vma) DF_BIND_NOW;
2800 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
2802 else if (strcmp (optarg, "lazy") == 0)
2804 link_info.flags &= ~(bfd_vma) DF_BIND_NOW;
2805 link_info.flags_1 &= ~(bfd_vma) DF_1_NOW;
2807 else if (strcmp (optarg, "origin") == 0)
2809 link_info.flags |= (bfd_vma) DF_ORIGIN;
2810 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
2812 else if (strcmp (optarg, "combreloc") == 0)
2813 link_info.combreloc = TRUE;
2814 else if (strcmp (optarg, "nocombreloc") == 0)
2815 link_info.combreloc = FALSE;
2816 else if (strcmp (optarg, "nocopyreloc") == 0)
2817 link_info.nocopyreloc = TRUE;
2818 else if (strcmp (optarg, "relro") == 0)
2819 link_info.relro = TRUE;
2820 else if (strcmp (optarg, "norelro") == 0)
2821 link_info.relro = FALSE;
2822 else if (strcmp (optarg, "separate-code") == 0)
2823 link_info.separate_code = TRUE;
2824 else if (strcmp (optarg, "noseparate-code") == 0)
2825 link_info.separate_code = FALSE;
2826 else if (strcmp (optarg, "common") == 0)
2827 link_info.elf_stt_common = elf_stt_common;
2828 else if (strcmp (optarg, "nocommon") == 0)
2829 link_info.elf_stt_common = no_elf_stt_common;
2830 else if (strcmp (optarg, "text") == 0)
2831 link_info.error_textrel = TRUE;
2832 else if (strcmp (optarg, "notext") == 0)
2833 link_info.error_textrel = FALSE;
2834 else if (strcmp (optarg, "textoff") == 0)
2835 link_info.error_textrel = FALSE;
2839 if test -n "$PARSE_AND_LIST_ARGS_CASE_Z" ; then
2841 $PARSE_AND_LIST_ARGS_CASE_Z
2847 einfo (_("%P: warning: -z %s ignored\n"), optarg);
2851 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
2853 $PARSE_AND_LIST_ARGS_CASES
2865 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2866 gld_list_options="gld${EMULATION_NAME}_list_options"
2867 if test -n "$PARSE_AND_LIST_OPTIONS"; then
2871 gld${EMULATION_NAME}_list_options (FILE * file)
2875 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
2877 $PARSE_AND_LIST_OPTIONS
2885 gld_list_options="NULL"
2888 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
2890 $PARSE_AND_LIST_EPILOGUE
2897 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
2899 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
2900 ${LDEMUL_SYSLIB-syslib_default},
2901 ${LDEMUL_HLL-hll_default},
2902 ${LDEMUL_AFTER_PARSE-gld${EMULATION_NAME}_after_parse},
2903 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
2904 ${LDEMUL_AFTER_CHECK_RELOCS-after_check_relocs_default},
2905 ${LDEMUL_AFTER_ALLOCATION-gld${EMULATION_NAME}_after_allocation},
2906 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
2907 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
2908 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
2909 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
2910 "${EMULATION_NAME}",
2912 ${LDEMUL_FINISH-finish_default},
2913 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
2914 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
2915 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
2916 ${LDEMUL_SET_SYMBOLS-NULL},
2917 ${LDEMUL_PARSE_ARGS-NULL},
2918 gld${EMULATION_NAME}_add_options,
2919 gld${EMULATION_NAME}_handle_option,
2920 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
2921 ${LDEMUL_LIST_OPTIONS-${gld_list_options}},
2922 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
2923 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
2924 ${LDEMUL_NEW_VERS_PATTERN-NULL},
2925 ${LDEMUL_EXTRA_MAP_FILE_TEXT-NULL}