| blob | bb1f92c920e24a1db3e22503b98e9f6c8b8b0dfb |
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
4 # ELF emulations.
5 test -z "${ELFSIZE}" && ELFSIZE=32
6 if [ -z "$MACHINE" ]; then
7 OUTPUT_ARCH=${ARCH}
8 else
9 OUTPUT_ARCH=${ARCH}:${MACHINE}
10 fi
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 2002, 2003, 2004 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}
38 #include "bfd.h"
39 #include "sysdep.h"
40 #include "libiberty.h"
41 #include "safe-ctype.h"
42 #include "getopt.h"
44 #include "bfdlink.h"
46 #include "ld.h"
47 #include "ldmain.h"
48 #include "ldmisc.h"
49 #include "ldexp.h"
50 #include "ldlang.h"
51 #include "ldfile.h"
52 #include "ldemul.h"
53 #include <ldgram.h>
54 #include "elf/common.h"
56 /* Declare functions used by various EXTRA_EM_FILEs. */
57 static void gld${EMULATION_NAME}_before_parse (void);
58 static void gld${EMULATION_NAME}_after_open (void);
59 static void gld${EMULATION_NAME}_before_allocation (void);
60 static bfd_boolean gld${EMULATION_NAME}_place_orphan
61 (lang_input_statement_type *file, asection *s);
62 static void gld${EMULATION_NAME}_finish (void);
64 EOF
66 # Import any needed special functions and/or overrides.
67 #
68 if test -n "$EXTRA_EM_FILE" ; then
69 . ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
70 fi
72 # Functions in this file can be overridden by setting the LDEMUL_* shell
73 # variables. If the name of the overriding function is the same as is
74 # defined in this file, then don't output this file's version.
75 # If a different overriding name is given then output the standard function
76 # as presumably it is called from the overriding function.
77 #
78 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
79 cat >>e${EMULATION_NAME}.c <<EOF
81 static void
82 gld${EMULATION_NAME}_before_parse (void)
83 {
84 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
85 config.dynamic_link = ${DYNAMIC_LINK-TRUE};
86 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
87 }
89 EOF
90 fi
92 if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
93 cat >>e${EMULATION_NAME}.c <<EOF
94 /* Handle as_needed DT_NEEDED. */
96 static bfd_boolean
97 gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
98 {
99 int class = 0;
101 /* Tell the ELF linker that we don't want the output file to have a
102 DT_NEEDED entry for this file, unless it is used to resolve
103 references in a regular object. */
104 if (entry->as_needed)
105 class = DYN_AS_NEEDED;
107 /* Tell the ELF linker that we don't want the output file to have a
108 DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
109 this file at all. */
110 if (!entry->add_needed)
111 class |= DYN_NO_ADD_NEEDED;
113 if (!class
114 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
115 return FALSE;
117 bfd_elf_set_dyn_lib_class (entry->the_bfd, class);
119 /* Continue on with normal load_symbols processing. */
120 return FALSE;
121 }
122 EOF
123 fi
125 cat >>e${EMULATION_NAME}.c <<EOF
127 /* These variables are required to pass information back and forth
128 between after_open and check_needed and stat_needed and vercheck. */
130 static struct bfd_link_needed_list *global_needed;
131 static struct stat global_stat;
132 static bfd_boolean global_found;
133 static struct bfd_link_needed_list *global_vercheck_needed;
134 static bfd_boolean global_vercheck_failed;
137 /* On Linux, it's possible to have different versions of the same
138 shared library linked against different versions of libc. The
139 dynamic linker somehow tags which libc version to use in
140 /etc/ld.so.cache, and, based on the libc that it sees in the
141 executable, chooses which version of the shared library to use.
143 We try to do a similar check here by checking whether this shared
144 library needs any other shared libraries which may conflict with
145 libraries we have already included in the link. If it does, we
146 skip it, and try to find another shared library farther on down the
147 link path.
149 This is called via lang_for_each_input_file.
150 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
151 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
152 a conflicting version. */
154 static void
155 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
156 {
157 const char *soname;
158 struct bfd_link_needed_list *l;
160 if (global_vercheck_failed)
161 return;
162 if (s->the_bfd == NULL
163 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
164 return;
166 soname = bfd_elf_get_dt_soname (s->the_bfd);
167 if (soname == NULL)
168 soname = lbasename (bfd_get_filename (s->the_bfd));
170 for (l = global_vercheck_needed; l != NULL; l = l->next)
171 {
172 const char *suffix;
174 if (strcmp (soname, l->name) == 0)
175 {
176 /* Probably can't happen, but it's an easy check. */
177 continue;
178 }
180 if (strchr (l->name, '/') != NULL)
181 continue;
183 suffix = strstr (l->name, ".so.");
184 if (suffix == NULL)
185 continue;
187 suffix += sizeof ".so." - 1;
189 if (strncmp (soname, l->name, suffix - l->name) == 0)
190 {
191 /* Here we know that S is a dynamic object FOO.SO.VER1, and
192 the object we are considering needs a dynamic object
193 FOO.SO.VER2, and VER1 and VER2 are different. This
194 appears to be a version mismatch, so we tell the caller
195 to try a different version of this library. */
196 global_vercheck_failed = TRUE;
197 return;
198 }
199 }
200 }
203 /* See if an input file matches a DT_NEEDED entry by running stat on
204 the file. */
206 static void
207 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
208 {
209 struct stat st;
210 const char *suffix;
211 const char *soname;
213 if (global_found)
214 return;
215 if (s->the_bfd == NULL)
216 return;
218 if (bfd_stat (s->the_bfd, &st) != 0)
219 {
220 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
221 return;
222 }
224 if (st.st_dev == global_stat.st_dev
225 && st.st_ino == global_stat.st_ino)
226 {
227 global_found = TRUE;
228 return;
229 }
231 /* We issue a warning if it looks like we are including two
232 different versions of the same shared library. For example,
233 there may be a problem if -lc picks up libc.so.6 but some other
234 shared library has a DT_NEEDED entry of libc.so.5. This is a
235 heuristic test, and it will only work if the name looks like
236 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
237 If we really want to issue warnings about mixing version numbers
238 of shared libraries, we need to find a better way. */
240 if (strchr (global_needed->name, '/') != NULL)
241 return;
242 suffix = strstr (global_needed->name, ".so.");
243 if (suffix == NULL)
244 return;
245 suffix += sizeof ".so." - 1;
247 soname = bfd_elf_get_dt_soname (s->the_bfd);
248 if (soname == NULL)
249 soname = lbasename (s->filename);
251 if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
252 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
253 global_needed->name, global_needed->by, soname);
254 }
256 struct dt_needed
257 {
258 bfd *by;
259 const char *name;
260 };
262 /* This function is called for each possible name for a dynamic object
263 named by a DT_NEEDED entry. The FORCE parameter indicates whether
264 to skip the check for a conflicting version. */
266 static bfd_boolean
267 gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
268 int force)
269 {
270 bfd *abfd;
271 const char *name = needed->name;
272 const char *soname;
273 int class;
275 abfd = bfd_openr (name, bfd_get_target (output_bfd));
276 if (abfd == NULL)
277 return FALSE;
278 if (! bfd_check_format (abfd, bfd_object))
279 {
280 bfd_close (abfd);
281 return FALSE;
282 }
283 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
284 {
285 bfd_close (abfd);
286 return FALSE;
287 }
289 /* For DT_NEEDED, they have to match. */
290 if (abfd->xvec != output_bfd->xvec)
291 {
292 bfd_close (abfd);
293 return FALSE;
294 }
296 /* Check whether this object would include any conflicting library
297 versions. If FORCE is set, then we skip this check; we use this
298 the second time around, if we couldn't find any compatible
299 instance of the shared library. */
301 if (! force)
302 {
303 struct bfd_link_needed_list *needed;
305 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
306 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
308 if (needed != NULL)
309 {
310 global_vercheck_needed = needed;
311 global_vercheck_failed = FALSE;
312 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
313 if (global_vercheck_failed)
314 {
315 bfd_close (abfd);
316 /* Return FALSE to force the caller to move on to try
317 another file on the search path. */
318 return FALSE;
319 }
321 /* But wait! It gets much worse. On Linux, if a shared
322 library does not use libc at all, we are supposed to skip
323 it the first time around in case we encounter a shared
324 library later on with the same name which does use the
325 version of libc that we want. This is much too horrible
326 to use on any system other than Linux. */
328 EOF
329 case ${target} in
330 *-*-linux-gnu*)
331 cat >>e${EMULATION_NAME}.c <<EOF
332 {
333 struct bfd_link_needed_list *l;
335 for (l = needed; l != NULL; l = l->next)
336 if (strncmp (l->name, "libc.so", 7) == 0)
337 break;
338 if (l == NULL)
339 {
340 bfd_close (abfd);
341 return FALSE;
342 }
343 }
345 EOF
346 ;;
347 esac
348 cat >>e${EMULATION_NAME}.c <<EOF
349 }
350 }
352 /* We've found a dynamic object matching the DT_NEEDED entry. */
354 /* We have already checked that there is no other input file of the
355 same name. We must now check again that we are not including the
356 same file twice. We need to do this because on many systems
357 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
358 reference libc.so.1. If we have already included libc.so, we
359 don't want to include libc.so.1 if they are the same file, and we
360 can only check that using stat. */
362 if (bfd_stat (abfd, &global_stat) != 0)
363 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
365 /* First strip off everything before the last '/'. */
366 soname = lbasename (abfd->filename);
368 if (trace_file_tries)
369 info_msg (_("found %s at %s\n"), soname, name);
371 global_found = FALSE;
372 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
373 if (global_found)
374 {
375 /* Return TRUE to indicate that we found the file, even though
376 we aren't going to do anything with it. */
377 return TRUE;
378 }
380 /* Specify the soname to use. */
381 bfd_elf_set_dt_needed_name (abfd, soname);
383 /* Tell the ELF linker that we don't want the output file to have a
384 DT_NEEDED entry for this file, unless it is used to resolve
385 references in a regular object. */
386 class = DYN_DT_NEEDED;
388 /* Tell the ELF linker that we don't want the output file to have a
389 DT_NEEDED entry for this file at all if the entry is from a file
390 with DYN_NO_ADD_NEEDED. */
391 if (needed->by
392 && (bfd_elf_get_dyn_lib_class (needed->by)
393 & DYN_NO_ADD_NEEDED) != 0)
394 class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
396 bfd_elf_set_dyn_lib_class (abfd, class);
398 /* Add this file into the symbol table. */
399 if (! bfd_link_add_symbols (abfd, &link_info))
400 einfo ("%F%B: could not read symbols: %E\n", abfd);
402 return TRUE;
403 }
406 /* Search for a needed file in a path. */
408 static bfd_boolean
409 gld${EMULATION_NAME}_search_needed (const char *path,
410 struct dt_needed *n, int force)
411 {
412 const char *s;
413 const char *name = n->name;
414 size_t len;
415 struct dt_needed needed;
417 if (name[0] == '/')
418 return gld${EMULATION_NAME}_try_needed (n, force);
420 if (path == NULL || *path == '\0')
421 return FALSE;
423 needed.by = n->by;
424 needed.name = n->name;
426 len = strlen (name);
427 while (1)
428 {
429 char *filename, *sset;
431 s = strchr (path, ':');
432 if (s == NULL)
433 s = path + strlen (path);
435 filename = (char *) xmalloc (s - path + len + 2);
436 if (s == path)
437 sset = filename;
438 else
439 {
440 memcpy (filename, path, s - path);
441 filename[s - path] = '/';
442 sset = filename + (s - path) + 1;
443 }
444 strcpy (sset, name);
446 needed.name = filename;
447 if (gld${EMULATION_NAME}_try_needed (&needed, force))
448 return TRUE;
450 free (filename);
452 if (*s == '\0')
453 break;
454 path = s + 1;
455 }
457 return FALSE;
458 }
460 EOF
461 if [ "x${USE_LIBPATH}" = xyes ] ; then
462 cat >>e${EMULATION_NAME}.c <<EOF
464 /* Add the sysroot to every entry in a colon-separated path. */
466 static char *
467 gld${EMULATION_NAME}_add_sysroot (const char *path)
468 {
469 int len, colons, i;
470 char *ret, *p;
472 len = strlen (path);
473 colons = 0;
474 i = 0;
475 while (path[i])
476 if (path[i++] == ':')
477 colons++;
479 if (path[i])
480 colons++;
482 len = len + (colons + 1) * strlen (ld_sysroot);
483 ret = xmalloc (len + 1);
484 strcpy (ret, ld_sysroot);
485 p = ret + strlen (ret);
486 i = 0;
487 while (path[i])
488 if (path[i] == ':')
489 {
490 *p++ = path[i++];
491 strcpy (p, ld_sysroot);
492 p = p + strlen (p);
493 }
494 else
495 *p++ = path[i++];
497 *p = 0;
498 return ret;
499 }
501 EOF
502 case ${target} in
503 *-*-linux-gnu*)
504 cat >>e${EMULATION_NAME}.c <<EOF
505 /* For a native linker, check the file /etc/ld.so.conf for directories
506 in which we may find shared libraries. /etc/ld.so.conf is really
507 only meaningful on Linux. */
509 static bfd_boolean
510 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
511 {
512 static bfd_boolean initialized;
513 static char *ld_so_conf;
514 struct dt_needed needed;
516 if (! initialized)
517 {
518 FILE *f;
519 char *tmppath;
521 tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL);
522 f = fopen (tmppath, FOPEN_RT);
523 free (tmppath);
524 if (f != NULL)
525 {
526 char *b;
527 size_t len, alloc;
528 int c;
530 len = 0;
531 alloc = 100;
532 b = (char *) xmalloc (alloc);
534 while ((c = getc (f)) != EOF)
535 {
536 if (len + 1 >= alloc)
537 {
538 alloc *= 2;
539 b = (char *) xrealloc (b, alloc);
540 }
541 if (c != ':'
542 && c != ' '
543 && c != '\t'
544 && c != '\n'
545 && c != ',')
546 {
547 b[len] = c;
548 ++len;
549 }
550 else
551 {
552 if (len > 0 && b[len - 1] != ':')
553 {
554 b[len] = ':';
555 ++len;
556 }
557 }
558 }
560 if (len > 0 && b[len - 1] == ':')
561 --len;
563 if (len > 0)
564 b[len] = '\0';
565 else
566 {
567 free (b);
568 b = NULL;
569 }
571 fclose (f);
573 if (b)
574 {
575 char *d = gld${EMULATION_NAME}_add_sysroot (b);
576 free (b);
577 b = d;
578 }
580 ld_so_conf = b;
581 }
583 initialized = TRUE;
584 }
586 if (ld_so_conf == NULL)
587 return FALSE;
590 needed.by = NULL;
591 needed.name = name;
592 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
593 }
595 EOF
596 # Linux
597 ;;
598 esac
599 fi
600 cat >>e${EMULATION_NAME}.c <<EOF
602 /* See if an input file matches a DT_NEEDED entry by name. */
604 static void
605 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
606 {
607 if (global_found)
608 return;
610 if (s->filename != NULL)
611 {
612 const char *f;
614 if (strcmp (s->filename, global_needed->name) == 0)
615 {
616 global_found = TRUE;
617 return;
618 }
620 if (s->search_dirs_flag)
621 {
622 f = strrchr (s->filename, '/');
623 if (f != NULL
624 && strcmp (f + 1, global_needed->name) == 0)
625 {
626 global_found = TRUE;
627 return;
628 }
629 }
630 }
632 if (s->the_bfd != NULL)
633 {
634 const char *soname;
636 soname = bfd_elf_get_dt_soname (s->the_bfd);
637 if (soname != NULL
638 && strcmp (soname, global_needed->name) == 0)
639 {
640 global_found = TRUE;
641 return;
642 }
643 }
644 }
646 EOF
648 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
649 cat >>e${EMULATION_NAME}.c <<EOF
651 /* This is called after all the input files have been opened. */
653 static void
654 gld${EMULATION_NAME}_after_open (void)
655 {
656 struct bfd_link_needed_list *needed, *l;
658 /* We only need to worry about this when doing a final link. */
659 if (link_info.relocatable || !link_info.executable)
660 return;
662 /* Get the list of files which appear in DT_NEEDED entries in
663 dynamic objects included in the link (often there will be none).
664 For each such file, we want to track down the corresponding
665 library, and include the symbol table in the link. This is what
666 the runtime dynamic linker will do. Tracking the files down here
667 permits one dynamic object to include another without requiring
668 special action by the person doing the link. Note that the
669 needed list can actually grow while we are stepping through this
670 loop. */
671 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
672 for (l = needed; l != NULL; l = l->next)
673 {
674 struct bfd_link_needed_list *ll;
675 struct dt_needed n, nn;
676 int force;
678 /* If we've already seen this file, skip it. */
679 for (ll = needed; ll != l; ll = ll->next)
680 if (strcmp (ll->name, l->name) == 0)
681 break;
682 if (ll != l)
683 continue;
685 /* See if this file was included in the link explicitly. */
686 global_needed = l;
687 global_found = FALSE;
688 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
689 if (global_found)
690 continue;
692 n.by = l->by;
693 n.name = l->name;
694 nn.by = l->by;
695 if (trace_file_tries)
696 info_msg (_("%s needed by %B\n"), l->name, l->by);
698 /* We need to find this file and include the symbol table. We
699 want to search for the file in the same way that the dynamic
700 linker will search. That means that we want to use
701 rpath_link, rpath, then the environment variable
702 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
703 entries (native only), then the linker script LIB_SEARCH_DIRS.
704 We do not search using the -L arguments.
706 We search twice. The first time, we skip objects which may
707 introduce version mismatches. The second time, we force
708 their use. See gld${EMULATION_NAME}_vercheck comment. */
709 for (force = 0; force < 2; force++)
710 {
711 size_t len;
712 search_dirs_type *search;
713 EOF
714 if [ "x${USE_LIBPATH}" = xyes ] ; then
715 cat >>e${EMULATION_NAME}.c <<EOF
716 const char *lib_path;
717 struct bfd_link_needed_list *rp;
718 int found;
719 EOF
720 fi
721 cat >>e${EMULATION_NAME}.c <<EOF
723 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
724 &n, force))
725 break;
726 EOF
727 if [ "x${USE_LIBPATH}" = xyes ] ; then
728 cat >>e${EMULATION_NAME}.c <<EOF
729 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
730 &n, force))
731 break;
732 EOF
733 fi
734 if [ "x${NATIVE}" = xyes ] ; then
735 cat >>e${EMULATION_NAME}.c <<EOF
736 if (command_line.rpath_link == NULL
737 && command_line.rpath == NULL)
738 {
739 lib_path = (const char *) getenv ("LD_RUN_PATH");
740 if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
741 force))
742 break;
743 }
744 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
745 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
746 break;
747 EOF
748 fi
749 if [ "x${USE_LIBPATH}" = xyes ] ; then
750 cat >>e${EMULATION_NAME}.c <<EOF
751 found = 0;
752 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
753 for (; !found && rp != NULL; rp = rp->next)
754 {
755 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
756 found = (rp->by == l->by
757 && gld${EMULATION_NAME}_search_needed (tmpname,
758 &n,
759 force));
760 free (tmpname);
761 }
762 if (found)
763 break;
765 EOF
766 fi
767 cat >>e${EMULATION_NAME}.c <<EOF
768 len = strlen (l->name);
769 for (search = search_head; search != NULL; search = search->next)
770 {
771 char *filename;
773 if (search->cmdline)
774 continue;
775 filename = (char *) xmalloc (strlen (search->name) + len + 2);
776 sprintf (filename, "%s/%s", search->name, l->name);
777 nn.name = filename;
778 if (gld${EMULATION_NAME}_try_needed (&nn, force))
779 break;
780 free (filename);
781 }
782 if (search != NULL)
783 break;
784 EOF
785 if [ "x${USE_LIBPATH}" = xyes ] ; then
786 case ${target} in
787 *-*-linux-gnu*)
788 cat >>e${EMULATION_NAME}.c <<EOF
789 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
790 break;
791 EOF
792 # Linux
793 ;;
794 esac
795 fi
796 cat >>e${EMULATION_NAME}.c <<EOF
797 }
799 if (force < 2)
800 continue;
802 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
803 l->name, l->by);
804 }
805 }
807 EOF
808 fi
810 cat >>e${EMULATION_NAME}.c <<EOF
812 /* Look through an expression for an assignment statement. */
814 static void
815 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
816 {
817 struct bfd_link_hash_entry *h;
819 switch (exp->type.node_class)
820 {
821 case etree_provide:
822 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
823 FALSE, FALSE, FALSE);
824 if (h == NULL)
825 break;
827 /* We call record_link_assignment even if the symbol is defined.
828 This is because if it is defined by a dynamic object, we
829 actually want to use the value defined by the linker script,
830 not the value from the dynamic object (because we are setting
831 symbols like etext). If the symbol is defined by a regular
832 object, then, as it happens, calling record_link_assignment
833 will do no harm. */
835 /* Fall through. */
836 case etree_assign:
837 if (strcmp (exp->assign.dst, ".") != 0)
838 {
839 if (! (bfd_elf_record_link_assignment
840 (output_bfd, &link_info, exp->assign.dst,
841 exp->type.node_class == etree_provide ? TRUE : FALSE)))
842 einfo ("%P%F: failed to record assignment to %s: %E\n",
843 exp->assign.dst);
844 }
845 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
846 break;
848 case etree_binary:
849 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
850 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
851 break;
853 case etree_trinary:
854 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
855 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
856 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
857 break;
859 case etree_unary:
860 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
861 break;
863 default:
864 break;
865 }
866 }
869 /* This is called by the before_allocation routine via
870 lang_for_each_statement. It locates any assignment statements, and
871 tells the ELF backend about them, in case they are assignments to
872 symbols which are referred to by dynamic objects. */
874 static void
875 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
876 {
877 if (s->header.type == lang_assignment_statement_enum)
878 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
879 }
881 EOF
883 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
884 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
885 ELF_INTERPRETER_SET_DEFAULT="
886 if (sinterp != NULL)
887 {
888 sinterp->contents = ${ELF_INTERPRETER_NAME};
889 sinterp->size = strlen (sinterp->contents) + 1;
890 }
892 "
893 else
894 ELF_INTERPRETER_SET_DEFAULT=
895 fi
896 cat >>e${EMULATION_NAME}.c <<EOF
898 /* This is called after the sections have been attached to output
899 sections, but before any sizes or addresses have been set. */
901 static void
902 gld${EMULATION_NAME}_before_allocation (void)
903 {
904 const char *rpath;
905 asection *sinterp;
907 if (link_info.hash->type == bfd_link_elf_hash_table)
908 _bfd_elf_tls_setup (output_bfd, &link_info);
910 /* If we are going to make any variable assignments, we need to let
911 the ELF backend know about them in case the variables are
912 referred to by dynamic objects. */
913 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
915 /* Let the ELF backend work out the sizes of any sections required
916 by dynamic linking. */
917 rpath = command_line.rpath;
918 if (rpath == NULL)
919 rpath = (const char *) getenv ("LD_RUN_PATH");
920 if (! (bfd_elf_size_dynamic_sections
921 (output_bfd, command_line.soname, rpath,
922 command_line.filter_shlib,
923 (const char * const *) command_line.auxiliary_filters,
924 &link_info, &sinterp, lang_elf_version_info)))
925 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
926 ${ELF_INTERPRETER_SET_DEFAULT}
927 /* Let the user override the dynamic linker we are using. */
928 if (command_line.interpreter != NULL
929 && sinterp != NULL)
930 {
931 sinterp->contents = (bfd_byte *) command_line.interpreter;
932 sinterp->size = strlen (command_line.interpreter) + 1;
933 }
935 /* Look for any sections named .gnu.warning. As a GNU extensions,
936 we treat such sections as containing warning messages. We print
937 out the warning message, and then zero out the section size so
938 that it does not get copied into the output file. */
940 {
941 LANG_FOR_EACH_INPUT_STATEMENT (is)
942 {
943 asection *s;
944 bfd_size_type sz;
945 bfd_size_type prefix_len;
946 char *msg;
947 bfd_boolean ret;
948 const char * gnu_warning_prefix = _("warning: ");
950 if (is->just_syms_flag)
951 continue;
953 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
954 if (s == NULL)
955 continue;
957 sz = s->size;
958 prefix_len = strlen (gnu_warning_prefix);
959 msg = xmalloc ((size_t) (prefix_len + sz + 1));
960 strcpy (msg, gnu_warning_prefix);
961 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len,
962 (file_ptr) 0, sz))
963 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
964 is->the_bfd);
965 msg[prefix_len + sz] = '\0';
966 ret = link_info.callbacks->warning (&link_info, msg,
967 (const char *) NULL,
968 is->the_bfd, (asection *) NULL,
969 (bfd_vma) 0);
970 ASSERT (ret);
971 free (msg);
973 /* Clobber the section size, so that we don't waste copying the
974 warning into the output file. */
975 s->size = 0;
976 }
977 }
978 }
980 EOF
981 fi
983 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
984 cat >>e${EMULATION_NAME}.c <<EOF
986 /* Try to open a dynamic archive. This is where we know that ELF
987 dynamic libraries have an extension of .so (or .sl on oddball systems
988 like hpux). */
990 static bfd_boolean
991 gld${EMULATION_NAME}_open_dynamic_archive
992 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
993 {
994 const char *filename;
995 char *string;
997 if (! entry->is_archive)
998 return FALSE;
1000 filename = entry->filename;
1002 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1003 is defined, but it does not seem worth the headache to optimize
1004 away those two bytes of space. */
1005 string = (char *) xmalloc (strlen (search->name)
1006 + strlen (filename)
1007 + strlen (arch)
1008 #ifdef EXTRA_SHLIB_EXTENSION
1009 + strlen (EXTRA_SHLIB_EXTENSION)
1010 #endif
1011 + sizeof "/lib.so");
1013 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1015 #ifdef EXTRA_SHLIB_EXTENSION
1016 /* Try the .so extension first. If that fails build a new filename
1017 using EXTRA_SHLIB_EXTENSION. */
1018 if (! ldfile_try_open_bfd (string, entry))
1019 sprintf (string, "%s/lib%s%s%s", search->name,
1020 filename, arch, EXTRA_SHLIB_EXTENSION);
1021 #endif
1023 if (! ldfile_try_open_bfd (string, entry))
1024 {
1025 free (string);
1026 return FALSE;
1027 }
1029 entry->filename = string;
1031 /* We have found a dynamic object to include in the link. The ELF
1032 backend linker will create a DT_NEEDED entry in the .dynamic
1033 section naming this file. If this file includes a DT_SONAME
1034 entry, it will be used. Otherwise, the ELF linker will just use
1035 the name of the file. For an archive found by searching, like
1036 this one, the DT_NEEDED entry should consist of just the name of
1037 the file, without the path information used to find it. Note
1038 that we only need to do this if we have a dynamic object; an
1039 archive will never be referenced by a DT_NEEDED entry.
1041 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1042 very pretty. I haven't been able to think of anything that is
1043 pretty, though. */
1044 if (bfd_check_format (entry->the_bfd, bfd_object)
1045 && (entry->the_bfd->flags & DYNAMIC) != 0)
1046 {
1047 ASSERT (entry->is_archive && entry->search_dirs_flag);
1049 /* Rather than duplicating the logic above. Just use the
1050 filename we recorded earlier. */
1052 filename = lbasename (entry->filename);
1053 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1054 }
1056 return TRUE;
1057 }
1059 EOF
1060 fi
1062 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1063 cat >>e${EMULATION_NAME}.c <<EOF
1065 /* A variant of lang_output_section_find. Used by place_orphan. */
1067 static lang_output_section_statement_type *
1068 output_rel_find (asection *sec, int isdyn)
1069 {
1070 lang_statement_union_type *u;
1071 lang_output_section_statement_type *lookup;
1072 lang_output_section_statement_type *last = NULL;
1073 lang_output_section_statement_type *last_alloc = NULL;
1074 lang_output_section_statement_type *last_rel = NULL;
1075 lang_output_section_statement_type *last_rel_alloc = NULL;
1076 int rela = sec->name[4] == 'a';
1078 for (u = lang_output_section_statement.head; u; u = lookup->next)
1079 {
1080 lookup = &u->output_section_statement;
1081 if (lookup->constraint != -1
1082 && strncmp (".rel", lookup->name, 4) == 0)
1083 {
1084 int lookrela = lookup->name[4] == 'a';
1086 /* .rel.dyn must come before all other reloc sections, to suit
1087 GNU ld.so. */
1088 if (isdyn)
1089 break;
1091 /* Don't place after .rel.plt as doing so results in wrong
1092 dynamic tags. */
1093 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1094 break;
1096 if (rela == lookrela || last_rel == NULL)
1097 last_rel = lookup;
1098 if ((rela == lookrela || last_rel_alloc == NULL)
1099 && lookup->bfd_section != NULL
1100 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1101 last_rel_alloc = lookup;
1102 }
1104 last = lookup;
1105 if (lookup->bfd_section != NULL
1106 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1107 last_alloc = lookup;
1108 }
1110 if (last_rel_alloc)
1111 return last_rel_alloc;
1113 if (last_rel)
1114 return last_rel;
1116 if (last_alloc)
1117 return last_alloc;
1119 return last;
1120 }
1122 /* Find the last output section before given output statement.
1123 Used by place_orphan. */
1125 static asection *
1126 output_prev_sec_find (lang_output_section_statement_type *os)
1127 {
1128 asection *s = (asection *) NULL;
1129 lang_statement_union_type *u;
1130 lang_output_section_statement_type *lookup;
1132 for (u = lang_output_section_statement.head;
1133 u != (lang_statement_union_type *) NULL;
1134 u = lookup->next)
1135 {
1136 lookup = &u->output_section_statement;
1137 if (lookup == os)
1138 return s;
1140 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1141 s = lookup->bfd_section;
1142 }
1144 return NULL;
1145 }
1147 /* Place an orphan section. We use this to put random SHF_ALLOC
1148 sections in the right segment. */
1150 struct orphan_save {
1151 lang_output_section_statement_type *os;
1152 asection **section;
1153 lang_statement_union_type **stmt;
1154 lang_statement_union_type **os_tail;
1155 };
1157 static bfd_boolean
1158 gld${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1159 {
1160 static struct orphan_save hold_text;
1161 static struct orphan_save hold_rodata;
1162 static struct orphan_save hold_data;
1163 static struct orphan_save hold_bss;
1164 static struct orphan_save hold_rel;
1165 static struct orphan_save hold_interp;
1166 static struct orphan_save hold_sdata;
1167 static int count = 1;
1168 struct orphan_save *place;
1169 lang_statement_list_type *old;
1170 lang_statement_list_type add;
1171 etree_type *address;
1172 const char *secname;
1173 const char *ps = NULL;
1174 lang_output_section_statement_type *os;
1175 lang_statement_union_type **os_tail;
1176 etree_type *load_base;
1177 int isdyn = 0;
1178 asection *sec;
1180 secname = bfd_get_section_name (s->owner, s);
1182 if (! link_info.relocatable
1183 && link_info.combreloc
1184 && (s->flags & SEC_ALLOC)
1185 && strncmp (secname, ".rel", 4) == 0)
1186 {
1187 if (secname[4] == 'a')
1188 secname = ".rela.dyn";
1189 else
1190 secname = ".rel.dyn";
1191 isdyn = 1;
1192 }
1194 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s)))
1195 {
1196 /* Look through the script to see where to place this section. */
1197 os = lang_output_section_find (secname);
1199 if (os != NULL
1200 && (os->bfd_section == NULL
1201 || ((s->flags ^ os->bfd_section->flags)
1202 & (SEC_LOAD | SEC_ALLOC)) == 0))
1203 {
1204 /* We already have an output section statement with this
1205 name, and its bfd section, if any, has compatible flags. */
1206 lang_add_section (&os->children, s, os, file);
1207 return TRUE;
1208 }
1209 }
1211 if (hold_text.os == NULL)
1212 hold_text.os = lang_output_section_find (".text");
1214 /* If this is a final link, then always put .gnu.warning.SYMBOL
1215 sections into the .text section to get them out of the way. */
1216 if (link_info.executable
1217 && ! link_info.relocatable
1218 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1219 && hold_text.os != NULL)
1220 {
1221 lang_add_section (&hold_text.os->children, s, hold_text.os, file);
1222 return TRUE;
1223 }
1225 /* Decide which segment the section should go in based on the
1226 section name and section flags. We put loadable .note sections
1227 right after the .interp section, so that the PT_NOTE segment is
1228 stored right after the program headers where the OS can read it
1229 in the first page. */
1230 #define HAVE_SECTION(hold, name) \
1231 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1233 place = NULL;
1234 if ((s->flags & SEC_ALLOC) == 0)
1235 ;
1236 else if ((s->flags & SEC_LOAD) != 0
1237 && strncmp (secname, ".note", 5) == 0
1238 && HAVE_SECTION (hold_interp, ".interp"))
1239 place = &hold_interp;
1240 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1241 && HAVE_SECTION (hold_bss, ".bss"))
1242 place = &hold_bss;
1243 else if ((s->flags & SEC_SMALL_DATA) != 0
1244 && HAVE_SECTION (hold_sdata, ".sdata"))
1245 place = &hold_sdata;
1246 else if ((s->flags & SEC_READONLY) == 0
1247 && HAVE_SECTION (hold_data, ".data"))
1248 place = &hold_data;
1249 else if (strncmp (secname, ".rel", 4) == 0
1250 && (s->flags & SEC_LOAD) != 0
1251 && (hold_rel.os != NULL
1252 || (hold_rel.os = output_rel_find (s, isdyn)) != NULL))
1253 place = &hold_rel;
1254 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == SEC_READONLY
1255 && HAVE_SECTION (hold_rodata, ".rodata"))
1256 place = &hold_rodata;
1257 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == (SEC_CODE | SEC_READONLY)
1258 && hold_text.os != NULL)
1259 place = &hold_text;
1261 #undef HAVE_SECTION
1263 /* Choose a unique name for the section. This will be needed if the
1264 same section name appears in the input file with different
1265 loadable or allocatable characteristics. But if the section
1266 already exists but does not have any flags set, then it has been
1267 created by the linker, probably as a result of a --section-start
1268 command line switch. */
1269 if ((sec = bfd_get_section_by_name (output_bfd, secname)) != NULL
1270 && bfd_get_section_flags (output_bfd, sec) != 0)
1271 {
1272 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1273 if (secname == NULL)
1274 einfo ("%F%P: place_orphan failed: %E\n");
1275 }
1277 /* Start building a list of statements for this section.
1278 First save the current statement pointer. */
1279 old = stat_ptr;
1281 /* If we have found an appropriate place for the output section
1282 statements for this orphan, add them to our own private list,
1283 inserting them later into the global statement list. */
1284 if (place != NULL)
1285 {
1286 stat_ptr = &add;
1287 lang_list_init (stat_ptr);
1288 }
1290 if (config.build_constructors)
1291 {
1292 /* If the name of the section is representable in C, then create
1293 symbols to mark the start and the end of the section. */
1294 for (ps = secname; *ps != '\0'; ps++)
1295 if (! ISALNUM (*ps) && *ps != '_')
1296 break;
1297 if (*ps == '\0')
1298 {
1299 char *symname;
1300 etree_type *e_align;
1302 symname = (char *) xmalloc (ps - secname + sizeof "__start_");
1303 sprintf (symname, "__start_%s", secname);
1304 e_align = exp_unop (ALIGN_K,
1305 exp_intop ((bfd_vma) 1 << s->alignment_power));
1306 lang_add_assignment (exp_assop ('=', symname, e_align));
1307 }
1308 }
1310 address = NULL;
1311 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1312 address = exp_intop ((bfd_vma) 0);
1314 load_base = NULL;
1315 if (place != NULL && place->os->load_base != NULL)
1316 {
1317 etree_type *lma_from_vma;
1318 lma_from_vma = exp_binop ('-', place->os->load_base,
1319 exp_nameop (ADDR, place->os->name));
1320 load_base = exp_binop ('+', lma_from_vma,
1321 exp_nameop (ADDR, secname));
1322 }
1324 os_tail = lang_output_section_statement.tail;
1325 os = lang_enter_output_section_statement (secname, address, 0,
1326 (etree_type *) NULL,
1327 (etree_type *) NULL,
1328 load_base, 0);
1330 lang_add_section (&os->children, s, os, file);
1332 lang_leave_output_section_statement
1333 ((bfd_vma) 0, "*default*",
1334 (struct lang_output_section_phdr_list *) NULL, NULL);
1336 if (config.build_constructors && *ps == '\0')
1337 {
1338 char *symname;
1340 /* lang_leave_ouput_section_statement resets stat_ptr. Put
1341 stat_ptr back where we want it. */
1342 if (place != NULL)
1343 stat_ptr = &add;
1345 symname = (char *) xmalloc (ps - secname + sizeof "__stop_");
1346 sprintf (symname, "__stop_%s", secname);
1347 lang_add_assignment (exp_assop ('=', symname,
1348 exp_nameop (NAME, ".")));
1349 }
1351 /* Restore the global list pointer. */
1352 stat_ptr = old;
1354 if (place != NULL && os->bfd_section != NULL)
1355 {
1356 asection *snew, **pps;
1358 snew = os->bfd_section;
1360 /* Shuffle the bfd section list to make the output file look
1361 neater. This is really only cosmetic. */
1362 if (place->section == NULL)
1363 {
1364 asection *bfd_section = place->os->bfd_section;
1366 /* If the output statement hasn't been used to place
1367 any input sections (and thus doesn't have an output
1368 bfd_section), look for the closest prior output statement
1369 having an output section. */
1370 if (bfd_section == NULL)
1371 bfd_section = output_prev_sec_find (place->os);
1373 if (bfd_section != NULL && bfd_section != snew)
1374 place->section = &bfd_section->next;
1375 }
1377 if (place->section != NULL)
1378 {
1379 /* Unlink the section. */
1380 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1381 ;
1382 bfd_section_list_remove (output_bfd, pps);
1384 /* Now tack it on to the "place->os" section list. */
1385 bfd_section_list_insert (output_bfd, place->section, snew);
1386 }
1388 /* Save the end of this list. Further ophans of this type will
1389 follow the one we've just added. */
1390 place->section = &snew->next;
1392 /* The following is non-cosmetic. We try to put the output
1393 statements in some sort of reasonable order here, because
1394 they determine the final load addresses of the orphan
1395 sections. In addition, placing output statements in the
1396 wrong order may require extra segments. For instance,
1397 given a typical situation of all read-only sections placed
1398 in one segment and following that a segment containing all
1399 the read-write sections, we wouldn't want to place an orphan
1400 read/write section before or amongst the read-only ones. */
1401 if (add.head != NULL)
1402 {
1403 lang_statement_union_type *newly_added_os;
1405 if (place->stmt == NULL)
1406 {
1407 /* Put the new statement list right at the head. */
1408 *add.tail = place->os->header.next;
1409 place->os->header.next = add.head;
1411 place->os_tail = &place->os->next;
1412 }
1413 else
1414 {
1415 /* Put it after the last orphan statement we added. */
1416 *add.tail = *place->stmt;
1417 *place->stmt = add.head;
1418 }
1420 /* Fix the global list pointer if we happened to tack our
1421 new list at the tail. */
1422 if (*old->tail == add.head)
1423 old->tail = add.tail;
1425 /* Save the end of this list. */
1426 place->stmt = add.tail;
1428 /* Do the same for the list of output section statements. */
1429 newly_added_os = *os_tail;
1430 *os_tail = NULL;
1431 newly_added_os->output_section_statement.next = *place->os_tail;
1432 *place->os_tail = newly_added_os;
1433 place->os_tail = &newly_added_os->output_section_statement.next;
1435 /* Fixing the global list pointer here is a little different.
1436 We added to the list in lang_enter_output_section_statement,
1437 trimmed off the new output_section_statment above when
1438 assigning *os_tail = NULL, but possibly added it back in
1439 the same place when assigning *place->os_tail. */
1440 if (*os_tail == NULL)
1441 lang_output_section_statement.tail = os_tail;
1442 }
1443 }
1445 return TRUE;
1446 }
1447 EOF
1448 fi
1450 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1451 cat >>e${EMULATION_NAME}.c <<EOF
1453 static void
1454 gld${EMULATION_NAME}_finish (void)
1455 {
1456 if (bfd_elf_discard_info (output_bfd, &link_info))
1457 {
1458 lang_reset_memory_regions ();
1460 /* Resize the sections. */
1461 lang_size_sections (stat_ptr->head, abs_output_section,
1462 &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
1464 /* Redo special stuff. */
1465 ldemul_after_allocation ();
1467 /* Do the assignments again. */
1468 lang_do_assignments (stat_ptr->head, abs_output_section,
1469 (fill_type *) 0, (bfd_vma) 0);
1470 }
1471 }
1472 EOF
1473 fi
1475 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1476 cat >>e${EMULATION_NAME}.c <<EOF
1478 static char *
1479 gld${EMULATION_NAME}_get_script (int *isfile)
1480 EOF
1482 if test -n "$COMPILE_IN"
1483 then
1484 # Scripts compiled in.
1486 # sed commands to quote an ld script as a C string.
1487 sc="-f stringify.sed"
1489 cat >>e${EMULATION_NAME}.c <<EOF
1490 {
1491 *isfile = 0;
1493 if (link_info.relocatable && config.build_constructors)
1494 return
1495 EOF
1496 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1497 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1498 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1499 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1500 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1501 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1502 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1503 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1504 fi
1505 if test -n "$GENERATE_PIE_SCRIPT" ; then
1506 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1507 echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1508 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1509 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1510 sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
1511 echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1512 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
1513 fi
1514 echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c
1515 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
1516 fi
1517 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1518 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1519 echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1520 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1521 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1522 sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
1523 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1524 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1525 fi
1526 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1527 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1528 fi
1529 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1530 echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1531 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1532 sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
1533 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1534 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1535 fi
1536 echo ' ; else return' >> e${EMULATION_NAME}.c
1537 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1538 echo '; }' >> e${EMULATION_NAME}.c
1540 else
1541 # Scripts read from the filesystem.
1543 cat >>e${EMULATION_NAME}.c <<EOF
1544 {
1545 *isfile = 1;
1547 if (link_info.relocatable && config.build_constructors)
1548 return "ldscripts/${EMULATION_NAME}.xu";
1549 else if (link_info.relocatable)
1550 return "ldscripts/${EMULATION_NAME}.xr";
1551 else if (!config.text_read_only)
1552 return "ldscripts/${EMULATION_NAME}.xbn";
1553 EOF
1554 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1555 else
1556 cat >>e${EMULATION_NAME}.c <<EOF
1557 else if (!config.magic_demand_paged)
1558 return "ldscripts/${EMULATION_NAME}.xn";
1559 EOF
1560 fi
1561 if test -n "$GENERATE_PIE_SCRIPT" ; then
1562 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1563 cat >>e${EMULATION_NAME}.c <<EOF
1564 else if (link_info.pie && link_info.combreloc
1565 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1566 return "ldscripts/${EMULATION_NAME}.xdw";
1567 else if (link_info.pie && link_info.combreloc)
1568 return "ldscripts/${EMULATION_NAME}.xdc";
1569 EOF
1570 fi
1571 cat >>e${EMULATION_NAME}.c <<EOF
1572 else if (link_info.pie)
1573 return "ldscripts/${EMULATION_NAME}.xd";
1574 EOF
1575 fi
1576 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1577 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1578 cat >>e${EMULATION_NAME}.c <<EOF
1579 else if (link_info.shared && link_info.combreloc
1580 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1581 return "ldscripts/${EMULATION_NAME}.xsw";
1582 else if (link_info.shared && link_info.combreloc)
1583 return "ldscripts/${EMULATION_NAME}.xsc";
1584 EOF
1585 fi
1586 cat >>e${EMULATION_NAME}.c <<EOF
1587 else if (link_info.shared)
1588 return "ldscripts/${EMULATION_NAME}.xs";
1589 EOF
1590 fi
1591 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1592 cat >>e${EMULATION_NAME}.c <<EOF
1593 else if (link_info.combreloc && link_info.relro
1594 && (link_info.flags & DT_BIND_NOW))
1595 return "ldscripts/${EMULATION_NAME}.xw";
1596 else if (link_info.combreloc)
1597 return "ldscripts/${EMULATION_NAME}.xc";
1598 EOF
1599 fi
1600 cat >>e${EMULATION_NAME}.c <<EOF
1601 else
1602 return "ldscripts/${EMULATION_NAME}.x";
1603 }
1605 EOF
1606 fi
1607 fi
1609 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1611 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1612 cat >>e${EMULATION_NAME}.c <<EOF
1613 $PARSE_AND_LIST_PROLOGUE
1614 EOF
1615 fi
1617 cat >>e${EMULATION_NAME}.c <<EOF
1619 #define OPTION_DISABLE_NEW_DTAGS (400)
1620 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1621 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1622 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
1624 static void
1625 gld${EMULATION_NAME}_add_options
1626 (int ns, char **shortopts, int nl, struct option **longopts,
1627 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1628 {
1629 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1630 static const struct option xtra_long[] = {
1631 EOF
1633 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1634 cat >>e${EMULATION_NAME}.c <<EOF
1635 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1636 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1637 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1638 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1639 EOF
1640 fi
1642 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1643 cat >>e${EMULATION_NAME}.c <<EOF
1644 $PARSE_AND_LIST_LONGOPTS
1645 EOF
1646 fi
1648 cat >>e${EMULATION_NAME}.c <<EOF
1649 {NULL, no_argument, NULL, 0}
1650 };
1652 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1653 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1654 *longopts = (struct option *)
1655 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1656 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1657 }
1659 static bfd_boolean
1660 gld${EMULATION_NAME}_handle_option (int optc)
1661 {
1662 switch (optc)
1663 {
1664 default:
1665 return FALSE;
1667 EOF
1669 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1670 cat >>e${EMULATION_NAME}.c <<EOF
1671 case OPTION_DISABLE_NEW_DTAGS:
1672 link_info.new_dtags = FALSE;
1673 break;
1675 case OPTION_ENABLE_NEW_DTAGS:
1676 link_info.new_dtags = TRUE;
1677 break;
1679 case OPTION_EH_FRAME_HDR:
1680 link_info.eh_frame_hdr = TRUE;
1681 break;
1683 case OPTION_GROUP:
1684 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1685 /* Groups must be self-contained. */
1686 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1687 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1688 break;
1690 case 'z':
1691 if (strcmp (optarg, "initfirst") == 0)
1692 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1693 else if (strcmp (optarg, "interpose") == 0)
1694 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1695 else if (strcmp (optarg, "loadfltr") == 0)
1696 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1697 else if (strcmp (optarg, "nodefaultlib") == 0)
1698 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1699 else if (strcmp (optarg, "nodelete") == 0)
1700 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1701 else if (strcmp (optarg, "nodlopen") == 0)
1702 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1703 else if (strcmp (optarg, "nodump") == 0)
1704 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1705 else if (strcmp (optarg, "now") == 0)
1706 {
1707 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1708 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1709 }
1710 else if (strcmp (optarg, "origin") == 0)
1711 {
1712 link_info.flags |= (bfd_vma) DF_ORIGIN;
1713 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1714 }
1715 else if (strcmp (optarg, "defs") == 0)
1716 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1717 else if (strcmp (optarg, "muldefs") == 0)
1718 link_info.allow_multiple_definition = TRUE;
1719 else if (strcmp (optarg, "combreloc") == 0)
1720 link_info.combreloc = TRUE;
1721 else if (strcmp (optarg, "nocombreloc") == 0)
1722 link_info.combreloc = FALSE;
1723 else if (strcmp (optarg, "nocopyreloc") == 0)
1724 link_info.nocopyreloc = TRUE;
1725 else if (strcmp (optarg, "execstack") == 0)
1726 {
1727 link_info.execstack = TRUE;
1728 link_info.noexecstack = FALSE;
1729 }
1730 else if (strcmp (optarg, "noexecstack") == 0)
1731 {
1732 link_info.noexecstack = TRUE;
1733 link_info.execstack = FALSE;
1734 }
1735 else if (strcmp (optarg, "relro") == 0)
1736 link_info.relro = TRUE;
1737 else if (strcmp (optarg, "norelro") == 0)
1738 link_info.relro = FALSE;
1739 /* What about the other Solaris -z options? FIXME. */
1740 break;
1741 EOF
1742 fi
1744 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1745 cat >>e${EMULATION_NAME}.c <<EOF
1746 $PARSE_AND_LIST_ARGS_CASES
1747 EOF
1748 fi
1750 cat >>e${EMULATION_NAME}.c <<EOF
1751 }
1753 return TRUE;
1754 }
1756 EOF
1758 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1759 cat >>e${EMULATION_NAME}.c <<EOF
1761 static void
1762 gld${EMULATION_NAME}_list_options (FILE * file)
1763 {
1764 EOF
1766 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1767 cat >>e${EMULATION_NAME}.c <<EOF
1768 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1769 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1770 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1771 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1772 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1773 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n"));
1774 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n"));
1775 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1776 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1777 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1778 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n"));
1779 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1780 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1781 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1782 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1783 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1784 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1785 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n"));
1786 fprintf (file, _(" -z norelro\t\tDon't create RELRO program header\n"));
1787 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1788 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n"));
1789 fprintf (file, _(" -z relro\t\tCreate RELRO program header\n"));
1790 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1791 EOF
1792 fi
1794 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1795 cat >>e${EMULATION_NAME}.c <<EOF
1796 $PARSE_AND_LIST_OPTIONS
1797 EOF
1798 fi
1800 cat >>e${EMULATION_NAME}.c <<EOF
1801 }
1802 EOF
1804 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1805 cat >>e${EMULATION_NAME}.c <<EOF
1806 $PARSE_AND_LIST_EPILOGUE
1807 EOF
1808 fi
1809 fi
1810 else
1811 cat >>e${EMULATION_NAME}.c <<EOF
1812 #define gld${EMULATION_NAME}_add_options NULL
1813 #define gld${EMULATION_NAME}_handle_option NULL
1814 EOF
1815 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1816 cat >>e${EMULATION_NAME}.c <<EOF
1817 #define gld${EMULATION_NAME}_list_options NULL
1818 EOF
1819 fi
1820 fi
1822 cat >>e${EMULATION_NAME}.c <<EOF
1824 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1825 {
1826 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1827 ${LDEMUL_SYSLIB-syslib_default},
1828 ${LDEMUL_HLL-hll_default},
1829 ${LDEMUL_AFTER_PARSE-after_parse_default},
1830 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1831 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1832 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1833 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1834 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1835 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1836 "${EMULATION_NAME}",
1837 "${OUTPUT_FORMAT}",
1838 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1839 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1840 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1841 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1842 ${LDEMUL_SET_SYMBOLS-NULL},
1843 ${LDEMUL_PARSE_ARGS-NULL},
1844 gld${EMULATION_NAME}_add_options,
1845 gld${EMULATION_NAME}_handle_option,
1846 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1847 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1848 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
1849 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1850 ${LDEMUL_NEW_VERS_PATTERN-NULL}
1851 };
1852 EOF