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"
54 #include "elf/common.h"
56 static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
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 PARAMS ((const char *, int));
62 static boolean gld${EMULATION_NAME}_search_needed
63 PARAMS ((const char *, const char *, int));
64 static void gld${EMULATION_NAME}_check_needed
65 PARAMS ((lang_input_statement_type *));
66 static void gld${EMULATION_NAME}_after_open PARAMS ((void));
67 static void gld${EMULATION_NAME}_find_exp_assignment PARAMS ((etree_type *));
68 static void gld${EMULATION_NAME}_find_statement_assignment
69 PARAMS ((lang_statement_union_type *));
70 static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
71 static boolean gld${EMULATION_NAME}_open_dynamic_archive
72 PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
73 static lang_output_section_statement_type *output_rel_find PARAMS ((void));
74 static boolean gld${EMULATION_NAME}_place_orphan
75 PARAMS ((lang_input_statement_type *, asection *));
76 static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile));
80 # Import any needed special functions and/or overrides.
82 if test -n "$EXTRA_EM_FILE" ; then
83 . ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
86 # Functions in this file can be overridden by setting the LDEMUL_* shell
87 # variables. If the name of the overriding function is the same as is
88 # defined in this file, then don't output this file's version.
89 # If a different overriding name is given then output the standard function
90 # as presumably it is called from the overriding function.
92 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
93 cat >>e${EMULATION_NAME}.c <<EOF
96 gld${EMULATION_NAME}_before_parse ()
98 const bfd_arch_info_type *arch = bfd_scan_arch ("${OUTPUT_ARCH}");
101 ldfile_output_architecture = arch->arch;
102 ldfile_output_machine = arch->mach;
103 ldfile_output_machine_name = arch->printable_name;
106 ldfile_output_architecture = bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`;
107 config.dynamic_link = ${DYNAMIC_LINK-true};
108 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo true ; else echo false ; fi`;
114 cat >>e${EMULATION_NAME}.c <<EOF
116 /* These variables are required to pass information back and forth
117 between after_open and check_needed and stat_needed and vercheck. */
119 static struct bfd_link_needed_list *global_needed;
120 static struct stat global_stat;
121 static boolean global_found;
122 static struct bfd_link_needed_list *global_vercheck_needed;
123 static boolean global_vercheck_failed;
126 /* On Linux, it's possible to have different versions of the same
127 shared library linked against different versions of libc. The
128 dynamic linker somehow tags which libc version to use in
129 /etc/ld.so.cache, and, based on the libc that it sees in the
130 executable, chooses which version of the shared library to use.
132 We try to do a similar check here by checking whether this shared
133 library needs any other shared libraries which may conflict with
134 libraries we have already included in the link. If it does, we
135 skip it, and try to find another shared library farther on down the
138 This is called via lang_for_each_input_file.
139 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
140 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
141 a conflicting version. */
144 gld${EMULATION_NAME}_vercheck (s)
145 lang_input_statement_type *s;
148 struct bfd_link_needed_list *l;
150 if (global_vercheck_failed)
152 if (s->the_bfd == NULL
153 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
156 soname = bfd_elf_get_dt_soname (s->the_bfd);
158 soname = basename (bfd_get_filename (s->the_bfd));
160 for (l = global_vercheck_needed; l != NULL; l = l->next)
164 if (strcmp (soname, l->name) == 0)
166 /* Probably can't happen, but it's an easy check. */
170 if (strchr (l->name, '/') != NULL)
173 suffix = strstr (l->name, ".so.");
177 suffix += sizeof ".so." - 1;
179 if (strncmp (soname, l->name, suffix - l->name) == 0)
181 /* Here we know that S is a dynamic object FOO.SO.VER1, and
182 the object we are considering needs a dynamic object
183 FOO.SO.VER2, and VER1 and VER2 are different. This
184 appears to be a version mismatch, so we tell the caller
185 to try a different version of this library. */
186 global_vercheck_failed = true;
193 /* See if an input file matches a DT_NEEDED entry by running stat on
197 gld${EMULATION_NAME}_stat_needed (s)
198 lang_input_statement_type *s;
206 if (s->the_bfd == NULL)
209 if (bfd_stat (s->the_bfd, &st) != 0)
211 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
215 if (st.st_dev == global_stat.st_dev
216 && st.st_ino == global_stat.st_ino)
222 /* We issue a warning if it looks like we are including two
223 different versions of the same shared library. For example,
224 there may be a problem if -lc picks up libc.so.6 but some other
225 shared library has a DT_NEEDED entry of libc.so.5. This is a
226 heuristic test, and it will only work if the name looks like
227 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
228 If we really want to issue warnings about mixing version numbers
229 of shared libraries, we need to find a better way. */
231 if (strchr (global_needed->name, '/') != NULL)
233 suffix = strstr (global_needed->name, ".so.");
236 suffix += sizeof ".so." - 1;
238 soname = bfd_elf_get_dt_soname (s->the_bfd);
240 soname = basename (s->filename);
242 if (strncmp (soname, global_needed->name,
243 suffix - global_needed->name) == 0)
244 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
245 global_needed->name, global_needed->by, soname);
249 /* This function is called for each possible name for a dynamic object
250 named by a DT_NEEDED entry. The FORCE parameter indicates whether
251 to skip the check for a conflicting version. */
254 gld${EMULATION_NAME}_try_needed (name, force)
261 abfd = bfd_openr (name, bfd_get_target (output_bfd));
264 if (! bfd_check_format (abfd, bfd_object))
266 (void) bfd_close (abfd);
269 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
271 (void) bfd_close (abfd);
275 /* Check whether this object would include any conflicting library
276 versions. If FORCE is set, then we skip this check; we use this
277 the second time around, if we couldn't find any compatible
278 instance of the shared library. */
282 struct bfd_link_needed_list *needed;
284 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
285 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
289 global_vercheck_needed = needed;
290 global_vercheck_failed = false;
291 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
292 if (global_vercheck_failed)
294 (void) bfd_close (abfd);
295 /* Return false to force the caller to move on to try
296 another file on the search path. */
300 /* But wait! It gets much worse. On Linux, if a shared
301 library does not use libc at all, we are supposed to skip
302 it the first time around in case we encounter a shared
303 library later on with the same name which does use the
304 version of libc that we want. This is much too horrible
305 to use on any system other than Linux. */
310 cat >>e${EMULATION_NAME}.c <<EOF
312 struct bfd_link_needed_list *l;
314 for (l = needed; l != NULL; l = l->next)
315 if (strncmp (l->name, "libc.so", 7) == 0)
319 (void) bfd_close (abfd);
327 cat >>e${EMULATION_NAME}.c <<EOF
331 /* We've found a dynamic object matching the DT_NEEDED entry. */
333 /* We have already checked that there is no other input file of the
334 same name. We must now check again that we are not including the
335 same file twice. We need to do this because on many systems
336 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
337 reference libc.so.1. If we have already included libc.so, we
338 don't want to include libc.so.1 if they are the same file, and we
339 can only check that using stat. */
341 if (bfd_stat (abfd, &global_stat) != 0)
342 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
344 /* First strip off everything before the last '/'. */
345 soname = basename (abfd->filename);
347 if (trace_file_tries)
348 info_msg (_("found %s at %s\n"), soname, name);
350 global_found = false;
351 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
354 /* Return true to indicate that we found the file, even though
355 we aren't going to do anything with it. */
359 /* Tell the ELF backend that we don't want the output file to have a
360 DT_NEEDED entry for this file. */
361 bfd_elf_set_dt_needed_name (abfd, "");
363 /* Previos basename call was clobbered in lang_for_each_input_file. */
364 soname = basename (abfd->filename);
366 /* Tell the ELF backend that the output file needs a DT_NEEDED
367 entry for this file if it is used to resolve the reference in
369 bfd_elf_set_dt_needed_soname (abfd, soname);
371 /* Add this file into the symbol table. */
372 if (! bfd_link_add_symbols (abfd, &link_info))
373 einfo ("%F%B: could not read symbols: %E\n", abfd);
379 /* Search for a needed file in a path. */
382 gld${EMULATION_NAME}_search_needed (path, name, force)
391 return gld${EMULATION_NAME}_try_needed (name, force);
393 if (path == NULL || *path == '\0')
398 char *filename, *sset;
400 s = strchr (path, ':');
402 s = path + strlen (path);
404 filename = (char *) xmalloc (s - path + len + 2);
409 memcpy (filename, path, s - path);
410 filename[s - path] = '/';
411 sset = filename + (s - path) + 1;
415 if (gld${EMULATION_NAME}_try_needed (filename, force))
429 if [ "x${host}" = "x${target}" ] ; then
430 case " ${EMULATION_LIBPATH} " in
431 *" ${EMULATION_NAME} "*)
434 cat >>e${EMULATION_NAME}.c <<EOF
436 /* For a native linker, check the file /etc/ld.so.conf for directories
437 in which we may find shared libraries. /etc/ld.so.conf is really
438 only meaningful on Linux. */
440 static boolean gld${EMULATION_NAME}_check_ld_so_conf
441 PARAMS ((const char *, int));
444 gld${EMULATION_NAME}_check_ld_so_conf (name, force)
448 static boolean initialized;
449 static char *ld_so_conf;
455 f = fopen ("/etc/ld.so.conf", FOPEN_RT);
464 b = (char *) xmalloc (alloc);
466 while ((c = getc (f)) != EOF)
468 if (len + 1 >= alloc)
471 b = (char *) xrealloc (b, alloc);
484 if (len > 0 && b[len - 1] != ':')
492 if (len > 0 && b[len - 1] == ':')
511 if (ld_so_conf == NULL)
514 return gld${EMULATION_NAME}_search_needed (ld_so_conf, name, force);
523 cat >>e${EMULATION_NAME}.c <<EOF
525 /* See if an input file matches a DT_NEEDED entry by name. */
528 gld${EMULATION_NAME}_check_needed (s)
529 lang_input_statement_type *s;
534 if (s->filename != NULL)
538 if (strcmp (s->filename, global_needed->name) == 0)
544 if (s->search_dirs_flag)
546 f = strrchr (s->filename, '/');
548 && strcmp (f + 1, global_needed->name) == 0)
556 if (s->the_bfd != NULL)
560 soname = bfd_elf_get_dt_soname (s->the_bfd);
562 && strcmp (soname, global_needed->name) == 0)
572 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
573 cat >>e${EMULATION_NAME}.c <<EOF
575 /* This is called after all the input files have been opened. */
578 gld${EMULATION_NAME}_after_open ()
580 struct bfd_link_needed_list *needed, *l;
582 /* We only need to worry about this when doing a final link. */
583 if (link_info.relocateable || link_info.shared)
586 /* Get the list of files which appear in DT_NEEDED entries in
587 dynamic objects included in the link (often there will be none).
588 For each such file, we want to track down the corresponding
589 library, and include the symbol table in the link. This is what
590 the runtime dynamic linker will do. Tracking the files down here
591 permits one dynamic object to include another without requiring
592 special action by the person doing the link. Note that the
593 needed list can actually grow while we are stepping through this
595 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
596 for (l = needed; l != NULL; l = l->next)
598 struct bfd_link_needed_list *ll;
601 /* If we've already seen this file, skip it. */
602 for (ll = needed; ll != l; ll = ll->next)
603 if (strcmp (ll->name, l->name) == 0)
608 /* See if this file was included in the link explicitly. */
610 global_found = false;
611 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
615 if (trace_file_tries)
616 info_msg (_("%s needed by %B\n"), l->name, l->by);
618 /* We need to find this file and include the symbol table. We
619 want to search for the file in the same way that the dynamic
620 linker will search. That means that we want to use
621 rpath_link, rpath, then the environment variable
622 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
623 entries (native only), then the linker script LIB_SEARCH_DIRS.
624 We do not search using the -L arguments.
626 We search twice. The first time, we skip objects which may
627 introduce version mismatches. The second time, we force
628 their use. See gld${EMULATION_NAME}_vercheck comment. */
629 for (force = 0; force < 2; force++)
632 search_dirs_type *search;
634 if [ "x${host}" = "x${target}" ] ; then
635 case " ${EMULATION_LIBPATH} " in
636 *" ${EMULATION_NAME} "*)
637 cat >>e${EMULATION_NAME}.c <<EOF
638 const char *lib_path;
639 struct bfd_link_needed_list *rp;
645 cat >>e${EMULATION_NAME}.c <<EOF
647 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
651 if [ "x${host}" = "x${target}" ] ; then
652 case " ${EMULATION_LIBPATH} " in
653 *" ${EMULATION_NAME} "*)
654 cat >>e${EMULATION_NAME}.c <<EOF
655 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
658 if (command_line.rpath_link == NULL
659 && command_line.rpath == NULL)
661 lib_path = (const char *) getenv ("LD_RUN_PATH");
662 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name,
666 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
667 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, force))
671 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
672 for (; !found && rp != NULL; rp = rp->next)
674 found = (rp->by == l->by
675 && gld${EMULATION_NAME}_search_needed (rp->name,
686 cat >>e${EMULATION_NAME}.c <<EOF
687 len = strlen (l->name);
688 for (search = search_head; search != NULL; search = search->next)
694 filename = (char *) xmalloc (strlen (search->name) + len + 2);
695 sprintf (filename, "%s/%s", search->name, l->name);
696 if (gld${EMULATION_NAME}_try_needed (filename, force))
703 if [ "x${host}" = "x${target}" ] ; then
704 case " ${EMULATION_LIBPATH} " in
705 *" ${EMULATION_NAME} "*)
708 cat >>e${EMULATION_NAME}.c <<EOF
709 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
718 cat >>e${EMULATION_NAME}.c <<EOF
724 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
732 cat >>e${EMULATION_NAME}.c <<EOF
734 /* Look through an expression for an assignment statement. */
737 gld${EMULATION_NAME}_find_exp_assignment (exp)
740 struct bfd_link_hash_entry *h;
742 switch (exp->type.node_class)
745 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
746 false, false, false);
750 /* We call record_link_assignment even if the symbol is defined.
751 This is because if it is defined by a dynamic object, we
752 actually want to use the value defined by the linker script,
753 not the value from the dynamic object (because we are setting
754 symbols like etext). If the symbol is defined by a regular
755 object, then, as it happens, calling record_link_assignment
760 if (strcmp (exp->assign.dst, ".") != 0)
762 if (! (bfd_elf${ELFSIZE}_record_link_assignment
763 (output_bfd, &link_info, exp->assign.dst,
764 exp->type.node_class == etree_provide ? true : false)))
765 einfo ("%P%F: failed to record assignment to %s: %E\n",
768 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
772 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
773 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
777 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
778 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
779 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
783 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
792 /* This is called by the before_allocation routine via
793 lang_for_each_statement. It locates any assignment statements, and
794 tells the ELF backend about them, in case they are assignments to
795 symbols which are referred to by dynamic objects. */
798 gld${EMULATION_NAME}_find_statement_assignment (s)
799 lang_statement_union_type *s;
801 if (s->header.type == lang_assignment_statement_enum)
802 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
807 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
808 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
809 ELF_INTERPRETER_SET_DEFAULT="
812 sinterp->contents = ${ELF_INTERPRETER_NAME};
813 sinterp->_raw_size = strlen (sinterp->contents) + 1;
818 ELF_INTERPRETER_SET_DEFAULT=
820 cat >>e${EMULATION_NAME}.c <<EOF
822 /* This is called after the sections have been attached to output
823 sections, but before any sizes or addresses have been set. */
826 gld${EMULATION_NAME}_before_allocation ()
831 /* If we are going to make any variable assignments, we need to let
832 the ELF backend know about them in case the variables are
833 referred to by dynamic objects. */
834 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
836 /* Let the ELF backend work out the sizes of any sections required
837 by dynamic linking. */
838 rpath = command_line.rpath;
840 rpath = (const char *) getenv ("LD_RUN_PATH");
841 if (! (bfd_elf${ELFSIZE}_size_dynamic_sections
842 (output_bfd, command_line.soname, rpath,
843 command_line.filter_shlib,
844 (const char * const *) command_line.auxiliary_filters,
845 &link_info, &sinterp, lang_elf_version_info)))
846 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
847 ${ELF_INTERPRETER_SET_DEFAULT}
848 /* Let the user override the dynamic linker we are using. */
849 if (command_line.interpreter != NULL
852 sinterp->contents = (bfd_byte *) command_line.interpreter;
853 sinterp->_raw_size = strlen (command_line.interpreter) + 1;
856 /* Look for any sections named .gnu.warning. As a GNU extensions,
857 we treat such sections as containing warning messages. We print
858 out the warning message, and then zero out the section size so
859 that it does not get copied into the output file. */
862 LANG_FOR_EACH_INPUT_STATEMENT (is)
869 if (is->just_syms_flag)
872 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
876 sz = bfd_section_size (is->the_bfd, s);
877 msg = xmalloc ((size_t) sz + 1);
878 if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
879 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
882 ret = link_info.callbacks->warning (&link_info, msg,
884 is->the_bfd, (asection *) NULL,
889 /* Clobber the section size, so that we don't waste copying the
890 warning into the output file. */
899 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
900 cat >>e${EMULATION_NAME}.c <<EOF
902 /* Try to open a dynamic archive. This is where we know that ELF
903 dynamic libraries have an extension of .so (or .sl on oddball systems
907 gld${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
909 search_dirs_type *search;
910 lang_input_statement_type *entry;
912 const char *filename;
915 if (! entry->is_archive)
918 filename = entry->filename;
920 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
921 is defined, but it does not seem worth the headache to optimize
922 away those two bytes of space. */
923 string = (char *) xmalloc (strlen (search->name)
926 #ifdef EXTRA_SHLIB_EXTENSION
927 + strlen (EXTRA_SHLIB_EXTENSION)
931 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
933 #ifdef EXTRA_SHLIB_EXTENSION
934 /* Try the .so extension first. If that fails build a new filename
935 using EXTRA_SHLIB_EXTENSION. */
936 if (! ldfile_try_open_bfd (string, entry))
937 sprintf (string, "%s/lib%s%s%s", search->name,
938 filename, arch, EXTRA_SHLIB_EXTENSION);
941 if (! ldfile_try_open_bfd (string, entry))
947 entry->filename = string;
949 /* We have found a dynamic object to include in the link. The ELF
950 backend linker will create a DT_NEEDED entry in the .dynamic
951 section naming this file. If this file includes a DT_SONAME
952 entry, it will be used. Otherwise, the ELF linker will just use
953 the name of the file. For an archive found by searching, like
954 this one, the DT_NEEDED entry should consist of just the name of
955 the file, without the path information used to find it. Note
956 that we only need to do this if we have a dynamic object; an
957 archive will never be referenced by a DT_NEEDED entry.
959 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
960 very pretty. I haven't been able to think of anything that is
962 if (bfd_check_format (entry->the_bfd, bfd_object)
963 && (entry->the_bfd->flags & DYNAMIC) != 0)
965 ASSERT (entry->is_archive && entry->search_dirs_flag);
967 /* Rather than duplicating the logic above. Just use the
968 filename we recorded earlier. */
970 filename = xstrdup (basename (entry->filename));
971 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
979 cat >>e${EMULATION_NAME}.c <<EOF
981 /* A variant of lang_output_section_find. Used by place_orphan. */
983 static lang_output_section_statement_type *
986 lang_statement_union_type *u;
987 lang_output_section_statement_type *lookup;
989 for (u = lang_output_section_statement.head;
990 u != (lang_statement_union_type *) NULL;
993 lookup = &u->output_section_statement;
994 if (strncmp (".rel", lookup->name, 4) == 0
995 && lookup->bfd_section != NULL
996 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1001 return (lang_output_section_statement_type *) NULL;
1006 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1007 cat >>e${EMULATION_NAME}.c <<EOF
1009 /* Place an orphan section. We use this to put random SHF_ALLOC
1010 sections in the right segment. */
1012 struct orphan_save {
1013 lang_output_section_statement_type *os;
1015 lang_statement_union_type **stmt;
1019 gld${EMULATION_NAME}_place_orphan (file, s)
1020 lang_input_statement_type *file;
1023 static struct orphan_save hold_text;
1024 static struct orphan_save hold_rodata;
1025 static struct orphan_save hold_data;
1026 static struct orphan_save hold_bss;
1027 static struct orphan_save hold_rel;
1028 static struct orphan_save hold_interp;
1029 static struct orphan_save hold_sdata;
1030 static int count = 1;
1031 struct orphan_save *place;
1032 lang_statement_list_type *old;
1033 lang_statement_list_type add;
1034 etree_type *address;
1035 const char *secname;
1036 const char *outsecname;
1037 const char *ps = NULL;
1038 lang_output_section_statement_type *os;
1040 secname = bfd_get_section_name (s->owner, s);
1042 if (! config.unique_orphan_sections && ! unique_section_p (secname))
1044 /* Look through the script to see where to place this section. */
1045 os = lang_output_section_find (secname);
1048 && os->bfd_section != NULL
1049 && ((s->flags ^ os->bfd_section->flags)
1050 & (SEC_LOAD | SEC_ALLOC)) == 0)
1052 /* We have already placed a section with this name. */
1053 wild_doit (&os->children, s, os, file);
1058 if (hold_text.os == NULL)
1059 hold_text.os = lang_output_section_find (".text");
1061 /* If this is a final link, then always put .gnu.warning.SYMBOL
1062 sections into the .text section to get them out of the way. */
1063 if (! link_info.shared
1064 && ! link_info.relocateable
1065 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1066 && hold_text.os != NULL)
1068 wild_doit (&hold_text.os->children, s, hold_text.os, file);
1072 /* Decide which segment the section should go in based on the
1073 section name and section flags. We put loadable .note sections
1074 right after the .interp section, so that the PT_NOTE segment is
1075 stored right after the program headers where the OS can read it
1076 in the first page. */
1077 #define HAVE_SECTION(hold, name) \
1078 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1080 if (s->flags & SEC_EXCLUDE)
1084 if ((s->flags & SEC_ALLOC) == 0)
1086 else if ((s->flags & SEC_LOAD) != 0
1087 && strncmp (secname, ".note", 5) == 0
1088 && HAVE_SECTION (hold_interp, ".interp"))
1089 place = &hold_interp;
1090 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1091 && HAVE_SECTION (hold_bss, ".bss"))
1093 else if ((s->flags & SEC_SMALL_DATA) != 0
1094 && HAVE_SECTION (hold_sdata, ".sdata"))
1095 place = &hold_sdata;
1096 else if ((s->flags & SEC_READONLY) == 0
1097 && HAVE_SECTION (hold_data, ".data"))
1099 else if (strncmp (secname, ".rel", 4) == 0
1100 && (hold_rel.os != NULL
1101 || (hold_rel.os = output_rel_find ()) != NULL))
1103 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == SEC_READONLY
1104 && HAVE_SECTION (hold_rodata, ".rodata"))
1105 place = &hold_rodata;
1106 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == (SEC_CODE | SEC_READONLY)
1107 && hold_text.os != NULL)
1112 /* Choose a unique name for the section. This will be needed if the
1113 same section name appears in the input file with different
1114 loadable or allocatable characteristics. */
1115 outsecname = secname;
1116 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1118 outsecname = bfd_get_unique_section_name (output_bfd,
1121 if (outsecname == NULL)
1122 einfo ("%F%P: place_orphan failed: %E\n");
1125 /* Start building a list of statements for this section.
1126 First save the current statement pointer. */
1129 /* If we have found an appropriate place for the output section
1130 statements for this orphan, add them to our own private list,
1131 inserting them later into the global statement list. */
1135 lang_list_init (stat_ptr);
1138 if (config.build_constructors)
1140 /* If the name of the section is representable in C, then create
1141 symbols to mark the start and the end of the section. */
1142 for (ps = outsecname; *ps != '\0'; ps++)
1143 if (! isalnum ((unsigned char) *ps) && *ps != '_')
1148 etree_type *e_align;
1150 symname = (char *) xmalloc (ps - outsecname + sizeof "__start_");
1151 sprintf (symname, "__start_%s", outsecname);
1152 e_align = exp_unop (ALIGN_K,
1153 exp_intop ((bfd_vma) 1 << s->alignment_power));
1154 lang_add_assignment (exp_assop ('=', symname, e_align));
1158 if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1159 address = exp_intop ((bfd_vma) 0);
1163 os = lang_enter_output_section_statement (outsecname, address, 0,
1165 (etree_type *) NULL,
1166 (etree_type *) NULL,
1167 (etree_type *) NULL);
1169 wild_doit (&os->children, s, os, file);
1171 lang_leave_output_section_statement
1172 ((bfd_vma) 0, "*default*",
1173 (struct lang_output_section_phdr_list *) NULL, "*default*");
1175 if (config.build_constructors && *ps == '\0')
1179 /* lang_leave_ouput_section_statement resets stat_ptr. Put
1180 stat_ptr back where we want it. */
1184 symname = (char *) xmalloc (ps - outsecname + sizeof "__stop_");
1185 sprintf (symname, "__stop_%s", outsecname);
1186 lang_add_assignment (exp_assop ('=', symname,
1187 exp_nameop (NAME, ".")));
1190 /* Restore the global list pointer. */
1195 asection *snew, **pps;
1197 snew = os->bfd_section;
1198 if (place->section != NULL
1199 || (place->os->bfd_section != NULL
1200 && place->os->bfd_section != snew))
1202 /* Shuffle the section to make the output file look neater.
1203 This is really only cosmetic. */
1204 if (place->section == NULL)
1207 /* Finding the end of the list is a little tricky. We
1208 make a wild stab at it by comparing section flags. */
1209 flagword first_flags = place->os->bfd_section->flags;
1210 for (pps = &place->os->bfd_section->next;
1211 *pps != NULL && (*pps)->flags == first_flags;
1212 pps = &(*pps)->next)
1214 place->section = pps;
1216 /* Put orphans after the first section on the list. */
1217 place->section = &place->os->bfd_section->next;
1221 /* Unlink the section. */
1222 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1226 /* Now tack it on to the "place->os" section list. */
1227 snew->next = *place->section;
1228 *place->section = snew;
1230 place->section = &snew->next; /* Save the end of this list. */
1232 if (add.head != NULL)
1234 /* We try to put the output statements in some sort of
1235 reasonable order here, because they determine the final
1236 load addresses of the orphan sections. */
1237 if (place->stmt == NULL)
1239 /* Put the new statement list right at the head. */
1240 *add.tail = place->os->header.next;
1241 place->os->header.next = add.head;
1245 /* Put it after the last orphan statement we added. */
1246 *add.tail = *place->stmt;
1247 *place->stmt = add.head;
1250 /* Fix the global list pointer if we happened to tack our
1251 new list at the tail. */
1252 if (*old->tail == add.head)
1253 old->tail = add.tail;
1255 /* Save the end of this list. */
1256 place->stmt = add.tail;
1266 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1267 cat >>e${EMULATION_NAME}.c <<EOF
1270 gld${EMULATION_NAME}_get_script (isfile)
1274 if test -n "$COMPILE_IN"
1276 # Scripts compiled in.
1278 # sed commands to quote an ld script as a C string.
1279 sc="-f stringify.sed"
1281 cat >>e${EMULATION_NAME}.c <<EOF
1285 if (link_info.relocateable == true && config.build_constructors == true)
1288 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1289 echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1290 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1291 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1292 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1293 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1294 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1296 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1297 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1298 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1301 echo ' ; else return' >> e${EMULATION_NAME}.c
1302 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1303 echo '; }' >> e${EMULATION_NAME}.c
1306 # Scripts read from the filesystem.
1308 cat >>e${EMULATION_NAME}.c <<EOF
1312 if (link_info.relocateable == true && config.build_constructors == true)
1313 return "ldscripts/${EMULATION_NAME}.xu";
1314 else if (link_info.relocateable == true)
1315 return "ldscripts/${EMULATION_NAME}.xr";
1316 else if (!config.text_read_only)
1317 return "ldscripts/${EMULATION_NAME}.xbn";
1318 else if (!config.magic_demand_paged)
1319 return "ldscripts/${EMULATION_NAME}.xn";
1320 else if (link_info.shared)
1321 return "ldscripts/${EMULATION_NAME}.xs";
1323 return "ldscripts/${EMULATION_NAME}.x";
1330 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1332 if test x"$LDEMUL_PARSE_ARGS" != xgld"$EMULATION_NAME"_parse_args; then
1334 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1335 cat >>e${EMULATION_NAME}.c <<EOF
1336 $PARSE_AND_LIST_PROLOGUE
1340 cat >>e${EMULATION_NAME}.c <<EOF
1344 #define OPTION_DISABLE_NEW_DTAGS (400)
1345 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1346 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1348 static struct option longopts[] =
1352 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1353 cat >>e${EMULATION_NAME}.c <<EOF
1354 /* getopt allows abbreviations, so we do this to stop it from
1355 treating -d/-e as abbreviations for these options. */
1356 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1357 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1358 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1359 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1360 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1361 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1365 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1366 cat >>e${EMULATION_NAME}.c <<EOF
1367 $PARSE_AND_LIST_LONGOPTS
1371 cat >>e${EMULATION_NAME}.c <<EOF
1372 {NULL, no_argument, NULL, 0}
1376 static int gld${EMULATION_NAME}_parse_args PARAMS ((int, char **));
1379 gld${EMULATION_NAME}_parse_args (argc, argv)
1385 static int prevoptind = -1;
1386 int prevopterr = opterr;
1389 if (prevoptind != optind)
1393 prevoptind = optind;
1395 optc = getopt_long_only (argc, argv,
1396 "-${PARSE_AND_LIST_SHORTOPTS}z:", longopts,
1398 opterr = prevopterr;
1405 optind = prevoptind;
1410 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1411 cat >>e${EMULATION_NAME}.c <<EOF
1412 case OPTION_DISABLE_NEW_DTAGS:
1413 link_info.new_dtags = false;
1416 case OPTION_ENABLE_NEW_DTAGS:
1417 link_info.new_dtags = true;
1421 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1422 /* Groups must be self-contained. */
1423 link_info.no_undefined = true;
1427 if (strcmp (optarg, "initfirst") == 0)
1428 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1429 else if (strcmp (optarg, "interpose") == 0)
1430 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1431 else if (strcmp (optarg, "loadfltr") == 0)
1432 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1433 else if (strcmp (optarg, "nodefaultlib") == 0)
1434 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1435 else if (strcmp (optarg, "nodelete") == 0)
1436 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1437 else if (strcmp (optarg, "nodlopen") == 0)
1438 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1439 else if (strcmp (optarg, "nodump") == 0)
1440 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1441 else if (strcmp (optarg, "now") == 0)
1443 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1444 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1446 else if (strcmp (optarg, "origin") == 0)
1448 link_info.flags |= (bfd_vma) DF_ORIGIN;
1449 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1451 else if (strcmp (optarg, "defs") == 0)
1452 link_info.no_undefined = true;
1453 /* What about the other Solaris -z options? FIXME. */
1458 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1459 cat >>e${EMULATION_NAME}.c <<EOF
1460 $PARSE_AND_LIST_ARGS_CASES
1464 cat >>e${EMULATION_NAME}.c <<EOF
1473 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1474 cat >>e${EMULATION_NAME}.c <<EOF
1476 static void gld${EMULATION_NAME}_list_options PARAMS ((FILE * file));
1479 gld${EMULATION_NAME}_list_options (file)
1484 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1485 cat >>e${EMULATION_NAME}.c <<EOF
1486 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1487 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1488 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1489 fprintf (file, _(" -z defs\t\tDisallows undefined symbols\n"));
1490 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1491 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1492 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1493 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1494 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1495 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1496 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1497 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1498 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n"));
1499 fprintf (file, _("\t\t\t at runtime\n"));
1500 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1504 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1505 cat >>e${EMULATION_NAME}.c <<EOF
1506 $PARSE_AND_LIST_OPTIONS
1510 cat >>e${EMULATION_NAME}.c <<EOF
1514 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1515 cat >>e${EMULATION_NAME}.c <<EOF
1516 $PARSE_AND_LIST_EPILOGUE
1521 if test x"$LDEMUL_PARSE_ARGS" != xgld"$EMULATION_NAME"_parse_args; then
1522 cat >>e${EMULATION_NAME}.c <<EOF
1523 #define gld${EMULATION_NAME}_parse_args NULL
1526 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1527 cat >>e${EMULATION_NAME}.c <<EOF
1528 #define gld${EMULATION_NAME}_list_options NULL
1533 cat >>e${EMULATION_NAME}.c <<EOF
1535 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1537 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1538 ${LDEMUL_SYSLIB-syslib_default},
1539 ${LDEMUL_HLL-hll_default},
1540 ${LDEMUL_AFTER_PARSE-after_parse_default},
1541 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1542 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1543 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1544 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1545 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1546 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1547 "${EMULATION_NAME}",
1549 ${LDEMUL_FINISH-NULL},
1550 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1551 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1552 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1553 ${LDEMUL_SET_SYMBOLS-NULL},
1554 ${LDEMUL_PARSE_ARGS-gld${EMULATION_NAME}_parse_args},
1555 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1556 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1557 ${LDEMUL_RECOGNIZED_FILE-NULL},
1558 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},