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}
11 cat >e${EMULATION_NAME}.c <<EOF
12 /* This file is is generated by a shell script. DO NOT EDIT! */
14 /* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
15 Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
16 Free Software Foundation, Inc.
17 Written by Steve Chamberlain <sac@cygnus.com>
18 ELF support by Ian Lance Taylor <ian@cygnus.com>
20 This file is part of GLD, the Gnu Linker.
22 This program is free software; you can redistribute it and/or modify
23 it under the terms of the GNU General Public License as published by
24 the Free Software Foundation; either version 2 of the License, or
25 (at your option) any later version.
27 This program is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 GNU General Public License for more details.
32 You should have received a copy of the GNU General Public License
33 along with this program; if not, write to the Free Software
34 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
36 #define TARGET_IS_${EMULATION_NAME}
40 #include "libiberty.h"
41 #include "safe-ctype.h"
53 #include "elf/common.h"
55 static void gld${EMULATION_NAME}_before_parse
57 static void gld${EMULATION_NAME}_vercheck
58 PARAMS ((lang_input_statement_type *));
59 static void gld${EMULATION_NAME}_stat_needed
60 PARAMS ((lang_input_statement_type *));
61 static boolean gld${EMULATION_NAME}_try_needed
62 PARAMS ((const char *, int));
63 static boolean gld${EMULATION_NAME}_search_needed
64 PARAMS ((const char *, const char *, int));
65 static void gld${EMULATION_NAME}_check_needed
66 PARAMS ((lang_input_statement_type *));
67 static void gld${EMULATION_NAME}_after_open
69 static void gld${EMULATION_NAME}_find_exp_assignment
70 PARAMS ((etree_type *));
71 static void gld${EMULATION_NAME}_find_statement_assignment
72 PARAMS ((lang_statement_union_type *));
73 static void gld${EMULATION_NAME}_before_allocation
75 static boolean gld${EMULATION_NAME}_open_dynamic_archive
76 PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
77 static lang_output_section_statement_type *output_rel_find
79 static asection *output_prev_sec_find
80 PARAMS ((lang_output_section_statement_type *));
81 static boolean gld${EMULATION_NAME}_place_orphan
82 PARAMS ((lang_input_statement_type *, asection *));
83 static void gld${EMULATION_NAME}_finish
85 static char *gld${EMULATION_NAME}_get_script
86 PARAMS ((int *isfile));
90 # Import any needed special functions and/or overrides.
92 if test -n "$EXTRA_EM_FILE" ; then
93 . ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
96 # Functions in this file can be overridden by setting the LDEMUL_* shell
97 # variables. If the name of the overriding function is the same as is
98 # defined in this file, then don't output this file's version.
99 # If a different overriding name is given then output the standard function
100 # as presumably it is called from the overriding function.
102 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
103 cat >>e${EMULATION_NAME}.c <<EOF
106 gld${EMULATION_NAME}_before_parse ()
108 const bfd_arch_info_type *arch = bfd_scan_arch ("${OUTPUT_ARCH}");
111 ldfile_output_architecture = arch->arch;
112 ldfile_output_machine = arch->mach;
113 ldfile_output_machine_name = arch->printable_name;
116 ldfile_output_architecture = bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`;
117 config.dynamic_link = ${DYNAMIC_LINK-true};
118 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo true ; else echo false ; fi`;
124 cat >>e${EMULATION_NAME}.c <<EOF
126 /* These variables are required to pass information back and forth
127 between after_open and check_needed and stat_needed and vercheck. */
129 static struct bfd_link_needed_list *global_needed;
130 static struct stat global_stat;
131 static boolean global_found;
132 static struct bfd_link_needed_list *global_vercheck_needed;
133 static boolean global_vercheck_failed;
136 /* On Linux, it's possible to have different versions of the same
137 shared library linked against different versions of libc. The
138 dynamic linker somehow tags which libc version to use in
139 /etc/ld.so.cache, and, based on the libc that it sees in the
140 executable, chooses which version of the shared library to use.
142 We try to do a similar check here by checking whether this shared
143 library needs any other shared libraries which may conflict with
144 libraries we have already included in the link. If it does, we
145 skip it, and try to find another shared library farther on down the
148 This is called via lang_for_each_input_file.
149 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
150 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
151 a conflicting version. */
154 gld${EMULATION_NAME}_vercheck (s)
155 lang_input_statement_type *s;
158 struct bfd_link_needed_list *l;
160 if (global_vercheck_failed)
162 if (s->the_bfd == NULL
163 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
166 soname = bfd_elf_get_dt_soname (s->the_bfd);
168 soname = basename (bfd_get_filename (s->the_bfd));
170 for (l = global_vercheck_needed; l != NULL; l = l->next)
174 if (strcmp (soname, l->name) == 0)
176 /* Probably can't happen, but it's an easy check. */
180 if (strchr (l->name, '/') != NULL)
183 suffix = strstr (l->name, ".so.");
187 suffix += sizeof ".so." - 1;
189 if (strncmp (soname, l->name, suffix - l->name) == 0)
191 /* Here we know that S is a dynamic object FOO.SO.VER1, and
192 the object we are considering needs a dynamic object
193 FOO.SO.VER2, and VER1 and VER2 are different. This
194 appears to be a version mismatch, so we tell the caller
195 to try a different version of this library. */
196 global_vercheck_failed = true;
203 /* See if an input file matches a DT_NEEDED entry by running stat on
207 gld${EMULATION_NAME}_stat_needed (s)
208 lang_input_statement_type *s;
216 if (s->the_bfd == NULL)
219 if (bfd_stat (s->the_bfd, &st) != 0)
221 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
225 if (st.st_dev == global_stat.st_dev
226 && st.st_ino == global_stat.st_ino)
232 /* We issue a warning if it looks like we are including two
233 different versions of the same shared library. For example,
234 there may be a problem if -lc picks up libc.so.6 but some other
235 shared library has a DT_NEEDED entry of libc.so.5. This is a
236 heuristic test, and it will only work if the name looks like
237 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
238 If we really want to issue warnings about mixing version numbers
239 of shared libraries, we need to find a better way. */
241 if (strchr (global_needed->name, '/') != NULL)
243 suffix = strstr (global_needed->name, ".so.");
246 suffix += sizeof ".so." - 1;
248 soname = bfd_elf_get_dt_soname (s->the_bfd);
250 soname = basename (s->filename);
252 if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
253 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
254 global_needed->name, global_needed->by, soname);
258 /* This function is called for each possible name for a dynamic object
259 named by a DT_NEEDED entry. The FORCE parameter indicates whether
260 to skip the check for a conflicting version. */
263 gld${EMULATION_NAME}_try_needed (name, force)
270 abfd = bfd_openr (name, bfd_get_target (output_bfd));
273 if (! bfd_check_format (abfd, bfd_object))
278 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
284 /* Check whether this object would include any conflicting library
285 versions. If FORCE is set, then we skip this check; we use this
286 the second time around, if we couldn't find any compatible
287 instance of the shared library. */
291 struct bfd_link_needed_list *needed;
293 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
294 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
298 global_vercheck_needed = needed;
299 global_vercheck_failed = false;
300 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
301 if (global_vercheck_failed)
304 /* Return false to force the caller to move on to try
305 another file on the search path. */
309 /* But wait! It gets much worse. On Linux, if a shared
310 library does not use libc at all, we are supposed to skip
311 it the first time around in case we encounter a shared
312 library later on with the same name which does use the
313 version of libc that we want. This is much too horrible
314 to use on any system other than Linux. */
319 cat >>e${EMULATION_NAME}.c <<EOF
321 struct bfd_link_needed_list *l;
323 for (l = needed; l != NULL; l = l->next)
324 if (strncmp (l->name, "libc.so", 7) == 0)
336 cat >>e${EMULATION_NAME}.c <<EOF
340 /* We've found a dynamic object matching the DT_NEEDED entry. */
342 /* We have already checked that there is no other input file of the
343 same name. We must now check again that we are not including the
344 same file twice. We need to do this because on many systems
345 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
346 reference libc.so.1. If we have already included libc.so, we
347 don't want to include libc.so.1 if they are the same file, and we
348 can only check that using stat. */
350 if (bfd_stat (abfd, &global_stat) != 0)
351 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
353 /* First strip off everything before the last '/'. */
354 soname = basename (abfd->filename);
356 if (trace_file_tries)
357 info_msg (_("found %s at %s\n"), soname, name);
359 global_found = false;
360 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
363 /* Return true to indicate that we found the file, even though
364 we aren't going to do anything with it. */
368 /* Tell the ELF backend that we don't want the output file to have a
369 DT_NEEDED entry for this file. */
370 bfd_elf_set_dt_needed_name (abfd, "");
372 /* Previos basename call was clobbered in lang_for_each_input_file. */
373 soname = basename (abfd->filename);
375 /* Tell the ELF backend that the output file needs a DT_NEEDED
376 entry for this file if it is used to resolve the reference in
378 bfd_elf_set_dt_needed_soname (abfd, soname);
380 /* Add this file into the symbol table. */
381 if (! bfd_link_add_symbols (abfd, &link_info))
382 einfo ("%F%B: could not read symbols: %E\n", abfd);
388 /* Search for a needed file in a path. */
391 gld${EMULATION_NAME}_search_needed (path, name, force)
400 return gld${EMULATION_NAME}_try_needed (name, force);
402 if (path == NULL || *path == '\0')
407 char *filename, *sset;
409 s = strchr (path, ':');
411 s = path + strlen (path);
413 filename = (char *) xmalloc (s - path + len + 2);
418 memcpy (filename, path, s - path);
419 filename[s - path] = '/';
420 sset = filename + (s - path) + 1;
424 if (gld${EMULATION_NAME}_try_needed (filename, force))
438 if [ "x${host}" = "x${target}" ] ; then
439 case " ${EMULATION_LIBPATH} " in
440 *" ${EMULATION_NAME} "*)
443 cat >>e${EMULATION_NAME}.c <<EOF
445 /* For a native linker, check the file /etc/ld.so.conf for directories
446 in which we may find shared libraries. /etc/ld.so.conf is really
447 only meaningful on Linux. */
449 static boolean gld${EMULATION_NAME}_check_ld_so_conf
450 PARAMS ((const char *, int));
453 gld${EMULATION_NAME}_check_ld_so_conf (name, force)
457 static boolean initialized;
458 static char *ld_so_conf;
464 f = fopen ("/etc/ld.so.conf", FOPEN_RT);
473 b = (char *) xmalloc (alloc);
475 while ((c = getc (f)) != EOF)
477 if (len + 1 >= alloc)
480 b = (char *) xrealloc (b, alloc);
493 if (len > 0 && b[len - 1] != ':')
501 if (len > 0 && b[len - 1] == ':')
520 if (ld_so_conf == NULL)
523 return gld${EMULATION_NAME}_search_needed (ld_so_conf, name, force);
532 cat >>e${EMULATION_NAME}.c <<EOF
534 /* See if an input file matches a DT_NEEDED entry by name. */
537 gld${EMULATION_NAME}_check_needed (s)
538 lang_input_statement_type *s;
543 if (s->filename != NULL)
547 if (strcmp (s->filename, global_needed->name) == 0)
553 if (s->search_dirs_flag)
555 f = strrchr (s->filename, '/');
557 && strcmp (f + 1, global_needed->name) == 0)
565 if (s->the_bfd != NULL)
569 soname = bfd_elf_get_dt_soname (s->the_bfd);
571 && strcmp (soname, global_needed->name) == 0)
581 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
582 cat >>e${EMULATION_NAME}.c <<EOF
584 /* This is called after all the input files have been opened. */
587 gld${EMULATION_NAME}_after_open ()
589 struct bfd_link_needed_list *needed, *l;
591 /* We only need to worry about this when doing a final link. */
592 if (link_info.relocateable || link_info.shared)
595 /* Get the list of files which appear in DT_NEEDED entries in
596 dynamic objects included in the link (often there will be none).
597 For each such file, we want to track down the corresponding
598 library, and include the symbol table in the link. This is what
599 the runtime dynamic linker will do. Tracking the files down here
600 permits one dynamic object to include another without requiring
601 special action by the person doing the link. Note that the
602 needed list can actually grow while we are stepping through this
604 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
605 for (l = needed; l != NULL; l = l->next)
607 struct bfd_link_needed_list *ll;
610 /* If we've already seen this file, skip it. */
611 for (ll = needed; ll != l; ll = ll->next)
612 if (strcmp (ll->name, l->name) == 0)
617 /* See if this file was included in the link explicitly. */
619 global_found = false;
620 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
624 if (trace_file_tries)
625 info_msg (_("%s needed by %B\n"), l->name, l->by);
627 /* We need to find this file and include the symbol table. We
628 want to search for the file in the same way that the dynamic
629 linker will search. That means that we want to use
630 rpath_link, rpath, then the environment variable
631 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
632 entries (native only), then the linker script LIB_SEARCH_DIRS.
633 We do not search using the -L arguments.
635 We search twice. The first time, we skip objects which may
636 introduce version mismatches. The second time, we force
637 their use. See gld${EMULATION_NAME}_vercheck comment. */
638 for (force = 0; force < 2; force++)
641 search_dirs_type *search;
643 if [ "x${host}" = "x${target}" ] ; then
644 case " ${EMULATION_LIBPATH} " in
645 *" ${EMULATION_NAME} "*)
646 cat >>e${EMULATION_NAME}.c <<EOF
647 const char *lib_path;
648 struct bfd_link_needed_list *rp;
654 cat >>e${EMULATION_NAME}.c <<EOF
656 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
660 if [ "x${host}" = "x${target}" ] ; then
661 case " ${EMULATION_LIBPATH} " in
662 *" ${EMULATION_NAME} "*)
663 cat >>e${EMULATION_NAME}.c <<EOF
664 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
667 if (command_line.rpath_link == NULL
668 && command_line.rpath == NULL)
670 lib_path = (const char *) getenv ("LD_RUN_PATH");
671 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name,
675 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
676 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, force))
680 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
681 for (; !found && rp != NULL; rp = rp->next)
683 found = (rp->by == l->by
684 && gld${EMULATION_NAME}_search_needed (rp->name,
695 cat >>e${EMULATION_NAME}.c <<EOF
696 len = strlen (l->name);
697 for (search = search_head; search != NULL; search = search->next)
703 filename = (char *) xmalloc (strlen (search->name) + len + 2);
704 sprintf (filename, "%s/%s", search->name, l->name);
705 if (gld${EMULATION_NAME}_try_needed (filename, force))
712 if [ "x${host}" = "x${target}" ] ; then
713 case " ${EMULATION_LIBPATH} " in
714 *" ${EMULATION_NAME} "*)
717 cat >>e${EMULATION_NAME}.c <<EOF
718 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
727 cat >>e${EMULATION_NAME}.c <<EOF
733 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
741 cat >>e${EMULATION_NAME}.c <<EOF
743 /* Look through an expression for an assignment statement. */
746 gld${EMULATION_NAME}_find_exp_assignment (exp)
749 struct bfd_link_hash_entry *h;
751 switch (exp->type.node_class)
754 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
755 false, false, false);
759 /* We call record_link_assignment even if the symbol is defined.
760 This is because if it is defined by a dynamic object, we
761 actually want to use the value defined by the linker script,
762 not the value from the dynamic object (because we are setting
763 symbols like etext). If the symbol is defined by a regular
764 object, then, as it happens, calling record_link_assignment
769 if (strcmp (exp->assign.dst, ".") != 0)
771 if (! (bfd_elf${ELFSIZE}_record_link_assignment
772 (output_bfd, &link_info, exp->assign.dst,
773 exp->type.node_class == etree_provide ? true : false)))
774 einfo ("%P%F: failed to record assignment to %s: %E\n",
777 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
781 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
782 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
786 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
787 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
788 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
792 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
801 /* This is called by the before_allocation routine via
802 lang_for_each_statement. It locates any assignment statements, and
803 tells the ELF backend about them, in case they are assignments to
804 symbols which are referred to by dynamic objects. */
807 gld${EMULATION_NAME}_find_statement_assignment (s)
808 lang_statement_union_type *s;
810 if (s->header.type == lang_assignment_statement_enum)
811 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
816 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
817 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
818 ELF_INTERPRETER_SET_DEFAULT="
821 sinterp->contents = ${ELF_INTERPRETER_NAME};
822 sinterp->_raw_size = strlen (sinterp->contents) + 1;
827 ELF_INTERPRETER_SET_DEFAULT=
829 cat >>e${EMULATION_NAME}.c <<EOF
831 /* This is called after the sections have been attached to output
832 sections, but before any sizes or addresses have been set. */
835 gld${EMULATION_NAME}_before_allocation ()
840 /* If we are going to make any variable assignments, we need to let
841 the ELF backend know about them in case the variables are
842 referred to by dynamic objects. */
843 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
845 /* Let the ELF backend work out the sizes of any sections required
846 by dynamic linking. */
847 rpath = command_line.rpath;
849 rpath = (const char *) getenv ("LD_RUN_PATH");
850 if (! (bfd_elf${ELFSIZE}_size_dynamic_sections
851 (output_bfd, command_line.soname, rpath,
852 command_line.filter_shlib,
853 (const char * const *) command_line.auxiliary_filters,
854 &link_info, &sinterp, lang_elf_version_info)))
855 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
856 ${ELF_INTERPRETER_SET_DEFAULT}
857 /* Let the user override the dynamic linker we are using. */
858 if (command_line.interpreter != NULL
861 sinterp->contents = (bfd_byte *) command_line.interpreter;
862 sinterp->_raw_size = strlen (command_line.interpreter) + 1;
865 /* Look for any sections named .gnu.warning. As a GNU extensions,
866 we treat such sections as containing warning messages. We print
867 out the warning message, and then zero out the section size so
868 that it does not get copied into the output file. */
871 LANG_FOR_EACH_INPUT_STATEMENT (is)
878 if (is->just_syms_flag)
881 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
885 sz = bfd_section_size (is->the_bfd, s);
886 msg = xmalloc ((size_t) sz + 1);
887 if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
888 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
891 ret = link_info.callbacks->warning (&link_info, msg,
893 is->the_bfd, (asection *) NULL,
898 /* Clobber the section size, so that we don't waste copying the
899 warning into the output file. */
908 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
909 cat >>e${EMULATION_NAME}.c <<EOF
911 /* Try to open a dynamic archive. This is where we know that ELF
912 dynamic libraries have an extension of .so (or .sl on oddball systems
916 gld${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
918 search_dirs_type *search;
919 lang_input_statement_type *entry;
921 const char *filename;
924 if (! entry->is_archive)
927 filename = entry->filename;
929 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
930 is defined, but it does not seem worth the headache to optimize
931 away those two bytes of space. */
932 string = (char *) xmalloc (strlen (search->name)
935 #ifdef EXTRA_SHLIB_EXTENSION
936 + strlen (EXTRA_SHLIB_EXTENSION)
940 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
942 #ifdef EXTRA_SHLIB_EXTENSION
943 /* Try the .so extension first. If that fails build a new filename
944 using EXTRA_SHLIB_EXTENSION. */
945 if (! ldfile_try_open_bfd (string, entry))
946 sprintf (string, "%s/lib%s%s%s", search->name,
947 filename, arch, EXTRA_SHLIB_EXTENSION);
950 if (! ldfile_try_open_bfd (string, entry))
956 entry->filename = string;
958 /* We have found a dynamic object to include in the link. The ELF
959 backend linker will create a DT_NEEDED entry in the .dynamic
960 section naming this file. If this file includes a DT_SONAME
961 entry, it will be used. Otherwise, the ELF linker will just use
962 the name of the file. For an archive found by searching, like
963 this one, the DT_NEEDED entry should consist of just the name of
964 the file, without the path information used to find it. Note
965 that we only need to do this if we have a dynamic object; an
966 archive will never be referenced by a DT_NEEDED entry.
968 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
969 very pretty. I haven't been able to think of anything that is
971 if (bfd_check_format (entry->the_bfd, bfd_object)
972 && (entry->the_bfd->flags & DYNAMIC) != 0)
974 ASSERT (entry->is_archive && entry->search_dirs_flag);
976 /* Rather than duplicating the logic above. Just use the
977 filename we recorded earlier. */
979 filename = xstrdup (basename (entry->filename));
980 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
989 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
990 cat >>e${EMULATION_NAME}.c <<EOF
992 /* A variant of lang_output_section_find. Used by place_orphan. */
994 static lang_output_section_statement_type *
997 lang_statement_union_type *u;
998 lang_output_section_statement_type *lookup;
1000 for (u = lang_output_section_statement.head;
1001 u != (lang_statement_union_type *) NULL;
1004 lookup = &u->output_section_statement;
1005 if (strncmp (".rel", lookup->name, 4) == 0
1006 && lookup->bfd_section != NULL
1007 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1012 return (lang_output_section_statement_type *) NULL;
1015 /* Find the last output section before given output statement.
1016 Used by place_orphan. */
1019 output_prev_sec_find (os)
1020 lang_output_section_statement_type *os;
1022 asection *s = (asection *) NULL;
1023 lang_statement_union_type *u;
1024 lang_output_section_statement_type *lookup;
1026 for (u = lang_output_section_statement.head;
1027 u != (lang_statement_union_type *) NULL;
1030 lookup = &u->output_section_statement;
1034 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1035 s = lookup->bfd_section;
1041 /* Place an orphan section. We use this to put random SHF_ALLOC
1042 sections in the right segment. */
1044 struct orphan_save {
1045 lang_output_section_statement_type *os;
1047 lang_statement_union_type **stmt;
1051 gld${EMULATION_NAME}_place_orphan (file, s)
1052 lang_input_statement_type *file;
1055 static struct orphan_save hold_text;
1056 static struct orphan_save hold_rodata;
1057 static struct orphan_save hold_data;
1058 static struct orphan_save hold_bss;
1059 static struct orphan_save hold_rel;
1060 static struct orphan_save hold_interp;
1061 static struct orphan_save hold_sdata;
1062 static int count = 1;
1063 struct orphan_save *place;
1064 lang_statement_list_type *old;
1065 lang_statement_list_type add;
1066 etree_type *address;
1067 const char *secname;
1068 const char *outsecname;
1069 const char *ps = NULL;
1070 lang_output_section_statement_type *os;
1072 secname = bfd_get_section_name (s->owner, s);
1074 if (! config.unique_orphan_sections && ! unique_section_p (secname))
1076 /* Look through the script to see where to place this section. */
1077 os = lang_output_section_find (secname);
1080 && (os->bfd_section == NULL
1081 || ((s->flags ^ os->bfd_section->flags)
1082 & (SEC_LOAD | SEC_ALLOC)) == 0))
1084 /* We already have an output section statement with this
1085 name, and its bfd section, if any, has compatible flags. */
1086 lang_add_section (&os->children, s, os, file);
1091 if (hold_text.os == NULL)
1092 hold_text.os = lang_output_section_find (".text");
1094 /* If this is a final link, then always put .gnu.warning.SYMBOL
1095 sections into the .text section to get them out of the way. */
1096 if (! link_info.shared
1097 && ! link_info.relocateable
1098 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1099 && hold_text.os != NULL)
1101 lang_add_section (&hold_text.os->children, s, hold_text.os, file);
1105 /* Decide which segment the section should go in based on the
1106 section name and section flags. We put loadable .note sections
1107 right after the .interp section, so that the PT_NOTE segment is
1108 stored right after the program headers where the OS can read it
1109 in the first page. */
1110 #define HAVE_SECTION(hold, name) \
1111 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1113 if (s->flags & SEC_EXCLUDE)
1115 if (s->output_section == NULL)
1116 s->output_section = bfd_abs_section_ptr;
1121 if ((s->flags & SEC_ALLOC) == 0)
1123 else if ((s->flags & SEC_LOAD) != 0
1124 && strncmp (secname, ".note", 5) == 0
1125 && HAVE_SECTION (hold_interp, ".interp"))
1126 place = &hold_interp;
1127 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1128 && HAVE_SECTION (hold_bss, ".bss"))
1130 else if ((s->flags & SEC_SMALL_DATA) != 0
1131 && HAVE_SECTION (hold_sdata, ".sdata"))
1132 place = &hold_sdata;
1133 else if ((s->flags & SEC_READONLY) == 0
1134 && HAVE_SECTION (hold_data, ".data"))
1136 else if (strncmp (secname, ".rel", 4) == 0
1137 && (hold_rel.os != NULL
1138 || (hold_rel.os = output_rel_find ()) != NULL))
1140 if (! link_info.relocateable && link_info.combreloc)
1142 if (strncmp (secname, ".rela", 5) == 0)
1143 os = lang_output_section_find (".rela.dyn");
1145 os = lang_output_section_find (".rel.dyn");
1148 && os->bfd_section != NULL
1149 && ((s->flags ^ os->bfd_section->flags)
1150 & (SEC_LOAD | SEC_ALLOC)) == 0)
1152 lang_add_section (&os->children, s, os, file);
1158 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == SEC_READONLY
1159 && HAVE_SECTION (hold_rodata, ".rodata"))
1160 place = &hold_rodata;
1161 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == (SEC_CODE | SEC_READONLY)
1162 && hold_text.os != NULL)
1167 /* Choose a unique name for the section. This will be needed if the
1168 same section name appears in the input file with different
1169 loadable or allocatable characteristics. */
1170 outsecname = secname;
1171 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1173 outsecname = bfd_get_unique_section_name (output_bfd,
1176 if (outsecname == NULL)
1177 einfo ("%F%P: place_orphan failed: %E\n");
1180 /* Start building a list of statements for this section.
1181 First save the current statement pointer. */
1184 /* If we have found an appropriate place for the output section
1185 statements for this orphan, add them to our own private list,
1186 inserting them later into the global statement list. */
1190 lang_list_init (stat_ptr);
1193 if (config.build_constructors)
1195 /* If the name of the section is representable in C, then create
1196 symbols to mark the start and the end of the section. */
1197 for (ps = outsecname; *ps != '\0'; ps++)
1198 if (! ISALNUM (*ps) && *ps != '_')
1203 etree_type *e_align;
1205 symname = (char *) xmalloc (ps - outsecname + sizeof "__start_");
1206 sprintf (symname, "__start_%s", outsecname);
1207 e_align = exp_unop (ALIGN_K,
1208 exp_intop ((bfd_vma) 1 << s->alignment_power));
1209 lang_add_assignment (exp_assop ('=', symname, e_align));
1213 if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1214 address = exp_intop ((bfd_vma) 0);
1218 os = lang_enter_output_section_statement (outsecname, address, 0,
1220 (etree_type *) NULL,
1221 (etree_type *) NULL,
1222 (etree_type *) NULL);
1224 lang_add_section (&os->children, s, os, file);
1226 lang_leave_output_section_statement
1227 ((bfd_vma) 0, "*default*",
1228 (struct lang_output_section_phdr_list *) NULL, "*default*");
1230 if (config.build_constructors && *ps == '\0')
1234 /* lang_leave_ouput_section_statement resets stat_ptr. Put
1235 stat_ptr back where we want it. */
1239 symname = (char *) xmalloc (ps - outsecname + sizeof "__stop_");
1240 sprintf (symname, "__stop_%s", outsecname);
1241 lang_add_assignment (exp_assop ('=', symname,
1242 exp_nameop (NAME, ".")));
1245 /* Restore the global list pointer. */
1250 asection *snew, **pps;
1252 snew = os->bfd_section;
1254 /* Shuffle the bfd section list to make the output file look
1255 neater. This is really only cosmetic. */
1256 if (place->section == NULL)
1258 asection *bfd_section = place->os->bfd_section;
1260 /* If the output statement hasn't been used to place
1261 any input sections (and thus doesn't have an output
1262 bfd_section), look for the closest prior output statement
1263 having an output section. */
1264 if (bfd_section == NULL)
1265 bfd_section = output_prev_sec_find (place->os);
1267 if (bfd_section != NULL && bfd_section != snew)
1268 place->section = &bfd_section->next;
1271 if (place->section != NULL)
1273 /* Unlink the section. */
1274 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1278 /* Now tack it on to the "place->os" section list. */
1279 snew->next = *place->section;
1280 *place->section = snew;
1283 /* Save the end of this list. Further ophans of this type will
1284 follow the one we've just added. */
1285 place->section = &snew->next;
1287 /* The following is non-cosmetic. We try to put the output
1288 statements in some sort of reasonable order here, because
1289 they determine the final load addresses of the orphan
1290 sections. In addition, placing output statements in the
1291 wrong order may require extra segments. For instance,
1292 given a typical situation of all read-only sections placed
1293 in one segment and following that a segment containing all
1294 the read-write sections, we wouldn't want to place an orphan
1295 read/write section before or amongst the read-only ones. */
1296 if (add.head != NULL)
1298 if (place->stmt == NULL)
1300 /* Put the new statement list right at the head. */
1301 *add.tail = place->os->header.next;
1302 place->os->header.next = add.head;
1306 /* Put it after the last orphan statement we added. */
1307 *add.tail = *place->stmt;
1308 *place->stmt = add.head;
1311 /* Fix the global list pointer if we happened to tack our
1312 new list at the tail. */
1313 if (*old->tail == add.head)
1314 old->tail = add.tail;
1316 /* Save the end of this list. */
1317 place->stmt = add.tail;
1326 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1327 cat >>e${EMULATION_NAME}.c <<EOF
1330 gld${EMULATION_NAME}_finish ()
1332 if (bfd_elf${ELFSIZE}_discard_info (&link_info))
1334 /* Resize the sections. */
1335 lang_size_sections (stat_ptr->head, abs_output_section,
1336 &stat_ptr->head, 0, (bfd_vma) 0, false);
1338 /* Redo special stuff. */
1339 ldemul_after_allocation ();
1341 /* Do the assignments again. */
1342 lang_do_assignments (stat_ptr->head, abs_output_section,
1343 (fill_type) 0, (bfd_vma) 0);
1349 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1350 cat >>e${EMULATION_NAME}.c <<EOF
1353 gld${EMULATION_NAME}_get_script (isfile)
1357 if test -n "$COMPILE_IN"
1359 # Scripts compiled in.
1361 # sed commands to quote an ld script as a C string.
1362 sc="-f stringify.sed"
1364 cat >>e${EMULATION_NAME}.c <<EOF
1368 if (link_info.relocateable == true && config.build_constructors == true)
1371 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1372 echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1373 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1374 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1375 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1376 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1377 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1378 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1380 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1381 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1382 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1383 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1384 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1386 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1387 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1388 echo ' ; else return' >> e${EMULATION_NAME}.c
1389 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1390 echo '; }' >> e${EMULATION_NAME}.c
1393 # Scripts read from the filesystem.
1395 cat >>e${EMULATION_NAME}.c <<EOF
1399 if (link_info.relocateable == true && config.build_constructors == true)
1400 return "ldscripts/${EMULATION_NAME}.xu";
1401 else if (link_info.relocateable == true)
1402 return "ldscripts/${EMULATION_NAME}.xr";
1403 else if (!config.text_read_only)
1404 return "ldscripts/${EMULATION_NAME}.xbn";
1405 else if (!config.magic_demand_paged)
1406 return "ldscripts/${EMULATION_NAME}.xn";
1407 else if (link_info.shared)
1408 return "ldscripts/${EMULATION_NAME}.xs";
1410 return "ldscripts/${EMULATION_NAME}.x";
1417 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1419 if test x"$LDEMUL_PARSE_ARGS" != xgld"$EMULATION_NAME"_parse_args; then
1421 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1422 cat >>e${EMULATION_NAME}.c <<EOF
1423 $PARSE_AND_LIST_PROLOGUE
1427 cat >>e${EMULATION_NAME}.c <<EOF
1431 #define OPTION_DISABLE_NEW_DTAGS (400)
1432 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1433 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1435 static struct option longopts[] =
1439 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1440 cat >>e${EMULATION_NAME}.c <<EOF
1441 /* getopt allows abbreviations, so we do this to stop it from
1442 treating -d/-e as abbreviations for these options. */
1443 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1444 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1445 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1446 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1447 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1448 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1452 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1453 cat >>e${EMULATION_NAME}.c <<EOF
1454 $PARSE_AND_LIST_LONGOPTS
1458 cat >>e${EMULATION_NAME}.c <<EOF
1459 {NULL, no_argument, NULL, 0}
1463 static int gld${EMULATION_NAME}_parse_args PARAMS ((int, char **));
1466 gld${EMULATION_NAME}_parse_args (argc, argv)
1472 static int prevoptind = -1;
1473 int prevopterr = opterr;
1476 if (prevoptind != optind)
1480 prevoptind = optind;
1482 optc = getopt_long_only (argc, argv,
1483 "-${PARSE_AND_LIST_SHORTOPTS}z:", longopts,
1485 opterr = prevopterr;
1492 optind = prevoptind;
1497 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1498 cat >>e${EMULATION_NAME}.c <<EOF
1499 case OPTION_DISABLE_NEW_DTAGS:
1500 link_info.new_dtags = false;
1503 case OPTION_ENABLE_NEW_DTAGS:
1504 link_info.new_dtags = true;
1508 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1509 /* Groups must be self-contained. */
1510 link_info.no_undefined = true;
1514 if (strcmp (optarg, "initfirst") == 0)
1515 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1516 else if (strcmp (optarg, "interpose") == 0)
1517 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1518 else if (strcmp (optarg, "loadfltr") == 0)
1519 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1520 else if (strcmp (optarg, "nodefaultlib") == 0)
1521 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1522 else if (strcmp (optarg, "nodelete") == 0)
1523 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1524 else if (strcmp (optarg, "nodlopen") == 0)
1525 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1526 else if (strcmp (optarg, "nodump") == 0)
1527 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1528 else if (strcmp (optarg, "now") == 0)
1530 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1531 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1533 else if (strcmp (optarg, "origin") == 0)
1535 link_info.flags |= (bfd_vma) DF_ORIGIN;
1536 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1538 else if (strcmp (optarg, "defs") == 0)
1539 link_info.no_undefined = true;
1540 else if (strcmp (optarg, "combreloc") == 0)
1541 link_info.combreloc = true;
1542 else if (strcmp (optarg, "nocombreloc") == 0)
1543 link_info.combreloc = false;
1544 else if (strcmp (optarg, "nocopyreloc") == 0)
1545 link_info.nocopyreloc = true;
1546 /* What about the other Solaris -z options? FIXME. */
1551 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1552 cat >>e${EMULATION_NAME}.c <<EOF
1553 $PARSE_AND_LIST_ARGS_CASES
1557 cat >>e${EMULATION_NAME}.c <<EOF
1566 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1567 cat >>e${EMULATION_NAME}.c <<EOF
1569 static void gld${EMULATION_NAME}_list_options PARAMS ((FILE * file));
1572 gld${EMULATION_NAME}_list_options (file)
1577 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1578 cat >>e${EMULATION_NAME}.c <<EOF
1579 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1580 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1581 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1582 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1583 fprintf (file, _(" -z defs\t\tDisallows undefined symbols\n"));
1584 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1585 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1586 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1587 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1588 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1589 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1590 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1591 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1592 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1593 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1594 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n"));
1595 fprintf (file, _("\t\t\t at runtime\n"));
1596 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1600 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1601 cat >>e${EMULATION_NAME}.c <<EOF
1602 $PARSE_AND_LIST_OPTIONS
1606 cat >>e${EMULATION_NAME}.c <<EOF
1610 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1611 cat >>e${EMULATION_NAME}.c <<EOF
1612 $PARSE_AND_LIST_EPILOGUE
1617 if test x"$LDEMUL_PARSE_ARGS" != xgld"$EMULATION_NAME"_parse_args; then
1618 cat >>e${EMULATION_NAME}.c <<EOF
1619 #define gld${EMULATION_NAME}_parse_args NULL
1622 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1623 cat >>e${EMULATION_NAME}.c <<EOF
1624 #define gld${EMULATION_NAME}_list_options NULL
1629 cat >>e${EMULATION_NAME}.c <<EOF
1631 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1633 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1634 ${LDEMUL_SYSLIB-syslib_default},
1635 ${LDEMUL_HLL-hll_default},
1636 ${LDEMUL_AFTER_PARSE-after_parse_default},
1637 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1638 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1639 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1640 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1641 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1642 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1643 "${EMULATION_NAME}",
1645 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1646 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1647 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1648 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1649 ${LDEMUL_SET_SYMBOLS-NULL},
1650 ${LDEMUL_PARSE_ARGS-gld${EMULATION_NAME}_parse_args},
1651 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1652 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1653 ${LDEMUL_RECOGNIZED_FILE-NULL},
1654 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},