| blob | 92f502d9d7e97c33ec2dd83f9617d962998b3409 |
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 if (!entry->as_needed
100 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
101 return FALSE;
103 /* Tell the ELF linker that we don't want the output file to have a
104 DT_NEEDED entry for this file, unless it is used to resolve
105 references in a regular object. */
106 bfd_elf_set_dyn_lib_class (entry->the_bfd, DYN_AS_NEEDED);
108 /* Continue on with normal load_symbols processing. */
109 return FALSE;
110 }
111 EOF
112 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 bfd_boolean global_found;
122 static struct bfd_link_needed_list *global_vercheck_needed;
123 static bfd_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
136 link path.
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. */
143 static void
144 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
145 {
146 const char *soname;
147 struct bfd_link_needed_list *l;
149 if (global_vercheck_failed)
150 return;
151 if (s->the_bfd == NULL
152 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
153 return;
155 soname = bfd_elf_get_dt_soname (s->the_bfd);
156 if (soname == NULL)
157 soname = lbasename (bfd_get_filename (s->the_bfd));
159 for (l = global_vercheck_needed; l != NULL; l = l->next)
160 {
161 const char *suffix;
163 if (strcmp (soname, l->name) == 0)
164 {
165 /* Probably can't happen, but it's an easy check. */
166 continue;
167 }
169 if (strchr (l->name, '/') != NULL)
170 continue;
172 suffix = strstr (l->name, ".so.");
173 if (suffix == NULL)
174 continue;
176 suffix += sizeof ".so." - 1;
178 if (strncmp (soname, l->name, suffix - l->name) == 0)
179 {
180 /* Here we know that S is a dynamic object FOO.SO.VER1, and
181 the object we are considering needs a dynamic object
182 FOO.SO.VER2, and VER1 and VER2 are different. This
183 appears to be a version mismatch, so we tell the caller
184 to try a different version of this library. */
185 global_vercheck_failed = TRUE;
186 return;
187 }
188 }
189 }
192 /* See if an input file matches a DT_NEEDED entry by running stat on
193 the file. */
195 static void
196 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
197 {
198 struct stat st;
199 const char *suffix;
200 const char *soname;
202 if (global_found)
203 return;
204 if (s->the_bfd == NULL)
205 return;
207 if (bfd_stat (s->the_bfd, &st) != 0)
208 {
209 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
210 return;
211 }
213 if (st.st_dev == global_stat.st_dev
214 && st.st_ino == global_stat.st_ino)
215 {
216 global_found = TRUE;
217 return;
218 }
220 /* We issue a warning if it looks like we are including two
221 different versions of the same shared library. For example,
222 there may be a problem if -lc picks up libc.so.6 but some other
223 shared library has a DT_NEEDED entry of libc.so.5. This is a
224 heuristic test, and it will only work if the name looks like
225 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
226 If we really want to issue warnings about mixing version numbers
227 of shared libraries, we need to find a better way. */
229 if (strchr (global_needed->name, '/') != NULL)
230 return;
231 suffix = strstr (global_needed->name, ".so.");
232 if (suffix == NULL)
233 return;
234 suffix += sizeof ".so." - 1;
236 soname = bfd_elf_get_dt_soname (s->the_bfd);
237 if (soname == NULL)
238 soname = lbasename (s->filename);
240 if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
241 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
242 global_needed->name, global_needed->by, soname);
243 }
246 /* This function is called for each possible name for a dynamic object
247 named by a DT_NEEDED entry. The FORCE parameter indicates whether
248 to skip the check for a conflicting version. */
250 static bfd_boolean
251 gld${EMULATION_NAME}_try_needed (const char *name, int force)
252 {
253 bfd *abfd;
254 const char *soname;
256 abfd = bfd_openr (name, bfd_get_target (output_bfd));
257 if (abfd == NULL)
258 return FALSE;
259 if (! bfd_check_format (abfd, bfd_object))
260 {
261 bfd_close (abfd);
262 return FALSE;
263 }
264 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
265 {
266 bfd_close (abfd);
267 return FALSE;
268 }
270 /* For DT_NEEDED, they have to match. */
271 if (abfd->xvec != output_bfd->xvec)
272 {
273 bfd_close (abfd);
274 return FALSE;
275 }
277 /* Check whether this object would include any conflicting library
278 versions. If FORCE is set, then we skip this check; we use this
279 the second time around, if we couldn't find any compatible
280 instance of the shared library. */
282 if (! force)
283 {
284 struct bfd_link_needed_list *needed;
286 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
287 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
289 if (needed != NULL)
290 {
291 global_vercheck_needed = needed;
292 global_vercheck_failed = FALSE;
293 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
294 if (global_vercheck_failed)
295 {
296 bfd_close (abfd);
297 /* Return FALSE to force the caller to move on to try
298 another file on the search path. */
299 return FALSE;
300 }
302 /* But wait! It gets much worse. On Linux, if a shared
303 library does not use libc at all, we are supposed to skip
304 it the first time around in case we encounter a shared
305 library later on with the same name which does use the
306 version of libc that we want. This is much too horrible
307 to use on any system other than Linux. */
309 EOF
310 case ${target} in
311 *-*-linux-gnu*)
312 cat >>e${EMULATION_NAME}.c <<EOF
313 {
314 struct bfd_link_needed_list *l;
316 for (l = needed; l != NULL; l = l->next)
317 if (strncmp (l->name, "libc.so", 7) == 0)
318 break;
319 if (l == NULL)
320 {
321 bfd_close (abfd);
322 return FALSE;
323 }
324 }
326 EOF
327 ;;
328 esac
329 cat >>e${EMULATION_NAME}.c <<EOF
330 }
331 }
333 /* We've found a dynamic object matching the DT_NEEDED entry. */
335 /* We have already checked that there is no other input file of the
336 same name. We must now check again that we are not including the
337 same file twice. We need to do this because on many systems
338 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
339 reference libc.so.1. If we have already included libc.so, we
340 don't want to include libc.so.1 if they are the same file, and we
341 can only check that using stat. */
343 if (bfd_stat (abfd, &global_stat) != 0)
344 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
346 /* First strip off everything before the last '/'. */
347 soname = lbasename (abfd->filename);
349 if (trace_file_tries)
350 info_msg (_("found %s at %s\n"), soname, name);
352 global_found = FALSE;
353 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
354 if (global_found)
355 {
356 /* Return TRUE to indicate that we found the file, even though
357 we aren't going to do anything with it. */
358 return TRUE;
359 }
361 /* Specify the soname to use. */
362 bfd_elf_set_dt_needed_name (abfd, soname);
364 /* Tell the ELF linker that we don't want the output file to have a
365 DT_NEEDED entry for this file, unless it is used to resolve
366 references in a regular object. */
367 bfd_elf_set_dyn_lib_class (abfd, DYN_DT_NEEDED);
369 /* Add this file into the symbol table. */
370 if (! bfd_link_add_symbols (abfd, &link_info))
371 einfo ("%F%B: could not read symbols: %E\n", abfd);
373 return TRUE;
374 }
377 /* Search for a needed file in a path. */
379 static bfd_boolean
380 gld${EMULATION_NAME}_search_needed (const char *path, const char *name, int force)
381 {
382 const char *s;
383 size_t len;
385 if (name[0] == '/')
386 return gld${EMULATION_NAME}_try_needed (name, force);
388 if (path == NULL || *path == '\0')
389 return FALSE;
390 len = strlen (name);
391 while (1)
392 {
393 char *filename, *sset;
395 s = strchr (path, ':');
396 if (s == NULL)
397 s = path + strlen (path);
399 filename = (char *) xmalloc (s - path + len + 2);
400 if (s == path)
401 sset = filename;
402 else
403 {
404 memcpy (filename, path, s - path);
405 filename[s - path] = '/';
406 sset = filename + (s - path) + 1;
407 }
408 strcpy (sset, name);
410 if (gld${EMULATION_NAME}_try_needed (filename, force))
411 return TRUE;
413 free (filename);
415 if (*s == '\0')
416 break;
417 path = s + 1;
418 }
420 return FALSE;
421 }
423 EOF
424 if [ "x${USE_LIBPATH}" = xyes ] ; then
425 cat >>e${EMULATION_NAME}.c <<EOF
427 /* Add the sysroot to every entry in a colon-separated path. */
429 static char *
430 gld${EMULATION_NAME}_add_sysroot (const char *path)
431 {
432 int len, colons, i;
433 char *ret, *p;
435 len = strlen (path);
436 colons = 0;
437 i = 0;
438 while (path[i])
439 if (path[i++] == ':')
440 colons++;
442 if (path[i])
443 colons++;
445 len = len + (colons + 1) * strlen (ld_sysroot);
446 ret = xmalloc (len + 1);
447 strcpy (ret, ld_sysroot);
448 p = ret + strlen (ret);
449 i = 0;
450 while (path[i])
451 if (path[i] == ':')
452 {
453 *p++ = path[i++];
454 strcpy (p, ld_sysroot);
455 p = p + strlen (p);
456 }
457 else
458 *p++ = path[i++];
460 *p = 0;
461 return ret;
462 }
464 EOF
465 case ${target} in
466 *-*-linux-gnu*)
467 cat >>e${EMULATION_NAME}.c <<EOF
468 /* For a native linker, check the file /etc/ld.so.conf for directories
469 in which we may find shared libraries. /etc/ld.so.conf is really
470 only meaningful on Linux. */
472 static bfd_boolean
473 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
474 {
475 static bfd_boolean initialized;
476 static char *ld_so_conf;
478 if (! initialized)
479 {
480 FILE *f;
481 char *tmppath;
483 tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL);
484 f = fopen (tmppath, FOPEN_RT);
485 free (tmppath);
486 if (f != NULL)
487 {
488 char *b;
489 size_t len, alloc;
490 int c;
492 len = 0;
493 alloc = 100;
494 b = (char *) xmalloc (alloc);
496 while ((c = getc (f)) != EOF)
497 {
498 if (len + 1 >= alloc)
499 {
500 alloc *= 2;
501 b = (char *) xrealloc (b, alloc);
502 }
503 if (c != ':'
504 && c != ' '
505 && c != '\t'
506 && c != '\n'
507 && c != ',')
508 {
509 b[len] = c;
510 ++len;
511 }
512 else
513 {
514 if (len > 0 && b[len - 1] != ':')
515 {
516 b[len] = ':';
517 ++len;
518 }
519 }
520 }
522 if (len > 0 && b[len - 1] == ':')
523 --len;
525 if (len > 0)
526 b[len] = '\0';
527 else
528 {
529 free (b);
530 b = NULL;
531 }
533 fclose (f);
535 if (b)
536 {
537 char *d = gld${EMULATION_NAME}_add_sysroot (b);
538 free (b);
539 b = d;
540 }
542 ld_so_conf = b;
543 }
545 initialized = TRUE;
546 }
548 if (ld_so_conf == NULL)
549 return FALSE;
551 return gld${EMULATION_NAME}_search_needed (ld_so_conf, name, force);
552 }
554 EOF
555 # Linux
556 ;;
557 esac
558 fi
559 cat >>e${EMULATION_NAME}.c <<EOF
561 /* See if an input file matches a DT_NEEDED entry by name. */
563 static void
564 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
565 {
566 if (global_found)
567 return;
569 if (s->filename != NULL)
570 {
571 const char *f;
573 if (strcmp (s->filename, global_needed->name) == 0)
574 {
575 global_found = TRUE;
576 return;
577 }
579 if (s->search_dirs_flag)
580 {
581 f = strrchr (s->filename, '/');
582 if (f != NULL
583 && strcmp (f + 1, global_needed->name) == 0)
584 {
585 global_found = TRUE;
586 return;
587 }
588 }
589 }
591 if (s->the_bfd != NULL)
592 {
593 const char *soname;
595 soname = bfd_elf_get_dt_soname (s->the_bfd);
596 if (soname != NULL
597 && strcmp (soname, global_needed->name) == 0)
598 {
599 global_found = TRUE;
600 return;
601 }
602 }
603 }
605 EOF
607 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
608 cat >>e${EMULATION_NAME}.c <<EOF
610 /* This is called after all the input files have been opened. */
612 static void
613 gld${EMULATION_NAME}_after_open (void)
614 {
615 struct bfd_link_needed_list *needed, *l;
617 /* We only need to worry about this when doing a final link. */
618 if (link_info.relocatable || !link_info.executable)
619 return;
621 /* Get the list of files which appear in DT_NEEDED entries in
622 dynamic objects included in the link (often there will be none).
623 For each such file, we want to track down the corresponding
624 library, and include the symbol table in the link. This is what
625 the runtime dynamic linker will do. Tracking the files down here
626 permits one dynamic object to include another without requiring
627 special action by the person doing the link. Note that the
628 needed list can actually grow while we are stepping through this
629 loop. */
630 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
631 for (l = needed; l != NULL; l = l->next)
632 {
633 struct bfd_link_needed_list *ll;
634 int force;
636 /* If we've already seen this file, skip it. */
637 for (ll = needed; ll != l; ll = ll->next)
638 if (strcmp (ll->name, l->name) == 0)
639 break;
640 if (ll != l)
641 continue;
643 /* See if this file was included in the link explicitly. */
644 global_needed = l;
645 global_found = FALSE;
646 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
647 if (global_found)
648 continue;
650 if (trace_file_tries)
651 info_msg (_("%s needed by %B\n"), l->name, l->by);
653 /* We need to find this file and include the symbol table. We
654 want to search for the file in the same way that the dynamic
655 linker will search. That means that we want to use
656 rpath_link, rpath, then the environment variable
657 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
658 entries (native only), then the linker script LIB_SEARCH_DIRS.
659 We do not search using the -L arguments.
661 We search twice. The first time, we skip objects which may
662 introduce version mismatches. The second time, we force
663 their use. See gld${EMULATION_NAME}_vercheck comment. */
664 for (force = 0; force < 2; force++)
665 {
666 size_t len;
667 search_dirs_type *search;
668 EOF
669 if [ "x${USE_LIBPATH}" = xyes ] ; then
670 cat >>e${EMULATION_NAME}.c <<EOF
671 const char *lib_path;
672 struct bfd_link_needed_list *rp;
673 int found;
674 EOF
675 fi
676 cat >>e${EMULATION_NAME}.c <<EOF
678 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
679 l->name, force))
680 break;
681 EOF
682 if [ "x${USE_LIBPATH}" = xyes ] ; then
683 cat >>e${EMULATION_NAME}.c <<EOF
684 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
685 l->name, force))
686 break;
687 EOF
688 fi
689 if [ "x${NATIVE}" = xyes ] ; then
690 cat >>e${EMULATION_NAME}.c <<EOF
691 if (command_line.rpath_link == NULL
692 && command_line.rpath == NULL)
693 {
694 lib_path = (const char *) getenv ("LD_RUN_PATH");
695 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name,
696 force))
697 break;
698 }
699 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
700 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, force))
701 break;
702 EOF
703 fi
704 if [ "x${USE_LIBPATH}" = xyes ] ; then
705 cat >>e${EMULATION_NAME}.c <<EOF
706 found = 0;
707 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
708 for (; !found && rp != NULL; rp = rp->next)
709 {
710 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
711 found = (rp->by == l->by
712 && gld${EMULATION_NAME}_search_needed (tmpname,
713 l->name,
714 force));
715 free (tmpname);
716 }
717 if (found)
718 break;
720 EOF
721 fi
722 cat >>e${EMULATION_NAME}.c <<EOF
723 len = strlen (l->name);
724 for (search = search_head; search != NULL; search = search->next)
725 {
726 char *filename;
728 if (search->cmdline)
729 continue;
730 filename = (char *) xmalloc (strlen (search->name) + len + 2);
731 sprintf (filename, "%s/%s", search->name, l->name);
732 if (gld${EMULATION_NAME}_try_needed (filename, force))
733 break;
734 free (filename);
735 }
736 if (search != NULL)
737 break;
738 EOF
739 if [ "x${USE_LIBPATH}" = xyes ] ; then
740 case ${target} in
741 *-*-linux-gnu*)
742 cat >>e${EMULATION_NAME}.c <<EOF
743 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
744 break;
745 EOF
746 # Linux
747 ;;
748 esac
749 fi
750 cat >>e${EMULATION_NAME}.c <<EOF
751 }
753 if (force < 2)
754 continue;
756 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
757 l->name, l->by);
758 }
759 }
761 EOF
762 fi
764 cat >>e${EMULATION_NAME}.c <<EOF
766 /* Look through an expression for an assignment statement. */
768 static void
769 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
770 {
771 struct bfd_link_hash_entry *h;
773 switch (exp->type.node_class)
774 {
775 case etree_provide:
776 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
777 FALSE, FALSE, FALSE);
778 if (h == NULL)
779 break;
781 /* We call record_link_assignment even if the symbol is defined.
782 This is because if it is defined by a dynamic object, we
783 actually want to use the value defined by the linker script,
784 not the value from the dynamic object (because we are setting
785 symbols like etext). If the symbol is defined by a regular
786 object, then, as it happens, calling record_link_assignment
787 will do no harm. */
789 /* Fall through. */
790 case etree_assign:
791 if (strcmp (exp->assign.dst, ".") != 0)
792 {
793 if (! (bfd_elf_record_link_assignment
794 (output_bfd, &link_info, exp->assign.dst,
795 exp->type.node_class == etree_provide ? TRUE : FALSE)))
796 einfo ("%P%F: failed to record assignment to %s: %E\n",
797 exp->assign.dst);
798 }
799 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
800 break;
802 case etree_binary:
803 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
804 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
805 break;
807 case etree_trinary:
808 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
809 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
810 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
811 break;
813 case etree_unary:
814 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
815 break;
817 default:
818 break;
819 }
820 }
823 /* This is called by the before_allocation routine via
824 lang_for_each_statement. It locates any assignment statements, and
825 tells the ELF backend about them, in case they are assignments to
826 symbols which are referred to by dynamic objects. */
828 static void
829 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
830 {
831 if (s->header.type == lang_assignment_statement_enum)
832 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
833 }
835 EOF
837 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
838 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
839 ELF_INTERPRETER_SET_DEFAULT="
840 if (sinterp != NULL)
841 {
842 sinterp->contents = ${ELF_INTERPRETER_NAME};
843 sinterp->_raw_size = strlen (sinterp->contents) + 1;
844 }
846 "
847 else
848 ELF_INTERPRETER_SET_DEFAULT=
849 fi
850 cat >>e${EMULATION_NAME}.c <<EOF
852 /* This is called after the sections have been attached to output
853 sections, but before any sizes or addresses have been set. */
855 static void
856 gld${EMULATION_NAME}_before_allocation (void)
857 {
858 const char *rpath;
859 asection *sinterp;
861 if (link_info.hash->type == bfd_link_elf_hash_table)
862 _bfd_elf_tls_setup (output_bfd, &link_info);
864 /* If we are going to make any variable assignments, we need to let
865 the ELF backend know about them in case the variables are
866 referred to by dynamic objects. */
867 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
869 /* Let the ELF backend work out the sizes of any sections required
870 by dynamic linking. */
871 rpath = command_line.rpath;
872 if (rpath == NULL)
873 rpath = (const char *) getenv ("LD_RUN_PATH");
874 if (! (bfd_elf_size_dynamic_sections
875 (output_bfd, command_line.soname, rpath,
876 command_line.filter_shlib,
877 (const char * const *) command_line.auxiliary_filters,
878 &link_info, &sinterp, lang_elf_version_info)))
879 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
880 ${ELF_INTERPRETER_SET_DEFAULT}
881 /* Let the user override the dynamic linker we are using. */
882 if (command_line.interpreter != NULL
883 && sinterp != NULL)
884 {
885 sinterp->contents = (bfd_byte *) command_line.interpreter;
886 sinterp->_raw_size = strlen (command_line.interpreter) + 1;
887 }
889 /* Look for any sections named .gnu.warning. As a GNU extensions,
890 we treat such sections as containing warning messages. We print
891 out the warning message, and then zero out the section size so
892 that it does not get copied into the output file. */
894 {
895 LANG_FOR_EACH_INPUT_STATEMENT (is)
896 {
897 asection *s;
898 bfd_size_type sz;
899 bfd_size_type prefix_len;
900 char *msg;
901 bfd_boolean ret;
902 const char * gnu_warning_prefix = _("warning: ");
904 if (is->just_syms_flag)
905 continue;
907 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
908 if (s == NULL)
909 continue;
911 sz = bfd_section_size (is->the_bfd, s);
912 prefix_len = strlen (gnu_warning_prefix);
913 msg = xmalloc ((size_t) (prefix_len + sz + 1));
914 strcpy (msg, gnu_warning_prefix);
915 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len,
916 (file_ptr) 0, sz))
917 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
918 is->the_bfd);
919 msg[prefix_len + sz] = '\0';
920 ret = link_info.callbacks->warning (&link_info, msg,
921 (const char *) NULL,
922 is->the_bfd, (asection *) NULL,
923 (bfd_vma) 0);
924 ASSERT (ret);
925 free (msg);
927 /* Clobber the section size, so that we don't waste copying the
928 warning into the output file. */
929 s->_raw_size = 0;
930 }
931 }
932 }
934 EOF
935 fi
937 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
938 cat >>e${EMULATION_NAME}.c <<EOF
940 /* Try to open a dynamic archive. This is where we know that ELF
941 dynamic libraries have an extension of .so (or .sl on oddball systems
942 like hpux). */
944 static bfd_boolean
945 gld${EMULATION_NAME}_open_dynamic_archive
946 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
947 {
948 const char *filename;
949 char *string;
951 if (! entry->is_archive)
952 return FALSE;
954 filename = entry->filename;
956 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
957 is defined, but it does not seem worth the headache to optimize
958 away those two bytes of space. */
959 string = (char *) xmalloc (strlen (search->name)
960 + strlen (filename)
961 + strlen (arch)
962 #ifdef EXTRA_SHLIB_EXTENSION
963 + strlen (EXTRA_SHLIB_EXTENSION)
964 #endif
965 + sizeof "/lib.so");
967 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
969 #ifdef EXTRA_SHLIB_EXTENSION
970 /* Try the .so extension first. If that fails build a new filename
971 using EXTRA_SHLIB_EXTENSION. */
972 if (! ldfile_try_open_bfd (string, entry))
973 sprintf (string, "%s/lib%s%s%s", search->name,
974 filename, arch, EXTRA_SHLIB_EXTENSION);
975 #endif
977 if (! ldfile_try_open_bfd (string, entry))
978 {
979 free (string);
980 return FALSE;
981 }
983 entry->filename = string;
985 /* We have found a dynamic object to include in the link. The ELF
986 backend linker will create a DT_NEEDED entry in the .dynamic
987 section naming this file. If this file includes a DT_SONAME
988 entry, it will be used. Otherwise, the ELF linker will just use
989 the name of the file. For an archive found by searching, like
990 this one, the DT_NEEDED entry should consist of just the name of
991 the file, without the path information used to find it. Note
992 that we only need to do this if we have a dynamic object; an
993 archive will never be referenced by a DT_NEEDED entry.
995 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
996 very pretty. I haven't been able to think of anything that is
997 pretty, though. */
998 if (bfd_check_format (entry->the_bfd, bfd_object)
999 && (entry->the_bfd->flags & DYNAMIC) != 0)
1000 {
1001 ASSERT (entry->is_archive && entry->search_dirs_flag);
1003 /* Rather than duplicating the logic above. Just use the
1004 filename we recorded earlier. */
1006 filename = lbasename (entry->filename);
1007 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1008 }
1010 return TRUE;
1011 }
1013 EOF
1014 fi
1016 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1017 cat >>e${EMULATION_NAME}.c <<EOF
1019 /* A variant of lang_output_section_find. Used by place_orphan. */
1021 static lang_output_section_statement_type *
1022 output_rel_find (asection *sec, int isdyn)
1023 {
1024 lang_statement_union_type *u;
1025 lang_output_section_statement_type *lookup;
1026 lang_output_section_statement_type *last = NULL;
1027 lang_output_section_statement_type *last_alloc = NULL;
1028 lang_output_section_statement_type *last_rel = NULL;
1029 lang_output_section_statement_type *last_rel_alloc = NULL;
1030 int rela = sec->name[4] == 'a';
1032 for (u = lang_output_section_statement.head; u; u = lookup->next)
1033 {
1034 lookup = &u->output_section_statement;
1035 if (strncmp (".rel", lookup->name, 4) == 0)
1036 {
1037 int lookrela = lookup->name[4] == 'a';
1039 /* .rel.dyn must come before all other reloc sections, to suit
1040 GNU ld.so. */
1041 if (isdyn)
1042 break;
1044 /* Don't place after .rel.plt as doing so results in wrong
1045 dynamic tags. */
1046 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1047 break;
1049 if (rela == lookrela || last_rel == NULL)
1050 last_rel = lookup;
1051 if ((rela == lookrela || last_rel_alloc == NULL)
1052 && lookup->bfd_section != NULL
1053 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1054 last_rel_alloc = lookup;
1055 }
1057 last = lookup;
1058 if (lookup->bfd_section != NULL
1059 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1060 last_alloc = lookup;
1061 }
1063 if (last_rel_alloc)
1064 return last_rel_alloc;
1066 if (last_rel)
1067 return last_rel;
1069 if (last_alloc)
1070 return last_alloc;
1072 return last;
1073 }
1075 /* Find the last output section before given output statement.
1076 Used by place_orphan. */
1078 static asection *
1079 output_prev_sec_find (lang_output_section_statement_type *os)
1080 {
1081 asection *s = (asection *) NULL;
1082 lang_statement_union_type *u;
1083 lang_output_section_statement_type *lookup;
1085 for (u = lang_output_section_statement.head;
1086 u != (lang_statement_union_type *) NULL;
1087 u = lookup->next)
1088 {
1089 lookup = &u->output_section_statement;
1090 if (lookup == os)
1091 return s;
1093 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1094 s = lookup->bfd_section;
1095 }
1097 return NULL;
1098 }
1100 /* Place an orphan section. We use this to put random SHF_ALLOC
1101 sections in the right segment. */
1103 struct orphan_save {
1104 lang_output_section_statement_type *os;
1105 asection **section;
1106 lang_statement_union_type **stmt;
1107 lang_statement_union_type **os_tail;
1108 };
1110 static bfd_boolean
1111 gld${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1112 {
1113 static struct orphan_save hold_text;
1114 static struct orphan_save hold_rodata;
1115 static struct orphan_save hold_data;
1116 static struct orphan_save hold_bss;
1117 static struct orphan_save hold_rel;
1118 static struct orphan_save hold_interp;
1119 static struct orphan_save hold_sdata;
1120 static int count = 1;
1121 struct orphan_save *place;
1122 lang_statement_list_type *old;
1123 lang_statement_list_type add;
1124 etree_type *address;
1125 const char *secname;
1126 const char *ps = NULL;
1127 lang_output_section_statement_type *os;
1128 lang_statement_union_type **os_tail;
1129 etree_type *load_base;
1130 int isdyn = 0;
1132 secname = bfd_get_section_name (s->owner, s);
1133 if (! link_info.relocatable
1134 && link_info.combreloc
1135 && (s->flags & SEC_ALLOC)
1136 && strncmp (secname, ".rel", 4) == 0)
1137 {
1138 if (secname[4] == 'a')
1139 secname = ".rela.dyn";
1140 else
1141 secname = ".rel.dyn";
1142 isdyn = 1;
1143 }
1145 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (secname)))
1146 {
1147 /* Look through the script to see where to place this section. */
1148 os = lang_output_section_find (secname);
1150 if (os != NULL
1151 && (os->bfd_section == NULL
1152 || ((s->flags ^ os->bfd_section->flags)
1153 & (SEC_LOAD | SEC_ALLOC)) == 0))
1154 {
1155 /* We already have an output section statement with this
1156 name, and its bfd section, if any, has compatible flags. */
1157 lang_add_section (&os->children, s, os, file);
1158 return TRUE;
1159 }
1160 }
1162 if (hold_text.os == NULL)
1163 hold_text.os = lang_output_section_find (".text");
1165 /* If this is a final link, then always put .gnu.warning.SYMBOL
1166 sections into the .text section to get them out of the way. */
1167 if (link_info.executable
1168 && ! link_info.relocatable
1169 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1170 && hold_text.os != NULL)
1171 {
1172 lang_add_section (&hold_text.os->children, s, hold_text.os, file);
1173 return TRUE;
1174 }
1176 /* Decide which segment the section should go in based on the
1177 section name and section flags. We put loadable .note sections
1178 right after the .interp section, so that the PT_NOTE segment is
1179 stored right after the program headers where the OS can read it
1180 in the first page. */
1181 #define HAVE_SECTION(hold, name) \
1182 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1184 if ((s->flags & SEC_EXCLUDE) != 0 && !link_info.relocatable)
1185 {
1186 if (s->output_section == NULL)
1187 s->output_section = bfd_abs_section_ptr;
1188 return TRUE;
1189 }
1191 place = NULL;
1192 if ((s->flags & SEC_ALLOC) == 0)
1193 ;
1194 else if ((s->flags & SEC_LOAD) != 0
1195 && strncmp (secname, ".note", 5) == 0
1196 && HAVE_SECTION (hold_interp, ".interp"))
1197 place = &hold_interp;
1198 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1199 && HAVE_SECTION (hold_bss, ".bss"))
1200 place = &hold_bss;
1201 else if ((s->flags & SEC_SMALL_DATA) != 0
1202 && HAVE_SECTION (hold_sdata, ".sdata"))
1203 place = &hold_sdata;
1204 else if ((s->flags & SEC_READONLY) == 0
1205 && HAVE_SECTION (hold_data, ".data"))
1206 place = &hold_data;
1207 else if (strncmp (secname, ".rel", 4) == 0
1208 && (s->flags & SEC_LOAD) != 0
1209 && (hold_rel.os != NULL
1210 || (hold_rel.os = output_rel_find (s, isdyn)) != NULL))
1211 place = &hold_rel;
1212 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == SEC_READONLY
1213 && HAVE_SECTION (hold_rodata, ".rodata"))
1214 place = &hold_rodata;
1215 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == (SEC_CODE | SEC_READONLY)
1216 && hold_text.os != NULL)
1217 place = &hold_text;
1219 #undef HAVE_SECTION
1221 /* Choose a unique name for the section. This will be needed if the
1222 same section name appears in the input file with different
1223 loadable or allocatable characteristics. */
1224 if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1225 {
1226 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1227 if (secname == NULL)
1228 einfo ("%F%P: place_orphan failed: %E\n");
1229 }
1231 /* Start building a list of statements for this section.
1232 First save the current statement pointer. */
1233 old = stat_ptr;
1235 /* If we have found an appropriate place for the output section
1236 statements for this orphan, add them to our own private list,
1237 inserting them later into the global statement list. */
1238 if (place != NULL)
1239 {
1240 stat_ptr = &add;
1241 lang_list_init (stat_ptr);
1242 }
1244 if (config.build_constructors)
1245 {
1246 /* If the name of the section is representable in C, then create
1247 symbols to mark the start and the end of the section. */
1248 for (ps = secname; *ps != '\0'; ps++)
1249 if (! ISALNUM (*ps) && *ps != '_')
1250 break;
1251 if (*ps == '\0')
1252 {
1253 char *symname;
1254 etree_type *e_align;
1256 symname = (char *) xmalloc (ps - secname + sizeof "__start_");
1257 sprintf (symname, "__start_%s", secname);
1258 e_align = exp_unop (ALIGN_K,
1259 exp_intop ((bfd_vma) 1 << s->alignment_power));
1260 lang_add_assignment (exp_assop ('=', symname, e_align));
1261 }
1262 }
1264 address = NULL;
1265 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1266 address = exp_intop ((bfd_vma) 0);
1268 load_base = NULL;
1269 if (place != NULL && place->os->load_base != NULL)
1270 {
1271 etree_type *lma_from_vma;
1272 lma_from_vma = exp_binop ('-', place->os->load_base,
1273 exp_nameop (ADDR, place->os->name));
1274 load_base = exp_binop ('+', lma_from_vma,
1275 exp_nameop (ADDR, secname));
1276 }
1278 os_tail = lang_output_section_statement.tail;
1279 os = lang_enter_output_section_statement (secname, address, 0,
1280 (etree_type *) NULL,
1281 (etree_type *) NULL,
1282 load_base);
1284 lang_add_section (&os->children, s, os, file);
1286 lang_leave_output_section_statement
1287 ((bfd_vma) 0, "*default*",
1288 (struct lang_output_section_phdr_list *) NULL, NULL);
1290 if (config.build_constructors && *ps == '\0')
1291 {
1292 char *symname;
1294 /* lang_leave_ouput_section_statement resets stat_ptr. Put
1295 stat_ptr back where we want it. */
1296 if (place != NULL)
1297 stat_ptr = &add;
1299 symname = (char *) xmalloc (ps - secname + sizeof "__stop_");
1300 sprintf (symname, "__stop_%s", secname);
1301 lang_add_assignment (exp_assop ('=', symname,
1302 exp_nameop (NAME, ".")));
1303 }
1305 /* Restore the global list pointer. */
1306 stat_ptr = old;
1308 if (place != NULL && os->bfd_section != NULL)
1309 {
1310 asection *snew, **pps;
1312 snew = os->bfd_section;
1314 /* Shuffle the bfd section list to make the output file look
1315 neater. This is really only cosmetic. */
1316 if (place->section == NULL)
1317 {
1318 asection *bfd_section = place->os->bfd_section;
1320 /* If the output statement hasn't been used to place
1321 any input sections (and thus doesn't have an output
1322 bfd_section), look for the closest prior output statement
1323 having an output section. */
1324 if (bfd_section == NULL)
1325 bfd_section = output_prev_sec_find (place->os);
1327 if (bfd_section != NULL && bfd_section != snew)
1328 place->section = &bfd_section->next;
1329 }
1331 if (place->section != NULL)
1332 {
1333 /* Unlink the section. */
1334 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1335 ;
1336 bfd_section_list_remove (output_bfd, pps);
1338 /* Now tack it on to the "place->os" section list. */
1339 bfd_section_list_insert (output_bfd, place->section, snew);
1340 }
1342 /* Save the end of this list. Further ophans of this type will
1343 follow the one we've just added. */
1344 place->section = &snew->next;
1346 /* The following is non-cosmetic. We try to put the output
1347 statements in some sort of reasonable order here, because
1348 they determine the final load addresses of the orphan
1349 sections. In addition, placing output statements in the
1350 wrong order may require extra segments. For instance,
1351 given a typical situation of all read-only sections placed
1352 in one segment and following that a segment containing all
1353 the read-write sections, we wouldn't want to place an orphan
1354 read/write section before or amongst the read-only ones. */
1355 if (add.head != NULL)
1356 {
1357 lang_statement_union_type *newly_added_os;
1359 if (place->stmt == NULL)
1360 {
1361 /* Put the new statement list right at the head. */
1362 *add.tail = place->os->header.next;
1363 place->os->header.next = add.head;
1365 place->os_tail = &place->os->next;
1366 }
1367 else
1368 {
1369 /* Put it after the last orphan statement we added. */
1370 *add.tail = *place->stmt;
1371 *place->stmt = add.head;
1372 }
1374 /* Fix the global list pointer if we happened to tack our
1375 new list at the tail. */
1376 if (*old->tail == add.head)
1377 old->tail = add.tail;
1379 /* Save the end of this list. */
1380 place->stmt = add.tail;
1382 /* Do the same for the list of output section statements. */
1383 newly_added_os = *os_tail;
1384 *os_tail = NULL;
1385 newly_added_os->output_section_statement.next = *place->os_tail;
1386 *place->os_tail = newly_added_os;
1387 place->os_tail = &newly_added_os->output_section_statement.next;
1389 /* Fixing the global list pointer here is a little different.
1390 We added to the list in lang_enter_output_section_statement,
1391 trimmed off the new output_section_statment above when
1392 assigning *os_tail = NULL, but possibly added it back in
1393 the same place when assigning *place->os_tail. */
1394 if (*os_tail == NULL)
1395 lang_output_section_statement.tail = os_tail;
1396 }
1397 }
1399 return TRUE;
1400 }
1401 EOF
1402 fi
1404 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1405 cat >>e${EMULATION_NAME}.c <<EOF
1407 static void
1408 gld${EMULATION_NAME}_finish (void)
1409 {
1410 if (bfd_elf_discard_info (output_bfd, &link_info))
1411 {
1412 lang_reset_memory_regions ();
1414 /* Resize the sections. */
1415 lang_size_sections (stat_ptr->head, abs_output_section,
1416 &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
1418 /* Redo special stuff. */
1419 ldemul_after_allocation ();
1421 /* Do the assignments again. */
1422 lang_do_assignments (stat_ptr->head, abs_output_section,
1423 (fill_type *) 0, (bfd_vma) 0);
1424 }
1425 }
1426 EOF
1427 fi
1429 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1430 cat >>e${EMULATION_NAME}.c <<EOF
1432 static char *
1433 gld${EMULATION_NAME}_get_script (int *isfile)
1434 EOF
1436 if test -n "$COMPILE_IN"
1437 then
1438 # Scripts compiled in.
1440 # sed commands to quote an ld script as a C string.
1441 sc="-f stringify.sed"
1443 cat >>e${EMULATION_NAME}.c <<EOF
1444 {
1445 *isfile = 0;
1447 if (link_info.relocatable && config.build_constructors)
1448 return
1449 EOF
1450 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1451 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1452 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1453 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1454 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1455 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1456 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1457 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1458 fi
1459 if test -n "$GENERATE_PIE_SCRIPT" ; then
1460 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1461 echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1462 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
1463 fi
1464 echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c
1465 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
1466 fi
1467 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1468 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1469 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1470 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1471 fi
1472 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1473 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1474 fi
1475 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1476 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1477 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1478 fi
1479 echo ' ; else return' >> e${EMULATION_NAME}.c
1480 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1481 echo '; }' >> e${EMULATION_NAME}.c
1483 else
1484 # Scripts read from the filesystem.
1486 cat >>e${EMULATION_NAME}.c <<EOF
1487 {
1488 *isfile = 1;
1490 if (link_info.relocatable && config.build_constructors)
1491 return "ldscripts/${EMULATION_NAME}.xu";
1492 else if (link_info.relocatable)
1493 return "ldscripts/${EMULATION_NAME}.xr";
1494 else if (!config.text_read_only)
1495 return "ldscripts/${EMULATION_NAME}.xbn";
1496 EOF
1497 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1498 else
1499 cat >>e${EMULATION_NAME}.c <<EOF
1500 else if (!config.magic_demand_paged)
1501 return "ldscripts/${EMULATION_NAME}.xn";
1502 EOF
1503 fi
1504 if test -n "$GENERATE_PIE_SCRIPT" ; then
1505 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1506 cat >>e${EMULATION_NAME}.c <<EOF
1507 else if (link_info.pie && link_info.combreloc)
1508 return "ldscripts/${EMULATION_NAME}.xdc";
1509 EOF
1510 fi
1511 cat >>e${EMULATION_NAME}.c <<EOF
1512 else if (link_info.pie)
1513 return "ldscripts/${EMULATION_NAME}.xd";
1514 EOF
1515 fi
1516 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1517 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1518 cat >>e${EMULATION_NAME}.c <<EOF
1519 else if (link_info.shared && link_info.combreloc)
1520 return "ldscripts/${EMULATION_NAME}.xsc";
1521 EOF
1522 fi
1523 cat >>e${EMULATION_NAME}.c <<EOF
1524 else if (link_info.shared)
1525 return "ldscripts/${EMULATION_NAME}.xs";
1526 EOF
1527 fi
1528 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1529 cat >>e${EMULATION_NAME}.c <<EOF
1530 else if (link_info.combreloc)
1531 return "ldscripts/${EMULATION_NAME}.xc";
1532 EOF
1533 fi
1534 cat >>e${EMULATION_NAME}.c <<EOF
1535 else
1536 return "ldscripts/${EMULATION_NAME}.x";
1537 }
1539 EOF
1540 fi
1541 fi
1543 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1545 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1546 cat >>e${EMULATION_NAME}.c <<EOF
1547 $PARSE_AND_LIST_PROLOGUE
1548 EOF
1549 fi
1551 cat >>e${EMULATION_NAME}.c <<EOF
1553 #define OPTION_DISABLE_NEW_DTAGS (400)
1554 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1555 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1556 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
1558 static void
1559 gld${EMULATION_NAME}_add_options
1560 (int ns, char **shortopts, int nl, struct option **longopts,
1561 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1562 {
1563 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1564 static const struct option xtra_long[] = {
1565 EOF
1567 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1568 cat >>e${EMULATION_NAME}.c <<EOF
1569 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1570 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1571 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1572 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1573 EOF
1574 fi
1576 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1577 cat >>e${EMULATION_NAME}.c <<EOF
1578 $PARSE_AND_LIST_LONGOPTS
1579 EOF
1580 fi
1582 cat >>e${EMULATION_NAME}.c <<EOF
1583 {NULL, no_argument, NULL, 0}
1584 };
1586 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1587 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1588 *longopts = (struct option *)
1589 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1590 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1591 }
1593 static bfd_boolean
1594 gld${EMULATION_NAME}_handle_option (int optc)
1595 {
1596 switch (optc)
1597 {
1598 default:
1599 return FALSE;
1601 EOF
1603 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1604 cat >>e${EMULATION_NAME}.c <<EOF
1605 case OPTION_DISABLE_NEW_DTAGS:
1606 link_info.new_dtags = FALSE;
1607 break;
1609 case OPTION_ENABLE_NEW_DTAGS:
1610 link_info.new_dtags = TRUE;
1611 break;
1613 case OPTION_EH_FRAME_HDR:
1614 link_info.eh_frame_hdr = TRUE;
1615 break;
1617 case OPTION_GROUP:
1618 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1619 /* Groups must be self-contained. */
1620 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1621 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1622 break;
1624 case 'z':
1625 if (strcmp (optarg, "initfirst") == 0)
1626 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1627 else if (strcmp (optarg, "interpose") == 0)
1628 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1629 else if (strcmp (optarg, "loadfltr") == 0)
1630 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1631 else if (strcmp (optarg, "nodefaultlib") == 0)
1632 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1633 else if (strcmp (optarg, "nodelete") == 0)
1634 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1635 else if (strcmp (optarg, "nodlopen") == 0)
1636 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1637 else if (strcmp (optarg, "nodump") == 0)
1638 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1639 else if (strcmp (optarg, "now") == 0)
1640 {
1641 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1642 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1643 }
1644 else if (strcmp (optarg, "origin") == 0)
1645 {
1646 link_info.flags |= (bfd_vma) DF_ORIGIN;
1647 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1648 }
1649 else if (strcmp (optarg, "defs") == 0)
1650 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1651 else if (strcmp (optarg, "muldefs") == 0)
1652 link_info.allow_multiple_definition = TRUE;
1653 else if (strcmp (optarg, "combreloc") == 0)
1654 link_info.combreloc = TRUE;
1655 else if (strcmp (optarg, "nocombreloc") == 0)
1656 link_info.combreloc = FALSE;
1657 else if (strcmp (optarg, "nocopyreloc") == 0)
1658 link_info.nocopyreloc = TRUE;
1659 else if (strcmp (optarg, "execstack") == 0)
1660 {
1661 link_info.execstack = TRUE;
1662 link_info.noexecstack = FALSE;
1663 }
1664 else if (strcmp (optarg, "noexecstack") == 0)
1665 {
1666 link_info.noexecstack = TRUE;
1667 link_info.execstack = FALSE;
1668 }
1669 /* What about the other Solaris -z options? FIXME. */
1670 break;
1671 EOF
1672 fi
1674 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1675 cat >>e${EMULATION_NAME}.c <<EOF
1676 $PARSE_AND_LIST_ARGS_CASES
1677 EOF
1678 fi
1680 cat >>e${EMULATION_NAME}.c <<EOF
1681 }
1683 return TRUE;
1684 }
1686 EOF
1688 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1689 cat >>e${EMULATION_NAME}.c <<EOF
1691 static void
1692 gld${EMULATION_NAME}_list_options (FILE * file)
1693 {
1694 EOF
1696 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1697 cat >>e${EMULATION_NAME}.c <<EOF
1698 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1699 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1700 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1701 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1702 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1703 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n"));
1704 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n"));
1705 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1706 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1707 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1708 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n"));
1709 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1710 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1711 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1712 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1713 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1714 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1715 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n"));
1716 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1717 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n"));
1718 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1719 EOF
1720 fi
1722 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1723 cat >>e${EMULATION_NAME}.c <<EOF
1724 $PARSE_AND_LIST_OPTIONS
1725 EOF
1726 fi
1728 cat >>e${EMULATION_NAME}.c <<EOF
1729 }
1730 EOF
1732 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1733 cat >>e${EMULATION_NAME}.c <<EOF
1734 $PARSE_AND_LIST_EPILOGUE
1735 EOF
1736 fi
1737 fi
1738 else
1739 cat >>e${EMULATION_NAME}.c <<EOF
1740 #define gld${EMULATION_NAME}_add_options NULL
1741 #define gld${EMULATION_NAME}_handle_option NULL
1742 EOF
1743 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1744 cat >>e${EMULATION_NAME}.c <<EOF
1745 #define gld${EMULATION_NAME}_list_options NULL
1746 EOF
1747 fi
1748 fi
1750 cat >>e${EMULATION_NAME}.c <<EOF
1752 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1753 {
1754 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1755 ${LDEMUL_SYSLIB-syslib_default},
1756 ${LDEMUL_HLL-hll_default},
1757 ${LDEMUL_AFTER_PARSE-after_parse_default},
1758 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1759 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1760 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1761 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1762 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1763 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1764 "${EMULATION_NAME}",
1765 "${OUTPUT_FORMAT}",
1766 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1767 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1768 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1769 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1770 ${LDEMUL_SET_SYMBOLS-NULL},
1771 ${LDEMUL_PARSE_ARGS-NULL},
1772 gld${EMULATION_NAME}_add_options,
1773 gld${EMULATION_NAME}_handle_option,
1774 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1775 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1776 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
1777 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1778 ${LDEMUL_NEW_VERS_PATTERN-NULL}
1779 };
1780 EOF