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-2016 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 = `if test "x${CHECK_RELOCS_AFTER_OPEN_INPUT}" = xyes ; then echo TRUE ; else echo FALSE ; fi`;
108 link_info.relro = DEFAULT_LD_Z_RELRO;
114 if test x"$LDEMUL_AFTER_PARSE" != xgld"$EMULATION_NAME"_after_parse; then
118 gld${EMULATION_NAME}_after_parse (void)
120 if (bfd_link_pie (&link_info))
121 link_info.flags_1 |= (bfd_vma) DF_1_PIE;
123 after_parse_default ();
129 if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
131 /* Handle the generation of DT_NEEDED tags. */
134 gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
138 /* Tell the ELF linker that we don't want the output file to have a
139 DT_NEEDED entry for this file, unless it is used to resolve
140 references in a regular object. */
141 if (entry->flags.add_DT_NEEDED_for_regular)
142 link_class = DYN_AS_NEEDED;
144 /* Tell the ELF linker that we don't want the output file to have a
145 DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
147 if (!entry->flags.add_DT_NEEDED_for_dynamic)
148 link_class |= DYN_NO_ADD_NEEDED;
150 if (entry->flags.just_syms
151 && (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) != 0)
152 einfo (_("%P%F: --just-symbols may not be used on DSO: %B\n"),
156 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
159 bfd_elf_set_dyn_lib_class (entry->the_bfd,
160 (enum dynamic_lib_link_class) link_class);
162 /* Continue on with normal load_symbols processing. */
170 /* These variables are required to pass information back and forth
171 between after_open and check_needed and stat_needed and vercheck. */
173 static struct bfd_link_needed_list *global_needed;
174 static struct stat global_stat;
175 static lang_input_statement_type *global_found;
176 static struct bfd_link_needed_list *global_vercheck_needed;
177 static bfd_boolean global_vercheck_failed;
179 /* These variables are used to implement target options */
181 static char *audit; /* colon (typically) separated list of libs */
182 static char *depaudit; /* colon (typically) separated list of libs */
184 /* Style of .note.gnu.build-id section. */
185 static const char *emit_note_gnu_build_id;
187 /* On Linux, it's possible to have different versions of the same
188 shared library linked against different versions of libc. The
189 dynamic linker somehow tags which libc version to use in
190 /etc/ld.so.cache, and, based on the libc that it sees in the
191 executable, chooses which version of the shared library to use.
193 We try to do a similar check here by checking whether this shared
194 library needs any other shared libraries which may conflict with
195 libraries we have already included in the link. If it does, we
196 skip it, and try to find another shared library farther on down the
199 This is called via lang_for_each_input_file.
200 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
201 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
202 a conflicting version. */
205 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
208 struct bfd_link_needed_list *l;
210 if (global_vercheck_failed)
212 if (s->the_bfd == NULL
213 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
216 soname = bfd_elf_get_dt_soname (s->the_bfd);
218 soname = lbasename (bfd_get_filename (s->the_bfd));
220 for (l = global_vercheck_needed; l != NULL; l = l->next)
224 if (filename_cmp (soname, l->name) == 0)
226 /* Probably can't happen, but it's an easy check. */
230 if (strchr (l->name, '/') != NULL)
233 suffix = strstr (l->name, ".so.");
237 suffix += sizeof ".so." - 1;
239 if (filename_ncmp (soname, l->name, suffix - l->name) == 0)
241 /* Here we know that S is a dynamic object FOO.SO.VER1, and
242 the object we are considering needs a dynamic object
243 FOO.SO.VER2, and VER1 and VER2 are different. This
244 appears to be a version mismatch, so we tell the caller
245 to try a different version of this library. */
246 global_vercheck_failed = TRUE;
253 /* See if an input file matches a DT_NEEDED entry by running stat on
257 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
263 if (global_found != NULL)
265 if (s->the_bfd == NULL)
268 /* If this input file was an as-needed entry, and wasn't found to be
269 needed at the stage it was linked, then don't say we have loaded it. */
270 if ((bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
273 if (bfd_stat (s->the_bfd, &st) != 0)
275 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
279 /* Some operating systems, e.g. Windows, do not provide a meaningful
280 st_ino; they always set it to zero. (Windows does provide a
281 meaningful st_dev.) Do not indicate a duplicate library in that
282 case. While there is no guarantee that a system that provides
283 meaningful inode numbers will never set st_ino to zero, this is
284 merely an optimization, so we do not need to worry about false
286 if (st.st_dev == global_stat.st_dev
287 && st.st_ino == global_stat.st_ino
294 /* We issue a warning if it looks like we are including two
295 different versions of the same shared library. For example,
296 there may be a problem if -lc picks up libc.so.6 but some other
297 shared library has a DT_NEEDED entry of libc.so.5. This is a
298 heuristic test, and it will only work if the name looks like
299 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
300 If we really want to issue warnings about mixing version numbers
301 of shared libraries, we need to find a better way. */
303 if (strchr (global_needed->name, '/') != NULL)
305 suffix = strstr (global_needed->name, ".so.");
308 suffix += sizeof ".so." - 1;
310 soname = bfd_elf_get_dt_soname (s->the_bfd);
312 soname = lbasename (s->filename);
314 if (filename_ncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
315 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
316 global_needed->name, global_needed->by, soname);
325 /* This function is called for each possible name for a dynamic object
326 named by a DT_NEEDED entry. The FORCE parameter indicates whether
327 to skip the check for a conflicting version. */
330 gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
334 const char *name = needed->name;
338 abfd = bfd_openr (name, bfd_get_target (link_info.output_bfd));
342 /* Linker needs to decompress sections. */
343 abfd->flags |= BFD_DECOMPRESS;
345 if (! bfd_check_format (abfd, bfd_object))
350 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
356 /* For DT_NEEDED, they have to match. */
357 if (abfd->xvec != link_info.output_bfd->xvec)
363 /* Check whether this object would include any conflicting library
364 versions. If FORCE is set, then we skip this check; we use this
365 the second time around, if we couldn't find any compatible
366 instance of the shared library. */
370 struct bfd_link_needed_list *needs;
372 if (! bfd_elf_get_bfd_needed_list (abfd, &needs))
373 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
377 global_vercheck_needed = needs;
378 global_vercheck_failed = FALSE;
379 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
380 if (global_vercheck_failed)
383 /* Return FALSE to force the caller to move on to try
384 another file on the search path. */
388 /* But wait! It gets much worse. On Linux, if a shared
389 library does not use libc at all, we are supposed to skip
390 it the first time around in case we encounter a shared
391 library later on with the same name which does use the
392 version of libc that we want. This is much too horrible
393 to use on any system other than Linux. */
397 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
400 struct bfd_link_needed_list *l;
402 for (l = needs; l != NULL; l = l->next)
403 if (CONST_STRNEQ (l->name, "libc.so"))
419 /* We've found a dynamic object matching the DT_NEEDED entry. */
421 /* We have already checked that there is no other input file of the
422 same name. We must now check again that we are not including the
423 same file twice. We need to do this because on many systems
424 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
425 reference libc.so.1. If we have already included libc.so, we
426 don't want to include libc.so.1 if they are the same file, and we
427 can only check that using stat. */
429 if (bfd_stat (abfd, &global_stat) != 0)
430 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
432 /* First strip off everything before the last '/'. */
433 soname = lbasename (abfd->filename);
436 info_msg (_("found %s at %s\n"), soname, name);
439 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
440 if (global_found != NULL)
442 /* Return TRUE to indicate that we found the file, even though
443 we aren't going to do anything with it. */
447 /* Specify the soname to use. */
448 bfd_elf_set_dt_needed_name (abfd, soname);
450 /* Tell the ELF linker that we don't want the output file to have a
451 DT_NEEDED entry for this file, unless it is used to resolve
452 references in a regular object. */
453 link_class = DYN_DT_NEEDED;
455 /* Tell the ELF linker that we don't want the output file to have a
456 DT_NEEDED entry for this file at all if the entry is from a file
457 with DYN_NO_ADD_NEEDED. */
458 if (needed->by != NULL
459 && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
460 link_class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
462 bfd_elf_set_dyn_lib_class (abfd, (enum dynamic_lib_link_class) link_class);
464 /* Add this file into the symbol table. */
465 if (! bfd_link_add_symbols (abfd, &link_info))
466 einfo ("%F%B: error adding symbols: %E\n", abfd);
472 /* Search for a needed file in a path. */
475 gld${EMULATION_NAME}_search_needed (const char *path,
476 struct dt_needed *n, int force)
479 const char *name = n->name;
481 struct dt_needed needed;
484 return gld${EMULATION_NAME}_try_needed (n, force);
486 if (path == NULL || *path == '\0')
490 needed.name = n->name;
495 char *filename, *sset;
497 s = strchr (path, config.rpath_separator);
499 s = path + strlen (path);
501 #if HAVE_DOS_BASED_FILE_SYSTEM
502 /* Assume a match on the second char is part of drive specifier. */
503 else if (config.rpath_separator == ':'
507 s = strchr (s + 1, config.rpath_separator);
509 s = path + strlen (path);
512 filename = (char *) xmalloc (s - path + len + 2);
517 memcpy (filename, path, s - path);
518 filename[s - path] = '/';
519 sset = filename + (s - path) + 1;
523 needed.name = filename;
524 if (gld${EMULATION_NAME}_try_needed (&needed, force))
538 if [ "x${USE_LIBPATH}" = xyes ] ; then
541 /* Add the sysroot to every entry in a path separated by
542 config.rpath_separator. */
545 gld${EMULATION_NAME}_add_sysroot (const char *path)
554 if (path[i++] == config.rpath_separator)
560 len = len + (colons + 1) * strlen (ld_sysroot);
561 ret = xmalloc (len + 1);
562 strcpy (ret, ld_sysroot);
563 p = ret + strlen (ret);
566 if (path[i] == config.rpath_separator)
569 strcpy (p, ld_sysroot);
581 *-*-freebsd* | *-*-dragonfly*)
583 /* Read the system search path the FreeBSD way rather than the Linux way. */
584 #ifdef HAVE_ELF_HINTS_H
585 #include <elf-hints.h>
587 #include "elf-hints-local.h"
591 gld${EMULATION_NAME}_check_ld_elf_hints (const struct bfd_link_needed_list *l,
594 static bfd_boolean initialized;
595 static char *ld_elf_hints;
596 struct dt_needed needed;
603 tmppath = concat (ld_sysroot, _PATH_ELF_HINTS, (const char *) NULL);
604 f = fopen (tmppath, FOPEN_RB);
608 struct elfhints_hdr hdr;
610 if (fread (&hdr, 1, sizeof (hdr), f) == sizeof (hdr)
611 && hdr.magic == ELFHINTS_MAGIC
614 if (fseek (f, hdr.strtab + hdr.dirlist, SEEK_SET) != -1)
618 b = xmalloc (hdr.dirlistlen + 1);
619 if (fread (b, 1, hdr.dirlistlen + 1, f) ==
621 ld_elf_hints = gld${EMULATION_NAME}_add_sysroot (b);
632 if (ld_elf_hints == NULL)
636 needed.name = l->name;
637 return gld${EMULATION_NAME}_search_needed (ld_elf_hints, &needed, force);
643 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
645 /* For a native linker, check the file /etc/ld.so.conf for directories
646 in which we may find shared libraries. /etc/ld.so.conf is really
647 only meaningful on Linux. */
649 struct gld${EMULATION_NAME}_ld_so_conf
656 gld${EMULATION_NAME}_parse_ld_so_conf
657 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
660 gld${EMULATION_NAME}_parse_ld_so_conf_include
661 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
669 if (pattern[0] != '/')
671 char *p = strrchr (filename, '/');
672 size_t patlen = strlen (pattern) + 1;
674 newp = xmalloc (p - filename + 1 + patlen);
675 memcpy (newp, filename, p - filename + 1);
676 memcpy (newp + (p - filename + 1), pattern, patlen);
681 if (glob (pattern, 0, NULL, &gl) == 0)
685 for (i = 0; i < gl.gl_pathc; ++i)
686 gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
690 /* If we do not have glob, treat the pattern as a literal filename. */
691 gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
699 gld${EMULATION_NAME}_parse_ld_so_conf
700 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
702 FILE *f = fopen (filename, FOPEN_RT);
710 line = xmalloc (linelen);
715 /* Normally this would use getline(3), but we need to be portable. */
716 while ((q = fgets (p, linelen - (p - line), f)) != NULL
717 && strlen (q) == linelen - (p - line) - 1
718 && line[linelen - 2] != '\n')
720 line = xrealloc (line, 2 * linelen);
721 p = line + linelen - 1;
725 if (q == NULL && p == line)
728 p = strchr (line, '\n');
732 /* Because the file format does not know any form of quoting we
733 can search forward for the next '#' character and if found
734 make it terminating the line. */
735 p = strchr (line, '#');
739 /* Remove leading whitespace. NUL is no whitespace character. */
741 while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
744 /* If the line is blank it is ignored. */
748 if (CONST_STRNEQ (p, "include") && (p[7] == ' ' || p[7] == '\t'))
754 while (*p == ' ' || *p == '\t')
762 while (*p != ' ' && *p != '\t' && *p)
768 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
776 while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
777 && *p != '\r' && *p != '\v')
780 while (p != dir && p[-1] == '/')
782 if (info->path == NULL)
784 info->alloc = p - dir + 1 + 256;
785 info->path = xmalloc (info->alloc);
790 if (info->len + 1 + (p - dir) >= info->alloc)
792 info->alloc += p - dir + 256;
793 info->path = xrealloc (info->path, info->alloc);
795 info->path[info->len++] = config.rpath_separator;
797 memcpy (info->path + info->len, dir, p - dir);
798 info->len += p - dir;
799 info->path[info->len] = '\0';
809 gld${EMULATION_NAME}_check_ld_so_conf (const struct bfd_link_needed_list *l,
812 static bfd_boolean initialized;
813 static char *ld_so_conf;
814 struct dt_needed needed;
819 struct gld${EMULATION_NAME}_ld_so_conf info;
822 info.len = info.alloc = 0;
823 tmppath = concat (ld_sysroot, "${prefix}/etc/ld.so.conf",
824 (const char *) NULL);
825 if (!gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath))
828 tmppath = concat (ld_sysroot, "/etc/ld.so.conf",
829 (const char *) NULL);
830 gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
836 char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
843 if (ld_so_conf == NULL)
848 needed.name = l->name;
849 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
859 /* See if an input file matches a DT_NEEDED entry by name. */
862 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
866 /* Stop looking if we've found a loaded lib. */
867 if (global_found != NULL
868 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
869 & DYN_AS_NEEDED) == 0)
872 if (s->filename == NULL || s->the_bfd == NULL)
875 /* Don't look for a second non-loaded as-needed lib. */
876 if (global_found != NULL
877 && (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
880 if (filename_cmp (s->filename, global_needed->name) == 0)
886 if (s->flags.search_dirs)
888 const char *f = strrchr (s->filename, '/');
890 && filename_cmp (f + 1, global_needed->name) == 0)
897 soname = bfd_elf_get_dt_soname (s->the_bfd);
899 && filename_cmp (soname, global_needed->name) == 0)
908 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
912 id_note_section_size (bfd *abfd ATTRIBUTE_UNUSED)
914 const char *style = emit_note_gnu_build_id;
916 bfd_size_type build_id_size;
918 size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
919 size = (size + 3) & -(bfd_size_type) 4;
921 build_id_size = compute_build_id_size (style);
923 size += build_id_size;
931 write_build_id (bfd *abfd)
933 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
934 struct elf_obj_tdata *t = elf_tdata (abfd);
937 Elf_Internal_Shdr *i_shdr;
938 unsigned char *contents, *id_bits;
941 Elf_External_Note *e_note;
943 style = t->o->build_id.style;
944 asec = t->o->build_id.sec;
945 if (bfd_is_abs_section (asec->output_section))
947 einfo (_("%P: warning: .note.gnu.build-id section discarded,"
948 " --build-id ignored.\n"));
951 i_shdr = &elf_section_data (asec->output_section)->this_hdr;
953 if (i_shdr->contents == NULL)
955 if (asec->contents == NULL)
956 asec->contents = (unsigned char *) xmalloc (asec->size);
957 contents = asec->contents;
960 contents = i_shdr->contents + asec->output_offset;
962 e_note = (Elf_External_Note *) contents;
963 size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
964 size = (size + 3) & -(bfd_size_type) 4;
965 id_bits = contents + size;
966 size = asec->size - size;
968 bfd_h_put_32 (abfd, sizeof "GNU", &e_note->namesz);
969 bfd_h_put_32 (abfd, size, &e_note->descsz);
970 bfd_h_put_32 (abfd, NT_GNU_BUILD_ID, &e_note->type);
971 memcpy (e_note->name, "GNU", sizeof "GNU");
973 generate_build_id (abfd, style, bed->s->checksum_contents, id_bits, size);
975 position = i_shdr->sh_offset + asec->output_offset;
977 return (bfd_seek (abfd, position, SEEK_SET) == 0
978 && bfd_bwrite (contents, size, abfd) == size);
981 /* Make .note.gnu.build-id section, and set up elf_tdata->build_id. */
984 setup_build_id (bfd *ibfd)
990 size = id_note_section_size (ibfd);
993 einfo ("%P: warning: unrecognized --build-id style ignored.\n");
997 flags = (SEC_ALLOC | SEC_LOAD | SEC_IN_MEMORY
998 | SEC_LINKER_CREATED | SEC_READONLY | SEC_DATA);
999 s = bfd_make_section_with_flags (ibfd, ".note.gnu.build-id", flags);
1000 if (s != NULL && bfd_set_section_alignment (ibfd, s, 2))
1002 struct elf_obj_tdata *t = elf_tdata (link_info.output_bfd);
1003 t->o->build_id.after_write_object_contents = &write_build_id;
1004 t->o->build_id.style = emit_note_gnu_build_id;
1005 t->o->build_id.sec = s;
1006 elf_section_type (s) = SHT_NOTE;
1011 einfo ("%P: warning: Cannot create .note.gnu.build-id section,"
1012 " --build-id ignored.\n");
1016 /* This is called after all the input files have been opened. */
1019 gld${EMULATION_NAME}_after_open (void)
1021 struct bfd_link_needed_list *needed, *l;
1022 struct elf_link_hash_table *htab;
1024 after_open_default ();
1026 htab = elf_hash_table (&link_info);
1027 if (!is_elf_hash_table (htab))
1030 if (command_line.out_implib_filename)
1032 unlink_if_ordinary (command_line.out_implib_filename);
1033 link_info.out_implib_bfd
1034 = bfd_openw (command_line.out_implib_filename,
1035 bfd_get_target (link_info.output_bfd));
1037 if (link_info.out_implib_bfd == NULL)
1039 einfo ("%F%s: Can't open for writing: %E\n",
1040 command_line.out_implib_filename);
1044 if (emit_note_gnu_build_id != NULL)
1048 /* Find an ELF input. */
1049 for (abfd = link_info.input_bfds;
1050 abfd != (bfd *) NULL; abfd = abfd->link.next)
1051 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1052 && bfd_count_sections (abfd) != 0)
1055 /* PR 10555: If there are no ELF input files do not try to
1056 create a .note.gnu-build-id section. */
1058 || !setup_build_id (abfd))
1060 free ((char *) emit_note_gnu_build_id);
1061 emit_note_gnu_build_id = NULL;
1065 if (bfd_link_relocatable (&link_info))
1067 if (link_info.execstack == ! link_info.noexecstack)
1068 /* PR ld/16744: If "-z [no]execstack" has been specified on the
1069 command line and we are perfoming a relocatable link then no
1070 PT_GNU_STACK segment will be created and so the
1071 linkinfo.[no]execstack values set in _handle_option() will have no
1072 effect. Instead we create a .note.GNU-stack section in much the
1073 same way as the assembler does with its --[no]execstack option. */
1074 (void) bfd_make_section_with_flags (link_info.input_bfds,
1076 SEC_READONLY | (link_info.execstack ? SEC_CODE : 0));
1081 if (!link_info.traditional_format)
1083 bfd *abfd, *elfbfd = NULL;
1084 bfd_boolean warn_eh_frame = FALSE;
1088 for (abfd = link_info.input_bfds; abfd; abfd = abfd->link.next)
1091 for (s = abfd->sections; s && type < COMPACT_EH_HDR; s = s->next)
1093 const char *name = bfd_get_section_name (abfd, s);
1095 if (bfd_is_abs_section (s->output_section))
1097 if (CONST_STRNEQ (name, ".eh_frame_entry"))
1098 type = COMPACT_EH_HDR;
1099 else if (strcmp (name, ".eh_frame") == 0 && s->size > 8)
1100 type = DWARF2_EH_HDR;
1109 else if (seen_type != type)
1111 einfo (_("%P%F: compact frame descriptions incompatible with"
1112 " DWARF2 .eh_frame from %B\n"),
1113 type == DWARF2_EH_HDR ? abfd : elfbfd);
1118 && (type == COMPACT_EH_HDR || link_info.eh_frame_hdr_type != 0))
1120 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1123 warn_eh_frame = TRUE;
1127 if (seen_type == COMPACT_EH_HDR)
1128 link_info.eh_frame_hdr_type = COMPACT_EH_HDR;
1130 if (bfd_count_sections (abfd) == 0)
1135 const struct elf_backend_data *bed;
1137 bed = get_elf_backend_data (elfbfd);
1138 s = bfd_make_section_with_flags (elfbfd, ".eh_frame_hdr",
1139 bed->dynamic_sec_flags
1142 && bfd_set_section_alignment (elfbfd, s, 2))
1144 htab->eh_info.hdr_sec = s;
1145 warn_eh_frame = FALSE;
1149 einfo ("%P: warning: Cannot create .eh_frame_hdr section,"
1150 " --eh-frame-hdr ignored.\n");
1153 /* Get the list of files which appear in DT_NEEDED entries in
1154 dynamic objects included in the link (often there will be none).
1155 For each such file, we want to track down the corresponding
1156 library, and include the symbol table in the link. This is what
1157 the runtime dynamic linker will do. Tracking the files down here
1158 permits one dynamic object to include another without requiring
1159 special action by the person doing the link. Note that the
1160 needed list can actually grow while we are stepping through this
1162 needed = bfd_elf_get_needed_list (link_info.output_bfd, &link_info);
1163 for (l = needed; l != NULL; l = l->next)
1165 struct bfd_link_needed_list *ll;
1166 struct dt_needed n, nn;
1169 /* If the lib that needs this one was --as-needed and wasn't
1170 found to be needed, then this lib isn't needed either. */
1172 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
1175 /* Skip the lib if --no-copy-dt-needed-entries and
1176 --allow-shlib-undefined is in effect. */
1178 && link_info.unresolved_syms_in_shared_libs == RM_IGNORE
1179 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_NO_ADD_NEEDED) != 0)
1182 /* If we've already seen this file, skip it. */
1183 for (ll = needed; ll != l; ll = ll->next)
1185 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
1186 && strcmp (ll->name, l->name) == 0)
1191 /* See if this file was included in the link explicitly. */
1193 global_found = NULL;
1194 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
1195 if (global_found != NULL
1196 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
1197 & DYN_AS_NEEDED) == 0)
1204 info_msg (_("%s needed by %B\n"), l->name, l->by);
1206 /* As-needed libs specified on the command line (or linker script)
1207 take priority over libs found in search dirs. */
1208 if (global_found != NULL)
1210 nn.name = global_found->filename;
1211 if (gld${EMULATION_NAME}_try_needed (&nn, TRUE))
1215 /* We need to find this file and include the symbol table. We
1216 want to search for the file in the same way that the dynamic
1217 linker will search. That means that we want to use
1218 rpath_link, rpath, then the environment variable
1219 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
1220 entries (native only), then the linker script LIB_SEARCH_DIRS.
1221 We do not search using the -L arguments.
1223 We search twice. The first time, we skip objects which may
1224 introduce version mismatches. The second time, we force
1225 their use. See gld${EMULATION_NAME}_vercheck comment. */
1226 for (force = 0; force < 2; force++)
1229 search_dirs_type *search;
1231 if [ "x${NATIVE}" = xyes ] ; then
1233 const char *lib_path;
1236 if [ "x${USE_LIBPATH}" = xyes ] ; then
1238 struct bfd_link_needed_list *rp;
1244 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
1248 if [ "x${USE_LIBPATH}" = xyes ] ; then
1250 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
1255 if [ "x${NATIVE}" = xyes ] ; then
1257 if (command_line.rpath_link == NULL
1258 && command_line.rpath == NULL)
1260 lib_path = (const char *) getenv ("LD_RUN_PATH");
1261 if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
1265 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
1266 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
1270 if [ "x${USE_LIBPATH}" = xyes ] ; then
1273 rp = bfd_elf_get_runpath_list (link_info.output_bfd, &link_info);
1274 for (; !found && rp != NULL; rp = rp->next)
1276 const char *tmpname = rp->name;
1278 if (IS_ABSOLUTE_PATH (tmpname))
1279 tmpname = gld${EMULATION_NAME}_add_sysroot (tmpname);
1280 found = (rp->by == l->by
1281 && gld${EMULATION_NAME}_search_needed (tmpname,
1284 if (tmpname != rp->name)
1285 free ((char *) tmpname);
1292 if [ "x${USE_LIBPATH}" = xyes ] ; then
1294 *-*-freebsd* | *-*-dragonfly*)
1296 if (gld${EMULATION_NAME}_check_ld_elf_hints (l, force))
1302 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
1304 if (gld${EMULATION_NAME}_check_ld_so_conf (l, force))
1313 len = strlen (l->name);
1314 for (search = search_head; search != NULL; search = search->next)
1318 if (search->cmdline)
1320 filename = (char *) xmalloc (strlen (search->name) + len + 2);
1321 sprintf (filename, "%s/%s", search->name, l->name);
1323 if (gld${EMULATION_NAME}_try_needed (&nn, force))
1336 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
1340 if (link_info.eh_frame_hdr_type == COMPACT_EH_HDR)
1341 if (bfd_elf_parse_eh_frame_entries (NULL, &link_info) == FALSE)
1342 einfo (_("%P%F: Failed to parse EH frame entries.\n"));
1350 /* Look through an expression for an assignment statement. */
1353 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1355 bfd_boolean provide = FALSE;
1357 switch (exp->type.node_class)
1360 case etree_provided:
1364 /* We call record_link_assignment even if the symbol is defined.
1365 This is because if it is defined by a dynamic object, we
1366 actually want to use the value defined by the linker script,
1367 not the value from the dynamic object (because we are setting
1368 symbols like etext). If the symbol is defined by a regular
1369 object, then, as it happens, calling record_link_assignment
1371 if (strcmp (exp->assign.dst, ".") != 0)
1373 if (!bfd_elf_record_link_assignment (link_info.output_bfd,
1375 exp->assign.dst, provide,
1376 exp->assign.hidden))
1377 einfo ("%P%F: failed to record assignment to %s: %E\n",
1380 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1384 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1385 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1389 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1390 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1391 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1395 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1404 /* This is called by the before_allocation routine via
1405 lang_for_each_statement. It locates any assignment statements, and
1406 tells the ELF backend about them, in case they are assignments to
1407 symbols which are referred to by dynamic objects. */
1410 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1412 if (s->header.type == lang_assignment_statement_enum)
1413 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1418 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1419 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1420 ELF_INTERPRETER_SET_DEFAULT="
1421 if (sinterp != NULL)
1423 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1424 sinterp->size = strlen ((char *) sinterp->contents) + 1;
1429 ELF_INTERPRETER_SET_DEFAULT=
1433 /* used by before_allocation and handle_option. */
1435 gld${EMULATION_NAME}_append_to_separated_string (char **to, char *op_arg)
1438 *to = xstrdup (op_arg);
1441 size_t to_len = strlen (*to);
1442 size_t op_arg_len = strlen (op_arg);
1446 /* First see whether OPTARG is already in the path. */
1449 if (strncmp (op_arg, cp, op_arg_len) == 0
1450 && (cp[op_arg_len] == 0
1451 || cp[op_arg_len] == config.rpath_separator))
1455 /* Not yet found. */
1456 cp = strchr (cp, config.rpath_separator);
1464 buf = xmalloc (to_len + op_arg_len + 2);
1465 sprintf (buf, "%s%c%s", *to,
1466 config.rpath_separator, op_arg);
1473 #if defined(__GNUC__) && GCC_VERSION < 4006
1474 /* Work around a GCC uninitialized warning bug fixed in GCC 4.6. */
1475 static struct bfd_link_hash_entry ehdr_start_empty;
1478 /* This is called after the sections have been attached to output
1479 sections, but before any sizes or addresses have been set. */
1482 gld${EMULATION_NAME}_before_allocation (void)
1487 struct elf_link_hash_entry *ehdr_start = NULL;
1488 #if defined(__GNUC__) && GCC_VERSION < 4006
1489 /* Work around a GCC uninitialized warning bug fixed in GCC 4.6. */
1490 struct bfd_link_hash_entry ehdr_start_save = ehdr_start_empty;
1492 struct bfd_link_hash_entry ehdr_start_save;
1495 if (is_elf_hash_table (link_info.hash))
1497 _bfd_elf_tls_setup (link_info.output_bfd, &link_info);
1499 /* Make __ehdr_start hidden if it has been referenced, to
1500 prevent the symbol from being dynamic. */
1501 if (!bfd_link_relocatable (&link_info))
1503 struct elf_link_hash_entry *h
1504 = elf_link_hash_lookup (elf_hash_table (&link_info), "__ehdr_start",
1505 FALSE, FALSE, TRUE);
1507 /* Only adjust the export class if the symbol was referenced
1508 and not defined, otherwise leave it alone. */
1510 && (h->root.type == bfd_link_hash_new
1511 || h->root.type == bfd_link_hash_undefined
1512 || h->root.type == bfd_link_hash_undefweak
1513 || h->root.type == bfd_link_hash_common))
1515 _bfd_elf_link_hash_hide_symbol (&link_info, h, TRUE);
1516 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
1517 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
1518 /* Don't leave the symbol undefined. Undefined hidden
1519 symbols typically won't have dynamic relocations, but
1520 we most likely will need dynamic relocations for
1521 __ehdr_start if we are building a PIE or shared
1524 ehdr_start_save = h->root;
1525 h->root.type = bfd_link_hash_defined;
1526 h->root.u.def.section = bfd_abs_section_ptr;
1527 h->root.u.def.value = 0;
1531 /* If we are going to make any variable assignments, we need to
1532 let the ELF backend know about them in case the variables are
1533 referred to by dynamic objects. */
1534 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1537 /* Let the ELF backend work out the sizes of any sections required
1538 by dynamic linking. */
1539 rpath = command_line.rpath;
1541 rpath = (const char *) getenv ("LD_RUN_PATH");
1543 for (abfd = link_info.input_bfds; abfd; abfd = abfd->link.next)
1544 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1546 const char *audit_libs = elf_dt_audit (abfd);
1548 /* If the input bfd contains an audit entry, we need to add it as
1549 a dep audit entry. */
1550 if (audit_libs && *audit_libs != '\0')
1552 char *cp = xstrdup (audit_libs);
1556 char *cp2 = strchr (cp, config.rpath_separator);
1564 if (cp != NULL && *cp != '\0')
1565 gld${EMULATION_NAME}_append_to_separated_string (&depaudit, cp);
1567 cp = more ? ++cp2 : NULL;
1573 if (! (bfd_elf_size_dynamic_sections
1574 (link_info.output_bfd, command_line.soname, rpath,
1575 command_line.filter_shlib, audit, depaudit,
1576 (const char * const *) command_line.auxiliary_filters,
1577 &link_info, &sinterp)))
1578 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1580 ${ELF_INTERPRETER_SET_DEFAULT}
1581 /* Let the user override the dynamic linker we are using. */
1582 if (command_line.interpreter != NULL
1585 sinterp->contents = (bfd_byte *) command_line.interpreter;
1586 sinterp->size = strlen (command_line.interpreter) + 1;
1589 /* Look for any sections named .gnu.warning. As a GNU extensions,
1590 we treat such sections as containing warning messages. We print
1591 out the warning message, and then zero out the section size so
1592 that it does not get copied into the output file. */
1595 LANG_FOR_EACH_INPUT_STATEMENT (is)
1601 if (is->flags.just_syms)
1604 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1609 msg = (char *) xmalloc ((size_t) (sz + 1));
1610 if (! bfd_get_section_contents (is->the_bfd, s, msg,
1612 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1615 (*link_info.callbacks->warning) (&link_info, msg,
1616 (const char *) NULL, is->the_bfd,
1617 (asection *) NULL, (bfd_vma) 0);
1620 /* Clobber the section size, so that we don't waste space
1621 copying the warning into the output file. If we've already
1622 sized the output section, adjust its size. The adjustment
1623 is on rawsize because targets that size sections early will
1624 have called lang_reset_memory_regions after sizing. */
1625 if (s->output_section != NULL
1626 && s->output_section->rawsize >= s->size)
1627 s->output_section->rawsize -= s->size;
1631 /* Also set SEC_EXCLUDE, so that local symbols defined in the
1632 warning section don't get copied to the output. */
1633 s->flags |= SEC_EXCLUDE | SEC_KEEP;
1637 before_allocation_default ();
1639 if (!bfd_elf_size_dynsym_hash_dynstr (link_info.output_bfd, &link_info))
1640 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1642 if (ehdr_start != NULL)
1644 /* If we twiddled __ehdr_start to defined earlier, put it back
1646 ehdr_start->root.type = ehdr_start_save.type;
1647 ehdr_start->root.u = ehdr_start_save.u;
1654 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1657 /* Try to open a dynamic archive. This is where we know that ELF
1658 dynamic libraries have an extension of .so (or .sl on oddball systems
1662 gld${EMULATION_NAME}_open_dynamic_archive
1663 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1665 const char *filename;
1668 bfd_boolean opened = FALSE;
1670 if (! entry->flags.maybe_archive)
1673 filename = entry->filename;
1674 len = strlen (search->name) + strlen (filename);
1675 if (entry->flags.full_name_provided)
1678 string = (char *) xmalloc (len);
1679 sprintf (string, "%s/%s", search->name, filename);
1685 len += strlen (arch) + sizeof "/lib.so";
1686 #ifdef EXTRA_SHLIB_EXTENSION
1687 xlen = (strlen (EXTRA_SHLIB_EXTENSION) > 3
1688 ? strlen (EXTRA_SHLIB_EXTENSION) - 3
1691 string = (char *) xmalloc (len + xlen);
1692 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1693 #ifdef EXTRA_SHLIB_EXTENSION
1694 /* Try the .so extension first. If that fails build a new filename
1695 using EXTRA_SHLIB_EXTENSION. */
1696 opened = ldfile_try_open_bfd (string, entry);
1698 strcpy (string + len - 4, EXTRA_SHLIB_EXTENSION);
1702 if (!opened && !ldfile_try_open_bfd (string, entry))
1708 entry->filename = string;
1710 /* We have found a dynamic object to include in the link. The ELF
1711 backend linker will create a DT_NEEDED entry in the .dynamic
1712 section naming this file. If this file includes a DT_SONAME
1713 entry, it will be used. Otherwise, the ELF linker will just use
1714 the name of the file. For an archive found by searching, like
1715 this one, the DT_NEEDED entry should consist of just the name of
1716 the file, without the path information used to find it. Note
1717 that we only need to do this if we have a dynamic object; an
1718 archive will never be referenced by a DT_NEEDED entry.
1720 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1721 very pretty. I haven't been able to think of anything that is
1723 if (bfd_check_format (entry->the_bfd, bfd_object)
1724 && (entry->the_bfd->flags & DYNAMIC) != 0)
1726 ASSERT (entry->flags.maybe_archive && entry->flags.search_dirs);
1728 /* Rather than duplicating the logic above. Just use the
1729 filename we recorded earlier. */
1731 if (!entry->flags.full_name_provided)
1732 filename = lbasename (entry->filename);
1733 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1742 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1745 /* A variant of lang_output_section_find used by place_orphan. */
1747 static lang_output_section_statement_type *
1748 output_rel_find (asection *sec, int isdyn)
1750 lang_output_section_statement_type *lookup;
1751 lang_output_section_statement_type *last = NULL;
1752 lang_output_section_statement_type *last_alloc = NULL;
1753 lang_output_section_statement_type *last_ro_alloc = NULL;
1754 lang_output_section_statement_type *last_rel = NULL;
1755 lang_output_section_statement_type *last_rel_alloc = NULL;
1756 int rela = sec->name[4] == 'a';
1758 for (lookup = &lang_output_section_statement.head->output_section_statement;
1760 lookup = lookup->next)
1762 if (lookup->constraint >= 0
1763 && CONST_STRNEQ (lookup->name, ".rel"))
1765 int lookrela = lookup->name[4] == 'a';
1767 /* .rel.dyn must come before all other reloc sections, to suit
1772 /* Don't place after .rel.plt as doing so results in wrong
1774 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1777 if (rela == lookrela || last_rel == NULL)
1779 if ((rela == lookrela || last_rel_alloc == NULL)
1780 && lookup->bfd_section != NULL
1781 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1782 last_rel_alloc = lookup;
1786 if (lookup->bfd_section != NULL
1787 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1789 last_alloc = lookup;
1790 if ((lookup->bfd_section->flags & SEC_READONLY) != 0)
1791 last_ro_alloc = lookup;
1796 return last_rel_alloc;
1802 return last_ro_alloc;
1810 /* Place an orphan section. We use this to put random SHF_ALLOC
1811 sections in the right segment. */
1813 static lang_output_section_statement_type *
1814 gld${EMULATION_NAME}_place_orphan (asection *s,
1815 const char *secname,
1818 static struct orphan_save hold[] =
1821 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1824 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1827 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_THREAD_LOCAL,
1830 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1836 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1839 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1842 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1848 enum orphan_save_index
1860 static int orphan_init_done = 0;
1861 struct orphan_save *place;
1862 lang_output_section_statement_type *after;
1863 lang_output_section_statement_type *os;
1864 lang_output_section_statement_type *match_by_name = NULL;
1866 int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1867 unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
1871 if (!bfd_link_relocatable (&link_info)
1872 && link_info.combreloc
1873 && (s->flags & SEC_ALLOC))
1879 secname = ".rela.dyn";
1883 secname = ".rel.dyn";
1889 else if (CONST_STRNEQ (secname, ".rel"))
1891 secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1896 /* Look through the script to see where to place this section. */
1897 if (constraint == 0)
1898 for (os = lang_output_section_find (secname);
1900 os = next_matching_output_section_statement (os, 0))
1902 /* If we don't match an existing output section, tell
1903 lang_insert_orphan to create a new output section. */
1904 constraint = SPECIAL;
1906 if (os->bfd_section != NULL
1907 && (os->bfd_section->flags == 0
1908 || (((s->flags ^ os->bfd_section->flags)
1909 & (SEC_LOAD | SEC_ALLOC)) == 0
1910 && _bfd_elf_match_sections_by_type (link_info.output_bfd,
1914 /* We already have an output section statement with this
1915 name, and its bfd section has compatible flags.
1916 If the section already exists but does not have any flags
1917 set, then it has been created by the linker, probably as a
1918 result of a --section-start command line switch. */
1919 lang_add_section (&os->children, s, NULL, os);
1923 /* Save unused output sections in case we can match them
1924 against orphans later. */
1925 if (os->bfd_section == NULL)
1929 /* If we didn't match an active output section, see if we matched an
1930 unused one and use that. */
1933 lang_add_section (&match_by_name->children, s, NULL, match_by_name);
1934 return match_by_name;
1937 if (!orphan_init_done)
1939 struct orphan_save *ho;
1941 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1942 if (ho->name != NULL)
1944 ho->os = lang_output_section_find (ho->name);
1945 if (ho->os != NULL && ho->os->flags == 0)
1946 ho->os->flags = ho->flags;
1948 orphan_init_done = 1;
1951 /* If this is a final link, then always put .gnu.warning.SYMBOL
1952 sections into the .text section to get them out of the way. */
1953 if (bfd_link_executable (&link_info)
1954 && CONST_STRNEQ (s->name, ".gnu.warning.")
1955 && hold[orphan_text].os != NULL)
1957 os = hold[orphan_text].os;
1958 lang_add_section (&os->children, s, NULL, os);
1963 if (!bfd_link_relocatable (&link_info))
1966 while ((nexts = bfd_get_next_section_by_name (nexts->owner, nexts))
1968 if (nexts->output_section == NULL
1969 && (nexts->flags & SEC_EXCLUDE) == 0
1970 && ((nexts->flags ^ flags) & (SEC_LOAD | SEC_ALLOC)) == 0
1971 && (nexts->owner->flags & DYNAMIC) == 0
1972 && nexts->owner->usrdata != NULL
1973 && !(((lang_input_statement_type *) nexts->owner->usrdata)
1975 && _bfd_elf_match_sections_by_type (nexts->owner, nexts,
1977 flags = (((flags ^ SEC_READONLY)
1978 | (nexts->flags ^ SEC_READONLY))
1982 /* Decide which segment the section should go in based on the
1983 section name and section flags. We put loadable .note sections
1984 right after the .interp section, so that the PT_NOTE segment is
1985 stored right after the program headers where the OS can read it
1986 in the first page. */
1989 if ((flags & (SEC_ALLOC | SEC_DEBUGGING)) == 0)
1990 place = &hold[orphan_nonalloc];
1991 else if ((flags & SEC_ALLOC) == 0)
1993 else if ((flags & SEC_LOAD) != 0
1994 && ((iself && sh_type == SHT_NOTE)
1995 || (!iself && CONST_STRNEQ (secname, ".note"))))
1996 place = &hold[orphan_interp];
1997 else if ((flags & (SEC_LOAD | SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) == 0)
1998 place = &hold[orphan_bss];
1999 else if ((flags & SEC_SMALL_DATA) != 0)
2000 place = &hold[orphan_sdata];
2001 else if ((flags & SEC_THREAD_LOCAL) != 0)
2002 place = &hold[orphan_tdata];
2003 else if ((flags & SEC_READONLY) == 0)
2004 place = &hold[orphan_data];
2005 else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
2006 || (!iself && CONST_STRNEQ (secname, ".rel")))
2007 && (flags & SEC_LOAD) != 0)
2008 place = &hold[orphan_rel];
2009 else if ((flags & SEC_CODE) == 0)
2010 place = &hold[orphan_rodata];
2012 place = &hold[orphan_text];
2017 if (place->os == NULL)
2019 if (place->name != NULL)
2020 place->os = lang_output_section_find (place->name);
2022 place->os = output_rel_find (s, isdyn);
2027 = lang_output_section_find_by_flags (s, flags, &place->os,
2028 _bfd_elf_match_sections_by_type);
2030 /* *ABS* is always the first output section statement. */
2031 after = &lang_output_section_statement.head->output_section_statement;
2034 return lang_insert_orphan (s, secname, constraint, after, place, NULL, NULL);
2039 if test x"$LDEMUL_AFTER_ALLOCATION" != xgld"$EMULATION_NAME"_after_allocation; then
2043 gld${EMULATION_NAME}_after_allocation (void)
2045 int need_layout = bfd_elf_discard_info (link_info.output_bfd, &link_info);
2047 if (need_layout < 0)
2048 einfo ("%X%P: .eh_frame/.stab edit: %E\n");
2050 gld${EMULATION_NAME}_map_segments (need_layout);
2055 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
2059 gld${EMULATION_NAME}_get_script (int *isfile)
2062 if test x"$COMPILE_IN" = xyes
2064 # Scripts compiled in.
2066 # sed commands to quote an ld script as a C string.
2067 sc="-f stringify.sed"
2073 if (bfd_link_relocatable (&link_info) && config.build_constructors)
2076 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
2077 echo ' ; else if (bfd_link_relocatable (&link_info)) return' >> e${EMULATION_NAME}.c
2078 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
2079 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
2080 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
2081 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
2082 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
2083 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
2085 if test -n "$GENERATE_PIE_SCRIPT" ; then
2086 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2087 echo ' ; else if (bfd_link_pie (&link_info)' >> e${EMULATION_NAME}.c
2088 echo ' && link_info.combreloc' >> e${EMULATION_NAME}.c
2089 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
2090 echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2091 sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
2092 echo ' ; else if (bfd_link_pie (&link_info)' >> e${EMULATION_NAME}.c
2093 echo ' && link_info.combreloc) return' >> e${EMULATION_NAME}.c
2094 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
2096 echo ' ; else if (bfd_link_pie (&link_info)) return' >> e${EMULATION_NAME}.c
2097 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
2099 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
2100 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2101 echo ' ; else if (bfd_link_dll (&link_info) && link_info.combreloc' >> e${EMULATION_NAME}.c
2102 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
2103 echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2104 sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
2105 echo ' ; else if (bfd_link_dll (&link_info) && link_info.combreloc) return' >> e${EMULATION_NAME}.c
2106 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
2108 echo ' ; else if (bfd_link_dll (&link_info)) return' >> e${EMULATION_NAME}.c
2109 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
2111 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2112 echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
2113 echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2114 sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
2115 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
2116 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
2118 echo ' ; else return' >> e${EMULATION_NAME}.c
2119 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
2120 echo '; }' >> e${EMULATION_NAME}.c
2123 # Scripts read from the filesystem.
2129 if (bfd_link_relocatable (&link_info) && config.build_constructors)
2130 return "ldscripts/${EMULATION_NAME}.xu";
2131 else if (bfd_link_relocatable (&link_info))
2132 return "ldscripts/${EMULATION_NAME}.xr";
2133 else if (!config.text_read_only)
2134 return "ldscripts/${EMULATION_NAME}.xbn";
2136 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
2139 else if (!config.magic_demand_paged)
2140 return "ldscripts/${EMULATION_NAME}.xn";
2143 if test -n "$GENERATE_PIE_SCRIPT" ; then
2144 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2146 else if (bfd_link_pie (&link_info)
2147 && link_info.combreloc
2149 && (link_info.flags & DF_BIND_NOW))
2150 return "ldscripts/${EMULATION_NAME}.xdw";
2151 else if (bfd_link_pie (&link_info)
2152 && link_info.combreloc)
2153 return "ldscripts/${EMULATION_NAME}.xdc";
2157 else if (bfd_link_pie (&link_info))
2158 return "ldscripts/${EMULATION_NAME}.xd";
2161 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
2162 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2164 else if (bfd_link_dll (&link_info) && link_info.combreloc
2165 && link_info.relro && (link_info.flags & DF_BIND_NOW))
2166 return "ldscripts/${EMULATION_NAME}.xsw";
2167 else if (bfd_link_dll (&link_info) && link_info.combreloc)
2168 return "ldscripts/${EMULATION_NAME}.xsc";
2172 else if (bfd_link_dll (&link_info))
2173 return "ldscripts/${EMULATION_NAME}.xs";
2176 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2178 else if (link_info.combreloc && link_info.relro
2179 && (link_info.flags & DF_BIND_NOW))
2180 return "ldscripts/${EMULATION_NAME}.xw";
2181 else if (link_info.combreloc)
2182 return "ldscripts/${EMULATION_NAME}.xc";
2187 return "ldscripts/${EMULATION_NAME}.x";
2194 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
2196 $PARSE_AND_LIST_PROLOGUE
2202 #define OPTION_DISABLE_NEW_DTAGS (400)
2203 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
2204 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
2205 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
2206 #define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1)
2207 #define OPTION_HASH_STYLE (OPTION_EXCLUDE_LIBS + 1)
2208 #define OPTION_BUILD_ID (OPTION_HASH_STYLE + 1)
2209 #define OPTION_AUDIT (OPTION_BUILD_ID + 1)
2210 #define OPTION_COMPRESS_DEBUG (OPTION_AUDIT + 1)
2213 gld${EMULATION_NAME}_add_options
2214 (int ns, char **shortopts, int nl, struct option **longopts,
2215 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
2218 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2220 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:P:";
2224 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
2228 static const struct option xtra_long[] = {
2230 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2232 {"audit", required_argument, NULL, OPTION_AUDIT},
2233 {"Bgroup", no_argument, NULL, OPTION_GROUP},
2237 {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
2238 {"compress-debug-sections", required_argument, NULL, OPTION_COMPRESS_DEBUG},
2240 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2242 {"depaudit", required_argument, NULL, 'P'},
2243 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
2244 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
2245 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
2246 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
2247 {"hash-style", required_argument, NULL, OPTION_HASH_STYLE},
2250 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
2252 $PARSE_AND_LIST_LONGOPTS
2256 {NULL, no_argument, NULL, 0}
2259 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
2260 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
2261 *longopts = (struct option *)
2262 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
2263 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
2266 #define DEFAULT_BUILD_ID_STYLE "sha1"
2269 gld${EMULATION_NAME}_handle_option (int optc)
2276 case OPTION_BUILD_ID:
2277 if (emit_note_gnu_build_id != NULL)
2279 free ((char *) emit_note_gnu_build_id);
2280 emit_note_gnu_build_id = NULL;
2283 optarg = DEFAULT_BUILD_ID_STYLE;
2284 if (strcmp (optarg, "none"))
2285 emit_note_gnu_build_id = xstrdup (optarg);
2288 case OPTION_COMPRESS_DEBUG:
2289 if (strcasecmp (optarg, "none") == 0)
2290 link_info.compress_debug = COMPRESS_DEBUG_NONE;
2291 else if (strcasecmp (optarg, "zlib") == 0)
2292 link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
2293 else if (strcasecmp (optarg, "zlib-gnu") == 0)
2294 link_info.compress_debug = COMPRESS_DEBUG_GNU_ZLIB;
2295 else if (strcasecmp (optarg, "zlib-gabi") == 0)
2296 link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
2298 einfo (_("%P%F: invalid --compress-debug-sections option: \`%s'\n"),
2303 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2306 gld${EMULATION_NAME}_append_to_separated_string (&audit, optarg);
2310 gld${EMULATION_NAME}_append_to_separated_string (&depaudit, optarg);
2313 case OPTION_DISABLE_NEW_DTAGS:
2314 link_info.new_dtags = FALSE;
2317 case OPTION_ENABLE_NEW_DTAGS:
2318 link_info.new_dtags = TRUE;
2321 case OPTION_EH_FRAME_HDR:
2322 link_info.eh_frame_hdr_type = DWARF2_EH_HDR;
2326 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
2327 /* Groups must be self-contained. */
2328 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2329 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
2332 case OPTION_EXCLUDE_LIBS:
2333 add_excluded_libs (optarg);
2336 case OPTION_HASH_STYLE:
2337 link_info.emit_hash = FALSE;
2338 link_info.emit_gnu_hash = FALSE;
2339 if (strcmp (optarg, "sysv") == 0)
2340 link_info.emit_hash = TRUE;
2341 else if (strcmp (optarg, "gnu") == 0)
2342 link_info.emit_gnu_hash = TRUE;
2343 else if (strcmp (optarg, "both") == 0)
2345 link_info.emit_hash = TRUE;
2346 link_info.emit_gnu_hash = TRUE;
2349 einfo (_("%P%F: invalid hash style \`%s'\n"), optarg);
2356 if (strcmp (optarg, "defs") == 0)
2357 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2358 else if (strcmp (optarg, "muldefs") == 0)
2359 link_info.allow_multiple_definition = TRUE;
2360 else if (CONST_STRNEQ (optarg, "max-page-size="))
2364 config.maxpagesize = strtoul (optarg + 14, &end, 0);
2365 if (*end || (config.maxpagesize & (config.maxpagesize - 1)) != 0)
2366 einfo (_("%P%F: invalid maxium page size \`%s'\n"),
2369 else if (CONST_STRNEQ (optarg, "common-page-size="))
2372 config.commonpagesize = strtoul (optarg + 17, &end, 0);
2374 || (config.commonpagesize & (config.commonpagesize - 1)) != 0)
2375 einfo (_("%P%F: invalid common page size \`%s'\n"),
2378 else if (CONST_STRNEQ (optarg, "stack-size="))
2381 link_info.stacksize = strtoul (optarg + 11, &end, 0);
2382 if (*end || link_info.stacksize < 0)
2383 einfo (_("%P%F: invalid stack size \`%s'\n"), optarg + 11);
2384 if (!link_info.stacksize)
2385 /* Use -1 for explicit no-stack, because zero means
2387 link_info.stacksize = -1;
2389 else if (strcmp (optarg, "execstack") == 0)
2391 link_info.execstack = TRUE;
2392 link_info.noexecstack = FALSE;
2394 else if (strcmp (optarg, "noexecstack") == 0)
2396 link_info.noexecstack = TRUE;
2397 link_info.execstack = FALSE;
2401 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2403 else if (strcmp (optarg, "global") == 0)
2404 link_info.flags_1 |= (bfd_vma) DF_1_GLOBAL;
2405 else if (strcmp (optarg, "initfirst") == 0)
2406 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
2407 else if (strcmp (optarg, "interpose") == 0)
2408 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
2409 else if (strcmp (optarg, "loadfltr") == 0)
2410 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
2411 else if (strcmp (optarg, "nodefaultlib") == 0)
2412 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
2413 else if (strcmp (optarg, "nodelete") == 0)
2414 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
2415 else if (strcmp (optarg, "nodlopen") == 0)
2416 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
2417 else if (strcmp (optarg, "nodump") == 0)
2418 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
2419 else if (strcmp (optarg, "now") == 0)
2421 link_info.flags |= (bfd_vma) DF_BIND_NOW;
2422 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
2424 else if (strcmp (optarg, "lazy") == 0)
2426 link_info.flags &= ~(bfd_vma) DF_BIND_NOW;
2427 link_info.flags_1 &= ~(bfd_vma) DF_1_NOW;
2429 else if (strcmp (optarg, "origin") == 0)
2431 link_info.flags |= (bfd_vma) DF_ORIGIN;
2432 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
2434 else if (strcmp (optarg, "combreloc") == 0)
2435 link_info.combreloc = TRUE;
2436 else if (strcmp (optarg, "nocombreloc") == 0)
2437 link_info.combreloc = FALSE;
2438 else if (strcmp (optarg, "nocopyreloc") == 0)
2439 link_info.nocopyreloc = TRUE;
2440 else if (strcmp (optarg, "relro") == 0)
2441 link_info.relro = TRUE;
2442 else if (strcmp (optarg, "norelro") == 0)
2443 link_info.relro = FALSE;
2444 else if (strcmp (optarg, "common") == 0)
2445 link_info.elf_stt_common = elf_stt_common;
2446 else if (strcmp (optarg, "nocommon") == 0)
2447 link_info.elf_stt_common = no_elf_stt_common;
2448 else if (strcmp (optarg, "text") == 0)
2449 link_info.error_textrel = TRUE;
2450 else if (strcmp (optarg, "notext") == 0)
2451 link_info.error_textrel = FALSE;
2452 else if (strcmp (optarg, "textoff") == 0)
2453 link_info.error_textrel = FALSE;
2457 if test -n "$PARSE_AND_LIST_ARGS_CASE_Z" ; then
2459 $PARSE_AND_LIST_ARGS_CASE_Z
2465 einfo (_("%P: warning: -z %s ignored.\n"), optarg);
2469 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
2471 $PARSE_AND_LIST_ARGS_CASES
2483 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2484 gld_list_options="gld${EMULATION_NAME}_list_options"
2485 if test -n "$PARSE_AND_LIST_OPTIONS"; then
2489 gld${EMULATION_NAME}_list_options (FILE * file)
2493 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
2495 $PARSE_AND_LIST_OPTIONS
2503 gld_list_options="NULL"
2506 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
2508 $PARSE_AND_LIST_EPILOGUE
2515 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
2517 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
2518 ${LDEMUL_SYSLIB-syslib_default},
2519 ${LDEMUL_HLL-hll_default},
2520 ${LDEMUL_AFTER_PARSE-gld${EMULATION_NAME}_after_parse},
2521 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
2522 ${LDEMUL_AFTER_ALLOCATION-gld${EMULATION_NAME}_after_allocation},
2523 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
2524 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
2525 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
2526 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
2527 "${EMULATION_NAME}",
2529 ${LDEMUL_FINISH-finish_default},
2530 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
2531 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
2532 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
2533 ${LDEMUL_SET_SYMBOLS-NULL},
2534 ${LDEMUL_PARSE_ARGS-NULL},
2535 gld${EMULATION_NAME}_add_options,
2536 gld${EMULATION_NAME}_handle_option,
2537 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
2538 ${LDEMUL_LIST_OPTIONS-${gld_list_options}},
2539 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
2540 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
2541 ${LDEMUL_NEW_VERS_PATTERN-NULL},
2542 ${LDEMUL_EXTRA_MAP_FILE_TEXT-NULL}