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 cat >e${EMULATION_NAME}.c <<EOF
7 /* This file is is generated by a shell script. DO NOT EDIT! */
9 /* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
10 Copyright (C) 1991, 93, 94, 95, 1996 Free Software Foundation, Inc.
11 Written by Steve Chamberlain <sac@cygnus.com>
12 ELF support by Ian Lance Taylor <ian@cygnus.com>
14 This file is part of GLD, the Gnu Linker.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 2 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30 #define TARGET_IS_${EMULATION_NAME}
48 static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
49 static boolean gld${EMULATION_NAME}_open_dynamic_archive
50 PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
51 static void gld${EMULATION_NAME}_after_open PARAMS ((void));
52 static void gld${EMULATION_NAME}_check_needed
53 PARAMS ((lang_input_statement_type *));
54 static void gld${EMULATION_NAME}_stat_needed
55 PARAMS ((lang_input_statement_type *));
56 static boolean gld${EMULATION_NAME}_search_needed
57 PARAMS ((const char *, const char *));
58 static boolean gld${EMULATION_NAME}_try_needed PARAMS ((const char *));
59 static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
60 static void gld${EMULATION_NAME}_find_statement_assignment
61 PARAMS ((lang_statement_union_type *));
62 static void gld${EMULATION_NAME}_find_exp_assignment PARAMS ((etree_type *));
63 static boolean gld${EMULATION_NAME}_place_orphan
64 PARAMS ((lang_input_statement_type *, asection *));
65 static void gld${EMULATION_NAME}_place_section
66 PARAMS ((lang_statement_union_type *));
67 static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile));
70 gld${EMULATION_NAME}_before_parse()
72 ldfile_output_architecture = bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`;
73 config.dynamic_link = ${DYNAMIC_LINK-true};
76 /* Try to open a dynamic archive. This is where we know that ELF
77 dynamic libraries have an extension of .so. */
80 gld${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
82 search_dirs_type *search;
83 lang_input_statement_type *entry;
88 if (! entry->is_archive)
91 filename = entry->filename;
93 string = (char *) xmalloc (strlen (search->name)
98 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
100 if (! ldfile_try_open_bfd (string, entry))
106 entry->filename = string;
108 /* We have found a dynamic object to include in the link. The ELF
109 backend linker will create a DT_NEEDED entry in the .dynamic
110 section naming this file. If this file includes a DT_SONAME
111 entry, it will be used. Otherwise, the ELF linker will just use
112 the name of the file. For an archive found by searching, like
113 this one, the DT_NEEDED entry should consist of just the name of
114 the file, without the path information used to find it. Note
115 that we only need to do this if we have a dynamic object; an
116 archive will never be referenced by a DT_NEEDED entry.
118 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
119 very pretty. I haven't been able to think of anything that is
121 if (bfd_check_format (entry->the_bfd, bfd_object)
122 && (entry->the_bfd->flags & DYNAMIC) != 0)
126 ASSERT (entry->is_archive && entry->search_dirs_flag);
127 needed_name = (char *) xmalloc (strlen (filename)
130 sprintf (needed_name, "lib%s%s.so", filename, arch);
131 bfd_elf_set_dt_needed_name (entry->the_bfd, needed_name);
138 if [ "x${host}" = "x${target}" ] ; then
139 if [ "x${DEFAULT_EMULATION}" = "x${EMULATION_NAME}" ] ; then
140 cat >>e${EMULATION_NAME}.c <<EOF
142 /* For a native linker, check the file /etc/ld.so.conf for directories
143 in which we may find shared libraries. /etc/ld.so.conf is really
144 only meaningful on Linux, but we check it on other systems anyhow. */
146 static boolean gld${EMULATION_NAME}_check_ld_so_conf PARAMS ((const char *));
149 gld${EMULATION_NAME}_check_ld_so_conf (name)
152 static boolean initialized;
153 static char *ld_so_conf;
159 f = fopen ("/etc/ld.so.conf", FOPEN_RT);
168 b = (char *) xmalloc (alloc);
170 while ((c = getc (f)) != EOF)
172 if (len + 1 >= alloc)
175 b = (char *) xrealloc (b, alloc);
188 if (len > 0 && b[len - 1] != ':')
196 if (len > 0 && b[len - 1] == ':')
215 if (ld_so_conf == NULL)
218 return gld${EMULATION_NAME}_search_needed (ld_so_conf, name);
224 cat >>e${EMULATION_NAME}.c <<EOF
226 /* These variables are required to pass information back and forth
227 between after_open and check_needed and stat_needed. */
229 static struct bfd_link_needed_list *global_needed;
230 static struct stat global_stat;
231 static boolean global_found;
233 /* This is called after all the input files have been opened. */
236 gld${EMULATION_NAME}_after_open ()
238 struct bfd_link_needed_list *needed, *l;
240 /* We only need to worry about this when doing a final link. */
241 if (link_info.relocateable || link_info.shared)
244 /* Get the list of files which appear in DT_NEEDED entries in
245 dynamic objects included in the link (often there will be none).
246 For each such file, we want to track down the corresponding
247 library, and include the symbol table in the link. This is what
248 the runtime dynamic linker will do. Tracking the files down here
249 permits one dynamic object to include another without requiring
250 special action by the person doing the link. Note that the
251 needed list can actually grow while we are stepping through this
253 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
254 for (l = needed; l != NULL; l = l->next)
256 struct bfd_link_needed_list *ll;
257 const char *lib_path;
259 search_dirs_type *search;
261 /* If we've already seen this file, skip it. */
262 for (ll = needed; ll != l; ll = ll->next)
263 if (strcmp (ll->name, l->name) == 0)
268 /* See if this file was included in the link explicitly. */
270 global_found = false;
271 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
275 /* We need to find this file and include the symbol table. We
276 want to search for the file in the same way that the dynamic
277 linker will search. That means that we want to use
278 rpath_link, rpath, then the environment variable
279 LD_LIBRARY_PATH (native only), then the linker script
280 LIB_SEARCH_DIRS. We do not search using the -L arguments. */
281 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
284 if (gld${EMULATION_NAME}_search_needed (command_line.rpath, l->name))
286 if (command_line.rpath_link == NULL
287 && command_line.rpath == NULL)
289 lib_path = (const char *) getenv ("LD_RUN_PATH");
290 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name))
294 if [ "x${host}" = "x${target}" ] ; then
295 if [ "x${DEFAULT_EMULATION}" = "x${EMULATION_NAME}" ] ; then
296 cat >>e${EMULATION_NAME}.c <<EOF
297 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
298 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name))
303 cat >>e${EMULATION_NAME}.c <<EOF
304 len = strlen (l->name);
305 for (search = search_head; search != NULL; search = search->next)
311 filename = (char *) xmalloc (strlen (search->name) + len + 2);
312 sprintf (filename, "%s/%s", search->name, l->name);
313 if (gld${EMULATION_NAME}_try_needed (filename))
320 if [ "x${host}" = "x${target}" ] ; then
321 if [ "x${DEFAULT_EMULATION}" = "x${EMULATION_NAME}" ] ; then
322 cat >>e${EMULATION_NAME}.c <<EOF
323 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name))
328 cat >>e${EMULATION_NAME}.c <<EOF
330 einfo ("%P: warning: %s, needed by %B, not found (try using --rpath)\n",
335 /* Search for a needed file in a path. */
338 gld${EMULATION_NAME}_search_needed (path, name)
345 if (path == NULL || *path == '\0')
350 char *filename, *sset;
352 s = strchr (path, ':');
354 s = path + strlen (path);
356 filename = (char *) xmalloc (s - path + len + 2);
361 memcpy (filename, path, s - path);
362 filename[s - path] = '/';
363 sset = filename + (s - path) + 1;
367 if (gld${EMULATION_NAME}_try_needed (filename))
380 /* This function is called for each possible name for a dynamic object
381 named by a DT_NEEDED entry. */
384 gld${EMULATION_NAME}_try_needed (name)
389 abfd = bfd_openr (name, bfd_get_target (output_bfd));
392 if (! bfd_check_format (abfd, bfd_object))
394 (void) bfd_close (abfd);
397 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
399 (void) bfd_close (abfd);
403 /* We've found a dynamic object matching the DT_NEEDED entry. */
405 /* We have already checked that there is no other input file of the
406 same name. We must now check again that we are not including the
407 same file twice. We need to do this because on many systems
408 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
409 reference libc.so.1. If we have already included libc.so, we
410 don't want to include libc.so.1 if they are the same file, and we
411 can only check that using stat. */
413 if (bfd_stat (abfd, &global_stat) != 0)
414 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
415 global_found = false;
416 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
419 /* Return true to indicate that we found the file, even though
420 we aren't going to do anything with it. */
424 /* Tell the ELF backend that don't want the output file to have a
425 DT_NEEDED entry for this file. */
426 bfd_elf_set_dt_needed_name (abfd, "");
428 /* Add this file into the symbol table. */
429 if (! bfd_link_add_symbols (abfd, &link_info))
430 einfo ("%F%B: could not read symbols: %E\n", abfd);
435 /* See if an input file matches a DT_NEEDED entry by name. */
438 gld${EMULATION_NAME}_check_needed (s)
439 lang_input_statement_type *s;
444 if (s->filename != NULL
445 && strcmp (s->filename, global_needed->name) == 0)
451 if (s->the_bfd != NULL)
455 soname = bfd_elf_get_dt_soname (s->the_bfd);
457 && strcmp (soname, global_needed->name) == 0)
464 if (s->search_dirs_flag
465 && s->filename != NULL
466 && strchr (global_needed->name, '/') == NULL)
470 f = strrchr (s->filename, '/');
472 && strcmp (f + 1, global_needed->name) == 0)
480 /* See if an input file matches a DT_NEEDED entry by running stat on
484 gld${EMULATION_NAME}_stat_needed (s)
485 lang_input_statement_type *s;
494 if (s->the_bfd == NULL)
497 if (bfd_stat (s->the_bfd, &st) != 0)
499 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
503 if (st.st_dev == global_stat.st_dev
504 && st.st_ino == global_stat.st_ino)
510 /* We issue a warning if it looks like we are including two
511 different versions of the same shared library. For example,
512 there may be a problem if -lc picks up libc.so.6 but some other
513 shared library has a DT_NEEDED entry of libc.so.5. This is a
514 hueristic test, and it will only work if the name looks like
515 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
516 If we really want to issue warnings about mixing version numbers
517 of shared libraries, we need to find a better way. */
519 if (strchr (global_needed->name, '/') != NULL)
521 suffix = strstr (global_needed->name, ".so.");
524 suffix += sizeof ".so." - 1;
526 soname = bfd_elf_get_dt_soname (s->the_bfd);
528 soname = s->filename;
530 f = strrchr (soname, '/');
536 if (strncmp (f, global_needed->name, suffix - global_needed->name) == 0)
537 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
538 global_needed->name, global_needed->by, f);
541 /* This is called after the sections have been attached to output
542 sections, but before any sizes or addresses have been set. */
545 gld${EMULATION_NAME}_before_allocation ()
550 /* If we are going to make any variable assignments, we need to let
551 the ELF backend know about them in case the variables are
552 referred to by dynamic objects. */
553 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
555 /* Let the ELF backend work out the sizes of any sections required
556 by dynamic linking. */
557 rpath = command_line.rpath;
559 rpath = (const char *) getenv ("LD_RUN_PATH");
560 if (! bfd_elf${ELFSIZE}_size_dynamic_sections (output_bfd,
563 command_line.export_dynamic,
566 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
568 /* Let the user override the dynamic linker we are using. */
569 if (command_line.interpreter != NULL
572 sinterp->contents = (bfd_byte *) command_line.interpreter;
573 sinterp->_raw_size = strlen (command_line.interpreter) + 1;
576 /* Look for any sections named .gnu.warning. As a GNU extensions,
577 we treat such sections as containing warning messages. We print
578 out the warning message, and then zero out the section size so
579 that it does not get copied into the output file. */
582 LANG_FOR_EACH_INPUT_STATEMENT (is)
589 if (is->just_syms_flag)
592 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
596 sz = bfd_section_size (is->the_bfd, s);
597 msg = xmalloc ((size_t) sz + 1);
598 if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
599 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
602 ret = link_info.callbacks->warning (&link_info, msg,
604 is->the_bfd, (asection *) NULL,
609 /* Clobber the section size, so that we don't waste copying the
610 warning into the output file. */
615 #if defined (TARGET_IS_elf32bmip) || defined (TARGET_IS_elf32lmip)
616 /* For MIPS ELF the .reginfo section requires special handling.
617 Each input section is 24 bytes, and the final output section must
618 also be 24 bytes. We handle this by clobbering all but the first
619 input section size to 0. The .reginfo section is handled
620 specially by the backend code anyhow. */
622 boolean found = false;
623 LANG_FOR_EACH_INPUT_STATEMENT (is)
627 if (is->just_syms_flag)
630 s = bfd_get_section_by_name (is->the_bfd, ".reginfo");
647 /* This is called by the before_allocation routine via
648 lang_for_each_statement. It locates any assignment statements, and
649 tells the ELF backend about them, in case they are assignments to
650 symbols which are referred to by dynamic objects. */
653 gld${EMULATION_NAME}_find_statement_assignment (s)
654 lang_statement_union_type *s;
656 if (s->header.type == lang_assignment_statement_enum)
657 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
660 /* Look through an expression for an assignment statement. */
663 gld${EMULATION_NAME}_find_exp_assignment (exp)
666 struct bfd_link_hash_entry *h;
668 switch (exp->type.node_class)
671 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
672 false, false, false);
676 /* We call record_link_assignment even if the symbol is defined.
677 This is because if it is defined by a dynamic object, we
678 actually want to use the value defined by the linker script,
679 not the value from the dynamic object (because we are setting
680 symbols like etext). If the symbol is defined by a regular
681 object, then, as it happens, calling record_link_assignment
686 if (strcmp (exp->assign.dst, ".") != 0)
688 if (! (bfd_elf${ELFSIZE}_record_link_assignment
689 (output_bfd, &link_info, exp->assign.dst,
690 exp->type.node_class == etree_provide ? true : false)))
691 einfo ("%P%F: failed to record assignment to %s: %E\n",
694 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
698 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
699 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
703 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
704 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
705 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
709 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
717 /* Place an orphan section. We use this to put random SHF_ALLOC
718 sections in the right segment. */
720 static asection *hold_section;
721 static lang_output_section_statement_type *hold_use;
722 static lang_output_section_statement_type *hold_text;
723 static lang_output_section_statement_type *hold_rodata;
724 static lang_output_section_statement_type *hold_data;
725 static lang_output_section_statement_type *hold_bss;
726 static lang_output_section_statement_type *hold_rel;
730 gld${EMULATION_NAME}_place_orphan (file, s)
731 lang_input_statement_type *file;
734 lang_output_section_statement_type *place;
735 asection *snew, **pps;
736 lang_statement_list_type *old;
737 lang_statement_list_type add;
739 const char *secname, *ps;
740 lang_output_section_statement_type *os;
742 if ((s->flags & SEC_ALLOC) == 0)
745 /* Look through the script to see where to place this section. */
748 lang_for_each_statement (gld${EMULATION_NAME}_place_section);
750 if (hold_use != NULL)
752 /* We have already placed a section with this name. */
753 wild_doit (&hold_use->children, s, hold_use, file);
757 secname = bfd_get_section_name (s->owner, s);
759 /* If this is a final link, then always put .gnu.warning.SYMBOL
760 sections into the .text section to get them out of the way. */
761 if (! link_info.shared
762 && ! link_info.relocateable
763 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
764 && hold_text != NULL)
766 wild_doit (&hold_text->children, s, hold_text, file);
770 /* Decide which segment the section should go in based on the
771 section name and section flags. */
773 if ((s->flags & SEC_HAS_CONTENTS) == 0
776 else if ((s->flags & SEC_READONLY) == 0
777 && hold_data != NULL)
779 else if (strncmp (secname, ".rel", 4) == 0
780 && (s->flags & SEC_ALLOC) != 0
783 else if ((s->flags & SEC_CODE) == 0
784 && (s->flags & SEC_READONLY) != 0
785 && hold_rodata != NULL)
787 else if ((s->flags & SEC_READONLY) != 0
788 && hold_text != NULL)
793 /* Create the section in the output file, and put it in the right
794 place. This shuffling is to make the output file look neater. */
795 snew = bfd_make_section (output_bfd, secname);
797 einfo ("%P%F: output format %s cannot represent section called %s\n",
798 output_bfd->xvec->name, secname);
799 if (place->bfd_section != NULL)
801 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
804 snew->next = place->bfd_section->next;
805 place->bfd_section->next = snew;
808 /* Start building a list of statements for this section. */
811 lang_list_init (stat_ptr);
813 /* If the name of the section is representable in C, then create
814 symbols to mark the start and the end of the section. */
815 for (ps = secname; *ps != '\0'; ps++)
816 if (! isalnum (*ps) && *ps != '_')
818 if (*ps == '\0' && config.build_constructors)
822 symname = (char *) xmalloc (ps - secname + sizeof "__start_");
823 sprintf (symname, "__start_%s", secname);
824 lang_add_assignment (exp_assop ('=', symname,
826 exp_intop ((bfd_vma) 1
827 << s->alignment_power))));
830 if (! link_info.relocateable)
833 address = exp_intop ((bfd_vma) 0);
835 lang_enter_output_section_statement (secname, address, 0,
839 (etree_type *) NULL);
841 os = lang_output_section_statement_lookup (secname);
842 wild_doit (&os->children, s, os, file);
844 lang_leave_output_section_statement
845 ((bfd_vma) 0, "*default*", (struct lang_output_section_phdr_list *) NULL);
848 if (*ps == '\0' && config.build_constructors)
852 symname = (char *) xmalloc (ps - secname + sizeof "__stop_");
853 sprintf (symname, "__stop_%s", secname);
854 lang_add_assignment (exp_assop ('=', symname,
855 exp_nameop (NAME, ".")));
858 /* Now stick the new statement list right after PLACE. */
859 *add.tail = place->header.next;
860 place->header.next = add.head;
868 gld${EMULATION_NAME}_place_section (s)
869 lang_statement_union_type *s;
871 lang_output_section_statement_type *os;
873 if (s->header.type != lang_output_section_statement_enum)
876 os = &s->output_section_statement;
878 if (strcmp (os->name, hold_section->name) == 0)
881 if (strcmp (os->name, ".text") == 0)
883 else if (strcmp (os->name, ".rodata") == 0)
885 else if (strcmp (os->name, ".data") == 0)
887 else if (strcmp (os->name, ".bss") == 0)
889 else if (hold_rel == NULL
890 && os->bfd_section != NULL
891 && (os->flags & SEC_ALLOC) != 0
892 && strncmp (os->name, ".rel", 4) == 0)
897 gld${EMULATION_NAME}_get_script(isfile)
901 if test -n "$COMPILE_IN"
903 # Scripts compiled in.
905 # sed commands to quote an ld script as a C string.
912 cat >>e${EMULATION_NAME}.c <<EOF
916 if (link_info.relocateable == true && config.build_constructors == true)
917 return `sed "$sc" ldscripts/${EMULATION_NAME}.xu`;
918 else if (link_info.relocateable == true)
919 return `sed "$sc" ldscripts/${EMULATION_NAME}.xr`;
920 else if (!config.text_read_only)
921 return `sed "$sc" ldscripts/${EMULATION_NAME}.xbn`;
922 else if (!config.magic_demand_paged)
923 return `sed "$sc" ldscripts/${EMULATION_NAME}.xn`;
924 else if (link_info.shared)
925 return `sed "$sc" ldscripts/${EMULATION_NAME}.xs`;
927 return `sed "$sc" ldscripts/${EMULATION_NAME}.x`;
932 # Scripts read from the filesystem.
934 cat >>e${EMULATION_NAME}.c <<EOF
938 if (link_info.relocateable == true && config.build_constructors == true)
939 return "ldscripts/${EMULATION_NAME}.xu";
940 else if (link_info.relocateable == true)
941 return "ldscripts/${EMULATION_NAME}.xr";
942 else if (!config.text_read_only)
943 return "ldscripts/${EMULATION_NAME}.xbn";
944 else if (!config.magic_demand_paged)
945 return "ldscripts/${EMULATION_NAME}.xn";
946 else if (link_info.shared)
947 return "ldscripts/${EMULATION_NAME}.xs";
949 return "ldscripts/${EMULATION_NAME}.x";
955 cat >>e${EMULATION_NAME}.c <<EOF
957 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
959 gld${EMULATION_NAME}_before_parse,
963 gld${EMULATION_NAME}_after_open,
964 after_allocation_default,
965 set_output_arch_default,
966 ldemul_default_target,
967 gld${EMULATION_NAME}_before_allocation,
968 gld${EMULATION_NAME}_get_script,
973 gld${EMULATION_NAME}_open_dynamic_archive,
974 gld${EMULATION_NAME}_place_orphan