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