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 /* Find the last output section before given output statement.
1010 Used by place_orphan. */
1013 output_prev_sec_find (os)
1014 lang_output_section_statement_type *os;
1016 asection *s = (asection *) NULL;
1017 lang_statement_union_type *u;
1018 lang_output_section_statement_type *lookup;
1020 for (u = lang_output_section_statement.head;
1021 u != (lang_statement_union_type *) NULL;
1024 lookup = &u->output_section_statement;
1027 if (lookup->bfd_section != NULL
1028 && lookup->bfd_section != bfd_abs_section_ptr
1029 && lookup->bfd_section != bfd_com_section_ptr
1030 && lookup->bfd_section != bfd_und_section_ptr)
1031 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 have already placed a section with this name. */
1085 wild_doit (&os->children, s, os, file);
1090 if (hold_text.os == NULL)
1091 hold_text.os = lang_output_section_find (".text");
1093 /* If this is a final link, then always put .gnu.warning.SYMBOL
1094 sections into the .text section to get them out of the way. */
1095 if (! link_info.shared
1096 && ! link_info.relocateable
1097 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1098 && hold_text.os != NULL)
1100 wild_doit (&hold_text.os->children, s, hold_text.os, file);
1104 /* Decide which segment the section should go in based on the
1105 section name and section flags. We put loadable .note sections
1106 right after the .interp section, so that the PT_NOTE segment is
1107 stored right after the program headers where the OS can read it
1108 in the first page. */
1109 #define HAVE_SECTION(hold, name) \
1110 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1112 if (s->flags & SEC_EXCLUDE)
1116 if ((s->flags & SEC_ALLOC) == 0)
1118 else if ((s->flags & SEC_LOAD) != 0
1119 && strncmp (secname, ".note", 5) == 0
1120 && HAVE_SECTION (hold_interp, ".interp"))
1121 place = &hold_interp;
1122 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1123 && HAVE_SECTION (hold_bss, ".bss"))
1125 else if ((s->flags & SEC_SMALL_DATA) != 0
1126 && HAVE_SECTION (hold_sdata, ".sdata"))
1127 place = &hold_sdata;
1128 else if ((s->flags & SEC_READONLY) == 0
1129 && HAVE_SECTION (hold_data, ".data"))
1131 else if (strncmp (secname, ".rel", 4) == 0
1132 && (hold_rel.os != NULL
1133 || (hold_rel.os = output_rel_find ()) != NULL))
1135 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == SEC_READONLY
1136 && HAVE_SECTION (hold_rodata, ".rodata"))
1137 place = &hold_rodata;
1138 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == (SEC_CODE | SEC_READONLY)
1139 && hold_text.os != NULL)
1144 /* Choose a unique name for the section. This will be needed if the
1145 same section name appears in the input file with different
1146 loadable or allocatable characteristics. */
1147 outsecname = secname;
1148 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1150 outsecname = bfd_get_unique_section_name (output_bfd,
1153 if (outsecname == NULL)
1154 einfo ("%F%P: place_orphan failed: %E\n");
1157 /* Start building a list of statements for this section.
1158 First save the current statement pointer. */
1161 /* If we have found an appropriate place for the output section
1162 statements for this orphan, add them to our own private list,
1163 inserting them later into the global statement list. */
1167 lang_list_init (stat_ptr);
1170 if (config.build_constructors)
1172 /* If the name of the section is representable in C, then create
1173 symbols to mark the start and the end of the section. */
1174 for (ps = outsecname; *ps != '\0'; ps++)
1175 if (! isalnum ((unsigned char) *ps) && *ps != '_')
1180 etree_type *e_align;
1182 symname = (char *) xmalloc (ps - outsecname + sizeof "__start_");
1183 sprintf (symname, "__start_%s", outsecname);
1184 e_align = exp_unop (ALIGN_K,
1185 exp_intop ((bfd_vma) 1 << s->alignment_power));
1186 lang_add_assignment (exp_assop ('=', symname, e_align));
1190 if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1191 address = exp_intop ((bfd_vma) 0);
1195 os = lang_enter_output_section_statement (outsecname, address, 0,
1197 (etree_type *) NULL,
1198 (etree_type *) NULL,
1199 (etree_type *) NULL);
1201 wild_doit (&os->children, s, os, file);
1203 lang_leave_output_section_statement
1204 ((bfd_vma) 0, "*default*",
1205 (struct lang_output_section_phdr_list *) NULL, "*default*");
1207 if (config.build_constructors && *ps == '\0')
1211 /* lang_leave_ouput_section_statement resets stat_ptr. Put
1212 stat_ptr back where we want it. */
1216 symname = (char *) xmalloc (ps - outsecname + sizeof "__stop_");
1217 sprintf (symname, "__stop_%s", outsecname);
1218 lang_add_assignment (exp_assop ('=', symname,
1219 exp_nameop (NAME, ".")));
1222 /* Restore the global list pointer. */
1227 asection *snew, **pps, *bfd_section;
1229 snew = os->bfd_section;
1230 bfd_section = place->os->bfd_section;
1231 if (place->section == NULL && bfd_section == NULL)
1232 bfd_section = output_prev_sec_find (place->os);
1234 if (place->section != NULL
1235 || (bfd_section != NULL
1236 && bfd_section != snew))
1238 /* Shuffle the section to make the output file look neater.
1239 This is really only cosmetic. */
1240 if (place->section == NULL)
1243 /* Finding the end of the list is a little tricky. We
1244 make a wild stab at it by comparing section flags. */
1245 flagword first_flags = bfd_section->flags;
1246 for (pps = &bfd_section->next;
1247 *pps != NULL && (*pps)->flags == first_flags;
1248 pps = &(*pps)->next)
1250 place->section = pps;
1252 /* Put orphans after the first section on the list. */
1253 place->section = &bfd_section->next;
1257 /* Unlink the section. */
1258 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1262 /* Now tack it on to the "place->os" section list. */
1263 snew->next = *place->section;
1264 *place->section = snew;
1266 place->section = &snew->next; /* Save the end of this list. */
1268 if (add.head != NULL)
1270 /* We try to put the output statements in some sort of
1271 reasonable order here, because they determine the final
1272 load addresses of the orphan sections. */
1273 if (place->stmt == NULL)
1275 /* Put the new statement list right at the head. */
1276 *add.tail = place->os->header.next;
1277 place->os->header.next = add.head;
1281 /* Put it after the last orphan statement we added. */
1282 *add.tail = *place->stmt;
1283 *place->stmt = add.head;
1286 /* Fix the global list pointer if we happened to tack our
1287 new list at the tail. */
1288 if (*old->tail == add.head)
1289 old->tail = add.tail;
1291 /* Save the end of this list. */
1292 place->stmt = add.tail;
1302 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1303 cat >>e${EMULATION_NAME}.c <<EOF
1306 gld${EMULATION_NAME}_get_script (isfile)
1310 if test -n "$COMPILE_IN"
1312 # Scripts compiled in.
1314 # sed commands to quote an ld script as a C string.
1315 sc="-f stringify.sed"
1317 cat >>e${EMULATION_NAME}.c <<EOF
1321 if (link_info.relocateable == true && config.build_constructors == true)
1324 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1325 echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1326 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1327 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1328 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1329 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1330 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1332 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1333 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1334 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1337 echo ' ; else return' >> e${EMULATION_NAME}.c
1338 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1339 echo '; }' >> e${EMULATION_NAME}.c
1342 # Scripts read from the filesystem.
1344 cat >>e${EMULATION_NAME}.c <<EOF
1348 if (link_info.relocateable == true && config.build_constructors == true)
1349 return "ldscripts/${EMULATION_NAME}.xu";
1350 else if (link_info.relocateable == true)
1351 return "ldscripts/${EMULATION_NAME}.xr";
1352 else if (!config.text_read_only)
1353 return "ldscripts/${EMULATION_NAME}.xbn";
1354 else if (!config.magic_demand_paged)
1355 return "ldscripts/${EMULATION_NAME}.xn";
1356 else if (link_info.shared)
1357 return "ldscripts/${EMULATION_NAME}.xs";
1359 return "ldscripts/${EMULATION_NAME}.x";
1366 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1368 if test x"$LDEMUL_PARSE_ARGS" != xgld"$EMULATION_NAME"_parse_args; then
1370 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1371 cat >>e${EMULATION_NAME}.c <<EOF
1372 $PARSE_AND_LIST_PROLOGUE
1376 cat >>e${EMULATION_NAME}.c <<EOF
1380 #define OPTION_DISABLE_NEW_DTAGS (400)
1381 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1382 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1384 static struct option longopts[] =
1388 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1389 cat >>e${EMULATION_NAME}.c <<EOF
1390 /* getopt allows abbreviations, so we do this to stop it from
1391 treating -d/-e as abbreviations for these options. */
1392 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1393 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1394 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1395 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1396 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1397 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1401 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1402 cat >>e${EMULATION_NAME}.c <<EOF
1403 $PARSE_AND_LIST_LONGOPTS
1407 cat >>e${EMULATION_NAME}.c <<EOF
1408 {NULL, no_argument, NULL, 0}
1412 static int gld${EMULATION_NAME}_parse_args PARAMS ((int, char **));
1415 gld${EMULATION_NAME}_parse_args (argc, argv)
1421 static int prevoptind = -1;
1422 int prevopterr = opterr;
1425 if (prevoptind != optind)
1429 prevoptind = optind;
1431 optc = getopt_long_only (argc, argv,
1432 "-${PARSE_AND_LIST_SHORTOPTS}z:", longopts,
1434 opterr = prevopterr;
1441 optind = prevoptind;
1446 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1447 cat >>e${EMULATION_NAME}.c <<EOF
1448 case OPTION_DISABLE_NEW_DTAGS:
1449 link_info.new_dtags = false;
1452 case OPTION_ENABLE_NEW_DTAGS:
1453 link_info.new_dtags = true;
1457 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1458 /* Groups must be self-contained. */
1459 link_info.no_undefined = true;
1463 if (strcmp (optarg, "initfirst") == 0)
1464 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1465 else if (strcmp (optarg, "interpose") == 0)
1466 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1467 else if (strcmp (optarg, "loadfltr") == 0)
1468 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1469 else if (strcmp (optarg, "nodefaultlib") == 0)
1470 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1471 else if (strcmp (optarg, "nodelete") == 0)
1472 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1473 else if (strcmp (optarg, "nodlopen") == 0)
1474 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1475 else if (strcmp (optarg, "nodump") == 0)
1476 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1477 else if (strcmp (optarg, "now") == 0)
1479 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1480 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1482 else if (strcmp (optarg, "origin") == 0)
1484 link_info.flags |= (bfd_vma) DF_ORIGIN;
1485 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1487 else if (strcmp (optarg, "defs") == 0)
1488 link_info.no_undefined = true;
1489 /* What about the other Solaris -z options? FIXME. */
1494 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1495 cat >>e${EMULATION_NAME}.c <<EOF
1496 $PARSE_AND_LIST_ARGS_CASES
1500 cat >>e${EMULATION_NAME}.c <<EOF
1509 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1510 cat >>e${EMULATION_NAME}.c <<EOF
1512 static void gld${EMULATION_NAME}_list_options PARAMS ((FILE * file));
1515 gld${EMULATION_NAME}_list_options (file)
1520 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1521 cat >>e${EMULATION_NAME}.c <<EOF
1522 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1523 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1524 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1525 fprintf (file, _(" -z defs\t\tDisallows undefined symbols\n"));
1526 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1527 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1528 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1529 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1530 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1531 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1532 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1533 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1534 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n"));
1535 fprintf (file, _("\t\t\t at runtime\n"));
1536 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1540 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1541 cat >>e${EMULATION_NAME}.c <<EOF
1542 $PARSE_AND_LIST_OPTIONS
1546 cat >>e${EMULATION_NAME}.c <<EOF
1550 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1551 cat >>e${EMULATION_NAME}.c <<EOF
1552 $PARSE_AND_LIST_EPILOGUE
1557 if test x"$LDEMUL_PARSE_ARGS" != xgld"$EMULATION_NAME"_parse_args; then
1558 cat >>e${EMULATION_NAME}.c <<EOF
1559 #define gld${EMULATION_NAME}_parse_args NULL
1562 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1563 cat >>e${EMULATION_NAME}.c <<EOF
1564 #define gld${EMULATION_NAME}_list_options NULL
1569 cat >>e${EMULATION_NAME}.c <<EOF
1571 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1573 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1574 ${LDEMUL_SYSLIB-syslib_default},
1575 ${LDEMUL_HLL-hll_default},
1576 ${LDEMUL_AFTER_PARSE-after_parse_default},
1577 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1578 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1579 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1580 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1581 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1582 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1583 "${EMULATION_NAME}",
1585 ${LDEMUL_FINISH-NULL},
1586 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1587 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1588 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1589 ${LDEMUL_SET_SYMBOLS-NULL},
1590 ${LDEMUL_PARSE_ARGS-gld${EMULATION_NAME}_parse_args},
1591 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1592 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1593 ${LDEMUL_RECOGNIZED_FILE-NULL},
1594 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},