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