| blob | 9bfed6eb67ca2f3aa402570d7b26b68b3aa7a1af |
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 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"
43 #include "bfdlink.h"
45 #include "ld.h"
46 #include "ldmain.h"
47 #include "ldmisc.h"
48 #include "ldexp.h"
49 #include "ldlang.h"
50 #include "ldfile.h"
51 #include "ldemul.h"
52 #include <ldgram.h>
53 #include "elf/common.h"
55 static void gld${EMULATION_NAME}_before_parse
56 PARAMS ((void));
57 static void gld${EMULATION_NAME}_vercheck
58 PARAMS ((lang_input_statement_type *));
59 static void gld${EMULATION_NAME}_stat_needed
60 PARAMS ((lang_input_statement_type *));
61 static boolean gld${EMULATION_NAME}_try_needed
62 PARAMS ((const char *, int));
63 static boolean gld${EMULATION_NAME}_search_needed
64 PARAMS ((const char *, const char *, int));
65 static void gld${EMULATION_NAME}_check_needed
66 PARAMS ((lang_input_statement_type *));
67 static void gld${EMULATION_NAME}_after_open
68 PARAMS ((void));
69 static void gld${EMULATION_NAME}_find_exp_assignment
70 PARAMS ((etree_type *));
71 static void gld${EMULATION_NAME}_find_statement_assignment
72 PARAMS ((lang_statement_union_type *));
73 static void gld${EMULATION_NAME}_before_allocation
74 PARAMS ((void));
75 static boolean gld${EMULATION_NAME}_open_dynamic_archive
76 PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
77 static lang_output_section_statement_type *output_rel_find
78 PARAMS ((asection *));
79 static asection *output_prev_sec_find
80 PARAMS ((lang_output_section_statement_type *));
81 static boolean gld${EMULATION_NAME}_place_orphan
82 PARAMS ((lang_input_statement_type *, asection *));
83 static void gld${EMULATION_NAME}_finish
84 PARAMS ((void));
85 static char *gld${EMULATION_NAME}_get_script
86 PARAMS ((int *isfile));
88 EOF
90 # Import any needed special functions and/or overrides.
91 #
92 if test -n "$EXTRA_EM_FILE" ; then
93 . ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
94 fi
96 # Functions in this file can be overridden by setting the LDEMUL_* shell
97 # variables. If the name of the overriding function is the same as is
98 # defined in this file, then don't output this file's version.
99 # If a different overriding name is given then output the standard function
100 # as presumably it is called from the overriding function.
101 #
102 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
103 cat >>e${EMULATION_NAME}.c <<EOF
105 static void
106 gld${EMULATION_NAME}_before_parse ()
107 {
108 const bfd_arch_info_type *arch = bfd_scan_arch ("${OUTPUT_ARCH}");
109 if (arch)
110 {
111 ldfile_output_architecture = arch->arch;
112 ldfile_output_machine = arch->mach;
113 ldfile_output_machine_name = arch->printable_name;
114 }
115 else
116 ldfile_output_architecture = bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`;
117 config.dynamic_link = ${DYNAMIC_LINK-true};
118 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo true ; else echo false ; fi`;
119 }
121 EOF
122 fi
124 cat >>e${EMULATION_NAME}.c <<EOF
126 /* These variables are required to pass information back and forth
127 between after_open and check_needed and stat_needed and vercheck. */
129 static struct bfd_link_needed_list *global_needed;
130 static struct stat global_stat;
131 static boolean global_found;
132 static struct bfd_link_needed_list *global_vercheck_needed;
133 static boolean global_vercheck_failed;
136 /* On Linux, it's possible to have different versions of the same
137 shared library linked against different versions of libc. The
138 dynamic linker somehow tags which libc version to use in
139 /etc/ld.so.cache, and, based on the libc that it sees in the
140 executable, chooses which version of the shared library to use.
142 We try to do a similar check here by checking whether this shared
143 library needs any other shared libraries which may conflict with
144 libraries we have already included in the link. If it does, we
145 skip it, and try to find another shared library farther on down the
146 link path.
148 This is called via lang_for_each_input_file.
149 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
150 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
151 a conflicting version. */
153 static void
154 gld${EMULATION_NAME}_vercheck (s)
155 lang_input_statement_type *s;
156 {
157 const char *soname;
158 struct bfd_link_needed_list *l;
160 if (global_vercheck_failed)
161 return;
162 if (s->the_bfd == NULL
163 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
164 return;
166 soname = bfd_elf_get_dt_soname (s->the_bfd);
167 if (soname == NULL)
168 soname = lbasename (bfd_get_filename (s->the_bfd));
170 for (l = global_vercheck_needed; l != NULL; l = l->next)
171 {
172 const char *suffix;
174 if (strcmp (soname, l->name) == 0)
175 {
176 /* Probably can't happen, but it's an easy check. */
177 continue;
178 }
180 if (strchr (l->name, '/') != NULL)
181 continue;
183 suffix = strstr (l->name, ".so.");
184 if (suffix == NULL)
185 continue;
187 suffix += sizeof ".so." - 1;
189 if (strncmp (soname, l->name, suffix - l->name) == 0)
190 {
191 /* Here we know that S is a dynamic object FOO.SO.VER1, and
192 the object we are considering needs a dynamic object
193 FOO.SO.VER2, and VER1 and VER2 are different. This
194 appears to be a version mismatch, so we tell the caller
195 to try a different version of this library. */
196 global_vercheck_failed = true;
197 return;
198 }
199 }
200 }
203 /* See if an input file matches a DT_NEEDED entry by running stat on
204 the file. */
206 static void
207 gld${EMULATION_NAME}_stat_needed (s)
208 lang_input_statement_type *s;
209 {
210 struct stat st;
211 const char *suffix;
212 const char *soname;
214 if (global_found)
215 return;
216 if (s->the_bfd == NULL)
217 return;
219 if (bfd_stat (s->the_bfd, &st) != 0)
220 {
221 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
222 return;
223 }
225 if (st.st_dev == global_stat.st_dev
226 && st.st_ino == global_stat.st_ino)
227 {
228 global_found = true;
229 return;
230 }
232 /* We issue a warning if it looks like we are including two
233 different versions of the same shared library. For example,
234 there may be a problem if -lc picks up libc.so.6 but some other
235 shared library has a DT_NEEDED entry of libc.so.5. This is a
236 heuristic test, and it will only work if the name looks like
237 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
238 If we really want to issue warnings about mixing version numbers
239 of shared libraries, we need to find a better way. */
241 if (strchr (global_needed->name, '/') != NULL)
242 return;
243 suffix = strstr (global_needed->name, ".so.");
244 if (suffix == NULL)
245 return;
246 suffix += sizeof ".so." - 1;
248 soname = bfd_elf_get_dt_soname (s->the_bfd);
249 if (soname == NULL)
250 soname = lbasename (s->filename);
252 if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
253 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
254 global_needed->name, global_needed->by, soname);
255 }
258 /* This function is called for each possible name for a dynamic object
259 named by a DT_NEEDED entry. The FORCE parameter indicates whether
260 to skip the check for a conflicting version. */
262 static boolean
263 gld${EMULATION_NAME}_try_needed (name, force)
264 const char *name;
265 int force;
266 {
267 bfd *abfd;
268 const char *soname;
270 abfd = bfd_openr (name, bfd_get_target (output_bfd));
271 if (abfd == NULL)
272 return false;
273 if (! bfd_check_format (abfd, bfd_object))
274 {
275 bfd_close (abfd);
276 return false;
277 }
278 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
279 {
280 bfd_close (abfd);
281 return false;
282 }
284 /* For DT_NEEDED, they have to match. */
285 if (abfd->xvec != output_bfd->xvec)
286 {
287 bfd_close (abfd);
288 return false;
289 }
291 /* Check whether this object would include any conflicting library
292 versions. If FORCE is set, then we skip this check; we use this
293 the second time around, if we couldn't find any compatible
294 instance of the shared library. */
296 if (! force)
297 {
298 struct bfd_link_needed_list *needed;
300 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
301 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
303 if (needed != NULL)
304 {
305 global_vercheck_needed = needed;
306 global_vercheck_failed = false;
307 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
308 if (global_vercheck_failed)
309 {
310 bfd_close (abfd);
311 /* Return false to force the caller to move on to try
312 another file on the search path. */
313 return false;
314 }
316 /* But wait! It gets much worse. On Linux, if a shared
317 library does not use libc at all, we are supposed to skip
318 it the first time around in case we encounter a shared
319 library later on with the same name which does use the
320 version of libc that we want. This is much too horrible
321 to use on any system other than Linux. */
323 EOF
324 case ${target} in
325 *-*-linux-gnu*)
326 cat >>e${EMULATION_NAME}.c <<EOF
327 {
328 struct bfd_link_needed_list *l;
330 for (l = needed; l != NULL; l = l->next)
331 if (strncmp (l->name, "libc.so", 7) == 0)
332 break;
333 if (l == NULL)
334 {
335 bfd_close (abfd);
336 return false;
337 }
338 }
340 EOF
341 ;;
342 esac
343 cat >>e${EMULATION_NAME}.c <<EOF
344 }
345 }
347 /* We've found a dynamic object matching the DT_NEEDED entry. */
349 /* We have already checked that there is no other input file of the
350 same name. We must now check again that we are not including the
351 same file twice. We need to do this because on many systems
352 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
353 reference libc.so.1. If we have already included libc.so, we
354 don't want to include libc.so.1 if they are the same file, and we
355 can only check that using stat. */
357 if (bfd_stat (abfd, &global_stat) != 0)
358 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
360 /* First strip off everything before the last '/'. */
361 soname = lbasename (abfd->filename);
363 if (trace_file_tries)
364 info_msg (_("found %s at %s\n"), soname, name);
366 global_found = false;
367 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
368 if (global_found)
369 {
370 /* Return true to indicate that we found the file, even though
371 we aren't going to do anything with it. */
372 return true;
373 }
375 /* Tell the ELF backend that we don't want the output file to have a
376 DT_NEEDED entry for this file. */
377 bfd_elf_set_dt_needed_name (abfd, "");
379 /* Tell the ELF backend that the output file needs a DT_NEEDED
380 entry for this file if it is used to resolve the reference in
381 a regular object. */
382 bfd_elf_set_dt_needed_soname (abfd, soname);
384 /* Add this file into the symbol table. */
385 if (! bfd_link_add_symbols (abfd, &link_info))
386 einfo ("%F%B: could not read symbols: %E\n", abfd);
388 return true;
389 }
392 /* Search for a needed file in a path. */
394 static boolean
395 gld${EMULATION_NAME}_search_needed (path, name, force)
396 const char *path;
397 const char *name;
398 int force;
399 {
400 const char *s;
401 size_t len;
403 if (name[0] == '/')
404 return gld${EMULATION_NAME}_try_needed (name, force);
406 if (path == NULL || *path == '\0')
407 return false;
408 len = strlen (name);
409 while (1)
410 {
411 char *filename, *sset;
413 s = strchr (path, ':');
414 if (s == NULL)
415 s = path + strlen (path);
417 filename = (char *) xmalloc (s - path + len + 2);
418 if (s == path)
419 sset = filename;
420 else
421 {
422 memcpy (filename, path, s - path);
423 filename[s - path] = '/';
424 sset = filename + (s - path) + 1;
425 }
426 strcpy (sset, name);
428 if (gld${EMULATION_NAME}_try_needed (filename, force))
429 return true;
431 free (filename);
433 if (*s == '\0')
434 break;
435 path = s + 1;
436 }
438 return false;
439 }
441 EOF
442 if [ "x${host}" = "x${target}" ] ; then
443 case " ${EMULATION_LIBPATH} " in
444 *" ${EMULATION_NAME} "*)
445 case ${target} in
446 *-*-linux-gnu*)
447 cat >>e${EMULATION_NAME}.c <<EOF
449 /* For a native linker, check the file /etc/ld.so.conf for directories
450 in which we may find shared libraries. /etc/ld.so.conf is really
451 only meaningful on Linux. */
453 static boolean gld${EMULATION_NAME}_check_ld_so_conf
454 PARAMS ((const char *, int));
456 static boolean
457 gld${EMULATION_NAME}_check_ld_so_conf (name, force)
458 const char *name;
459 int force;
460 {
461 static boolean initialized;
462 static char *ld_so_conf;
464 if (! initialized)
465 {
466 FILE *f;
468 f = fopen ("/etc/ld.so.conf", FOPEN_RT);
469 if (f != NULL)
470 {
471 char *b;
472 size_t len, alloc;
473 int c;
475 len = 0;
476 alloc = 100;
477 b = (char *) xmalloc (alloc);
479 while ((c = getc (f)) != EOF)
480 {
481 if (len + 1 >= alloc)
482 {
483 alloc *= 2;
484 b = (char *) xrealloc (b, alloc);
485 }
486 if (c != ':'
487 && c != ' '
488 && c != '\t'
489 && c != '\n'
490 && c != ',')
491 {
492 b[len] = c;
493 ++len;
494 }
495 else
496 {
497 if (len > 0 && b[len - 1] != ':')
498 {
499 b[len] = ':';
500 ++len;
501 }
502 }
503 }
505 if (len > 0 && b[len - 1] == ':')
506 --len;
508 if (len > 0)
509 b[len] = '\0';
510 else
511 {
512 free (b);
513 b = NULL;
514 }
516 fclose (f);
518 ld_so_conf = b;
519 }
521 initialized = true;
522 }
524 if (ld_so_conf == NULL)
525 return false;
527 return gld${EMULATION_NAME}_search_needed (ld_so_conf, name, force);
528 }
530 EOF
531 # Linux
532 ;;
533 esac
534 esac
535 fi
536 cat >>e${EMULATION_NAME}.c <<EOF
538 /* See if an input file matches a DT_NEEDED entry by name. */
540 static void
541 gld${EMULATION_NAME}_check_needed (s)
542 lang_input_statement_type *s;
543 {
544 if (global_found)
545 return;
547 if (s->filename != NULL)
548 {
549 const char *f;
551 if (strcmp (s->filename, global_needed->name) == 0)
552 {
553 global_found = true;
554 return;
555 }
557 if (s->search_dirs_flag)
558 {
559 f = strrchr (s->filename, '/');
560 if (f != NULL
561 && strcmp (f + 1, global_needed->name) == 0)
562 {
563 global_found = true;
564 return;
565 }
566 }
567 }
569 if (s->the_bfd != NULL)
570 {
571 const char *soname;
573 soname = bfd_elf_get_dt_soname (s->the_bfd);
574 if (soname != NULL
575 && strcmp (soname, global_needed->name) == 0)
576 {
577 global_found = true;
578 return;
579 }
580 }
581 }
583 EOF
585 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
586 cat >>e${EMULATION_NAME}.c <<EOF
588 /* This is called after all the input files have been opened. */
590 static void
591 gld${EMULATION_NAME}_after_open ()
592 {
593 struct bfd_link_needed_list *needed, *l;
595 /* We only need to worry about this when doing a final link. */
596 if (link_info.relocateable || link_info.shared)
597 return;
599 /* Get the list of files which appear in DT_NEEDED entries in
600 dynamic objects included in the link (often there will be none).
601 For each such file, we want to track down the corresponding
602 library, and include the symbol table in the link. This is what
603 the runtime dynamic linker will do. Tracking the files down here
604 permits one dynamic object to include another without requiring
605 special action by the person doing the link. Note that the
606 needed list can actually grow while we are stepping through this
607 loop. */
608 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
609 for (l = needed; l != NULL; l = l->next)
610 {
611 struct bfd_link_needed_list *ll;
612 int force;
614 /* If we've already seen this file, skip it. */
615 for (ll = needed; ll != l; ll = ll->next)
616 if (strcmp (ll->name, l->name) == 0)
617 break;
618 if (ll != l)
619 continue;
621 /* See if this file was included in the link explicitly. */
622 global_needed = l;
623 global_found = false;
624 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
625 if (global_found)
626 continue;
628 if (trace_file_tries)
629 info_msg (_("%s needed by %B\n"), l->name, l->by);
631 /* We need to find this file and include the symbol table. We
632 want to search for the file in the same way that the dynamic
633 linker will search. That means that we want to use
634 rpath_link, rpath, then the environment variable
635 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
636 entries (native only), then the linker script LIB_SEARCH_DIRS.
637 We do not search using the -L arguments.
639 We search twice. The first time, we skip objects which may
640 introduce version mismatches. The second time, we force
641 their use. See gld${EMULATION_NAME}_vercheck comment. */
642 for (force = 0; force < 2; force++)
643 {
644 size_t len;
645 search_dirs_type *search;
646 EOF
647 if [ "x${host}" = "x${target}" ] ; then
648 case " ${EMULATION_LIBPATH} " in
649 *" ${EMULATION_NAME} "*)
650 cat >>e${EMULATION_NAME}.c <<EOF
651 const char *lib_path;
652 struct bfd_link_needed_list *rp;
653 int found;
654 EOF
655 ;;
656 esac
657 fi
658 cat >>e${EMULATION_NAME}.c <<EOF
660 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
661 l->name, force))
662 break;
663 EOF
664 if [ "x${host}" = "x${target}" ] ; then
665 case " ${EMULATION_LIBPATH} " in
666 *" ${EMULATION_NAME} "*)
667 cat >>e${EMULATION_NAME}.c <<EOF
668 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
669 l->name, force))
670 break;
671 if (command_line.rpath_link == NULL
672 && command_line.rpath == NULL)
673 {
674 lib_path = (const char *) getenv ("LD_RUN_PATH");
675 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name,
676 force))
677 break;
678 }
679 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
680 if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, force))
681 break;
683 found = 0;
684 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
685 for (; !found && rp != NULL; rp = rp->next)
686 {
687 found = (rp->by == l->by
688 && gld${EMULATION_NAME}_search_needed (rp->name,
689 l->name,
690 force));
691 }
692 if (found)
693 break;
695 EOF
696 ;;
697 esac
698 fi
699 cat >>e${EMULATION_NAME}.c <<EOF
700 len = strlen (l->name);
701 for (search = search_head; search != NULL; search = search->next)
702 {
703 char *filename;
705 if (search->cmdline)
706 continue;
707 filename = (char *) xmalloc (strlen (search->name) + len + 2);
708 sprintf (filename, "%s/%s", search->name, l->name);
709 if (gld${EMULATION_NAME}_try_needed (filename, force))
710 break;
711 free (filename);
712 }
713 if (search != NULL)
714 break;
715 EOF
716 if [ "x${host}" = "x${target}" ] ; then
717 case " ${EMULATION_LIBPATH} " in
718 *" ${EMULATION_NAME} "*)
719 case ${target} in
720 *-*-linux-gnu*)
721 cat >>e${EMULATION_NAME}.c <<EOF
722 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
723 break;
724 EOF
725 # Linux
726 ;;
727 esac
728 ;;
729 esac
730 fi
731 cat >>e${EMULATION_NAME}.c <<EOF
732 }
734 if (force < 2)
735 continue;
737 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
738 l->name, l->by);
739 }
740 }
742 EOF
743 fi
745 cat >>e${EMULATION_NAME}.c <<EOF
747 /* Look through an expression for an assignment statement. */
749 static void
750 gld${EMULATION_NAME}_find_exp_assignment (exp)
751 etree_type *exp;
752 {
753 struct bfd_link_hash_entry *h;
755 switch (exp->type.node_class)
756 {
757 case etree_provide:
758 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
759 false, false, false);
760 if (h == NULL)
761 break;
763 /* We call record_link_assignment even if the symbol is defined.
764 This is because if it is defined by a dynamic object, we
765 actually want to use the value defined by the linker script,
766 not the value from the dynamic object (because we are setting
767 symbols like etext). If the symbol is defined by a regular
768 object, then, as it happens, calling record_link_assignment
769 will do no harm. */
771 /* Fall through. */
772 case etree_assign:
773 if (strcmp (exp->assign.dst, ".") != 0)
774 {
775 if (! (bfd_elf${ELFSIZE}_record_link_assignment
776 (output_bfd, &link_info, exp->assign.dst,
777 exp->type.node_class == etree_provide ? true : false)))
778 einfo ("%P%F: failed to record assignment to %s: %E\n",
779 exp->assign.dst);
780 }
781 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
782 break;
784 case etree_binary:
785 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
786 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
787 break;
789 case etree_trinary:
790 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
791 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
792 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
793 break;
795 case etree_unary:
796 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
797 break;
799 default:
800 break;
801 }
802 }
805 /* This is called by the before_allocation routine via
806 lang_for_each_statement. It locates any assignment statements, and
807 tells the ELF backend about them, in case they are assignments to
808 symbols which are referred to by dynamic objects. */
810 static void
811 gld${EMULATION_NAME}_find_statement_assignment (s)
812 lang_statement_union_type *s;
813 {
814 if (s->header.type == lang_assignment_statement_enum)
815 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
816 }
818 EOF
820 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
821 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
822 ELF_INTERPRETER_SET_DEFAULT="
823 if (sinterp != NULL)
824 {
825 sinterp->contents = ${ELF_INTERPRETER_NAME};
826 sinterp->_raw_size = strlen (sinterp->contents) + 1;
827 }
829 "
830 else
831 ELF_INTERPRETER_SET_DEFAULT=
832 fi
833 cat >>e${EMULATION_NAME}.c <<EOF
835 /* This is called after the sections have been attached to output
836 sections, but before any sizes or addresses have been set. */
838 static void
839 gld${EMULATION_NAME}_before_allocation ()
840 {
841 const char *rpath;
842 asection *sinterp;
844 /* If we are going to make any variable assignments, we need to let
845 the ELF backend know about them in case the variables are
846 referred to by dynamic objects. */
847 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
849 /* Let the ELF backend work out the sizes of any sections required
850 by dynamic linking. */
851 rpath = command_line.rpath;
852 if (rpath == NULL)
853 rpath = (const char *) getenv ("LD_RUN_PATH");
854 if (! (bfd_elf${ELFSIZE}_size_dynamic_sections
855 (output_bfd, command_line.soname, rpath,
856 command_line.filter_shlib,
857 (const char * const *) command_line.auxiliary_filters,
858 &link_info, &sinterp, lang_elf_version_info)))
859 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
860 ${ELF_INTERPRETER_SET_DEFAULT}
861 /* Let the user override the dynamic linker we are using. */
862 if (command_line.interpreter != NULL
863 && sinterp != NULL)
864 {
865 sinterp->contents = (bfd_byte *) command_line.interpreter;
866 sinterp->_raw_size = strlen (command_line.interpreter) + 1;
867 }
869 /* Look for any sections named .gnu.warning. As a GNU extensions,
870 we treat such sections as containing warning messages. We print
871 out the warning message, and then zero out the section size so
872 that it does not get copied into the output file. */
874 {
875 LANG_FOR_EACH_INPUT_STATEMENT (is)
876 {
877 asection *s;
878 bfd_size_type sz;
879 char *msg;
880 boolean ret;
882 if (is->just_syms_flag)
883 continue;
885 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
886 if (s == NULL)
887 continue;
889 sz = bfd_section_size (is->the_bfd, s);
890 msg = xmalloc ((size_t) sz + 1);
891 if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
892 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
893 is->the_bfd);
894 msg[sz] = '\0';
895 ret = link_info.callbacks->warning (&link_info, msg,
896 (const char *) NULL,
897 is->the_bfd, (asection *) NULL,
898 (bfd_vma) 0);
899 ASSERT (ret);
900 free (msg);
902 /* Clobber the section size, so that we don't waste copying the
903 warning into the output file. */
904 s->_raw_size = 0;
905 }
906 }
907 }
909 EOF
910 fi
912 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
913 cat >>e${EMULATION_NAME}.c <<EOF
915 /* Try to open a dynamic archive. This is where we know that ELF
916 dynamic libraries have an extension of .so (or .sl on oddball systems
917 like hpux). */
919 static boolean
920 gld${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
921 const char *arch;
922 search_dirs_type *search;
923 lang_input_statement_type *entry;
924 {
925 const char *filename;
926 char *string;
928 if (! entry->is_archive)
929 return false;
931 filename = entry->filename;
933 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
934 is defined, but it does not seem worth the headache to optimize
935 away those two bytes of space. */
936 string = (char *) xmalloc (strlen (search->name)
937 + strlen (filename)
938 + strlen (arch)
939 #ifdef EXTRA_SHLIB_EXTENSION
940 + strlen (EXTRA_SHLIB_EXTENSION)
941 #endif
942 + sizeof "/lib.so");
944 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
946 #ifdef EXTRA_SHLIB_EXTENSION
947 /* Try the .so extension first. If that fails build a new filename
948 using EXTRA_SHLIB_EXTENSION. */
949 if (! ldfile_try_open_bfd (string, entry))
950 sprintf (string, "%s/lib%s%s%s", search->name,
951 filename, arch, EXTRA_SHLIB_EXTENSION);
952 #endif
954 if (! ldfile_try_open_bfd (string, entry))
955 {
956 free (string);
957 return false;
958 }
960 entry->filename = string;
962 /* We have found a dynamic object to include in the link. The ELF
963 backend linker will create a DT_NEEDED entry in the .dynamic
964 section naming this file. If this file includes a DT_SONAME
965 entry, it will be used. Otherwise, the ELF linker will just use
966 the name of the file. For an archive found by searching, like
967 this one, the DT_NEEDED entry should consist of just the name of
968 the file, without the path information used to find it. Note
969 that we only need to do this if we have a dynamic object; an
970 archive will never be referenced by a DT_NEEDED entry.
972 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
973 very pretty. I haven't been able to think of anything that is
974 pretty, though. */
975 if (bfd_check_format (entry->the_bfd, bfd_object)
976 && (entry->the_bfd->flags & DYNAMIC) != 0)
977 {
978 ASSERT (entry->is_archive && entry->search_dirs_flag);
980 /* Rather than duplicating the logic above. Just use the
981 filename we recorded earlier. */
983 filename = lbasename (entry->filename);
984 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
985 }
987 return true;
988 }
990 EOF
991 fi
993 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
994 cat >>e${EMULATION_NAME}.c <<EOF
996 /* A variant of lang_output_section_find. Used by place_orphan. */
998 static lang_output_section_statement_type *
999 output_rel_find (sec)
1000 asection *sec;
1001 {
1002 lang_statement_union_type *u;
1003 lang_output_section_statement_type *lookup;
1004 lang_output_section_statement_type *last = NULL;
1005 lang_output_section_statement_type *last_rel = NULL;
1006 lang_output_section_statement_type *last_rel_alloc = NULL;
1007 int rela = sec->name[4] == 'a';
1009 for (u = lang_output_section_statement.head; u; u = lookup->next)
1010 {
1011 lookup = &u->output_section_statement;
1012 if (strncmp (".rel", lookup->name, 4) == 0)
1013 {
1014 /* Don't place after .rel.plt as doing so results in wrong
1015 dynamic tags. Also, place allocated reloc sections before
1016 non-allocated. */
1017 int lookrela = lookup->name[4] == 'a';
1019 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0
1020 || (lookup->bfd_section != NULL
1021 && (lookup->bfd_section->flags & SEC_ALLOC) == 0))
1022 break;
1023 last = lookup;
1024 if (rela == lookrela)
1025 last_rel = lookup;
1026 if (lookup->bfd_section != NULL
1027 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1028 last_rel_alloc = lookup;
1029 }
1030 }
1032 if (last_rel_alloc)
1033 return last_rel_alloc;
1035 if (last_rel)
1036 return last_rel;
1038 return last;
1039 }
1041 /* Find the last output section before given output statement.
1042 Used by place_orphan. */
1044 static asection *
1045 output_prev_sec_find (os)
1046 lang_output_section_statement_type *os;
1047 {
1048 asection *s = (asection *) NULL;
1049 lang_statement_union_type *u;
1050 lang_output_section_statement_type *lookup;
1052 for (u = lang_output_section_statement.head;
1053 u != (lang_statement_union_type *) NULL;
1054 u = lookup->next)
1055 {
1056 lookup = &u->output_section_statement;
1057 if (lookup == os)
1058 return s;
1060 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1061 s = lookup->bfd_section;
1062 }
1064 return NULL;
1065 }
1067 /* Place an orphan section. We use this to put random SHF_ALLOC
1068 sections in the right segment. */
1070 struct orphan_save {
1071 lang_output_section_statement_type *os;
1072 asection **section;
1073 lang_statement_union_type **stmt;
1074 };
1076 static boolean
1077 gld${EMULATION_NAME}_place_orphan (file, s)
1078 lang_input_statement_type *file;
1079 asection *s;
1080 {
1081 static struct orphan_save hold_text;
1082 static struct orphan_save hold_rodata;
1083 static struct orphan_save hold_data;
1084 static struct orphan_save hold_bss;
1085 static struct orphan_save hold_rel;
1086 static struct orphan_save hold_interp;
1087 static struct orphan_save hold_sdata;
1088 static int count = 1;
1089 struct orphan_save *place;
1090 lang_statement_list_type *old;
1091 lang_statement_list_type add;
1092 etree_type *address;
1093 const char *secname;
1094 const char *ps = NULL;
1095 lang_output_section_statement_type *os;
1096 int isdyn = 0;
1098 secname = bfd_get_section_name (s->owner, s);
1099 if (! link_info.relocateable
1100 && link_info.combreloc
1101 && (s->flags & SEC_ALLOC)
1102 && strncmp (secname, ".rel", 4) == 0)
1103 {
1104 if (secname[4] == 'a')
1105 secname = ".rela.dyn";
1106 else
1107 secname = ".rel.dyn";
1108 isdyn = 1;
1109 }
1111 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (secname)))
1112 {
1113 /* Look through the script to see where to place this section. */
1114 os = lang_output_section_find (secname);
1116 if (os != NULL
1117 && (os->bfd_section == NULL
1118 || ((s->flags ^ os->bfd_section->flags)
1119 & (SEC_LOAD | SEC_ALLOC)) == 0))
1120 {
1121 /* We already have an output section statement with this
1122 name, and its bfd section, if any, has compatible flags. */
1123 lang_add_section (&os->children, s, os, file);
1124 return true;
1125 }
1126 }
1128 if (hold_text.os == NULL)
1129 hold_text.os = lang_output_section_find (".text");
1131 /* If this is a final link, then always put .gnu.warning.SYMBOL
1132 sections into the .text section to get them out of the way. */
1133 if (! link_info.shared
1134 && ! link_info.relocateable
1135 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1136 && hold_text.os != NULL)
1137 {
1138 lang_add_section (&hold_text.os->children, s, hold_text.os, file);
1139 return true;
1140 }
1142 /* Decide which segment the section should go in based on the
1143 section name and section flags. We put loadable .note sections
1144 right after the .interp section, so that the PT_NOTE segment is
1145 stored right after the program headers where the OS can read it
1146 in the first page. */
1147 #define HAVE_SECTION(hold, name) \
1148 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1150 if ((s->flags & SEC_EXCLUDE) != 0 && !link_info.relocateable)
1151 {
1152 if (s->output_section == NULL)
1153 s->output_section = bfd_abs_section_ptr;
1154 return true;
1155 }
1157 place = NULL;
1158 if ((s->flags & SEC_ALLOC) == 0)
1159 ;
1160 else if ((s->flags & SEC_LOAD) != 0
1161 && strncmp (secname, ".note", 5) == 0
1162 && HAVE_SECTION (hold_interp, ".interp"))
1163 place = &hold_interp;
1164 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1165 && HAVE_SECTION (hold_bss, ".bss"))
1166 place = &hold_bss;
1167 else if ((s->flags & SEC_SMALL_DATA) != 0
1168 && HAVE_SECTION (hold_sdata, ".sdata"))
1169 place = &hold_sdata;
1170 else if ((s->flags & SEC_READONLY) == 0
1171 && HAVE_SECTION (hold_data, ".data"))
1172 place = &hold_data;
1173 else if (strncmp (secname, ".rel", 4) == 0
1174 && (s->flags & SEC_LOAD) != 0
1175 && (hold_rel.os != NULL
1176 || (hold_rel.os = output_rel_find (s)) != NULL))
1177 place = &hold_rel;
1178 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == SEC_READONLY
1179 && HAVE_SECTION (hold_rodata, ".rodata"))
1180 place = &hold_rodata;
1181 else if ((s->flags & (SEC_CODE | SEC_READONLY)) == (SEC_CODE | SEC_READONLY)
1182 && hold_text.os != NULL)
1183 place = &hold_text;
1185 #undef HAVE_SECTION
1187 /* Choose a unique name for the section. This will be needed if the
1188 same section name appears in the input file with different
1189 loadable or allocatable characteristics. */
1190 if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1191 {
1192 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1193 if (secname == NULL)
1194 einfo ("%F%P: place_orphan failed: %E\n");
1195 }
1197 /* Start building a list of statements for this section.
1198 First save the current statement pointer. */
1199 old = stat_ptr;
1201 /* If we have found an appropriate place for the output section
1202 statements for this orphan, add them to our own private list,
1203 inserting them later into the global statement list. */
1204 if (place != NULL)
1205 {
1206 stat_ptr = &add;
1207 lang_list_init (stat_ptr);
1208 }
1210 if (config.build_constructors)
1211 {
1212 /* If the name of the section is representable in C, then create
1213 symbols to mark the start and the end of the section. */
1214 for (ps = secname; *ps != '\0'; ps++)
1215 if (! ISALNUM (*ps) && *ps != '_')
1216 break;
1217 if (*ps == '\0')
1218 {
1219 char *symname;
1220 etree_type *e_align;
1222 symname = (char *) xmalloc (ps - secname + sizeof "__start_");
1223 sprintf (symname, "__start_%s", secname);
1224 e_align = exp_unop (ALIGN_K,
1225 exp_intop ((bfd_vma) 1 << s->alignment_power));
1226 lang_add_assignment (exp_assop ('=', symname, e_align));
1227 }
1228 }
1230 if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1231 address = exp_intop ((bfd_vma) 0);
1232 else
1233 address = NULL;
1235 os = lang_enter_output_section_statement (secname, address, 0,
1236 (bfd_vma) 0,
1237 (etree_type *) NULL,
1238 (etree_type *) NULL,
1239 (etree_type *) NULL);
1241 lang_add_section (&os->children, s, os, file);
1243 lang_leave_output_section_statement
1244 ((bfd_vma) 0, "*default*",
1245 (struct lang_output_section_phdr_list *) NULL, NULL);
1247 if (config.build_constructors && *ps == '\0')
1248 {
1249 char *symname;
1251 /* lang_leave_ouput_section_statement resets stat_ptr. Put
1252 stat_ptr back where we want it. */
1253 if (place != NULL)
1254 stat_ptr = &add;
1256 symname = (char *) xmalloc (ps - secname + sizeof "__stop_");
1257 sprintf (symname, "__stop_%s", secname);
1258 lang_add_assignment (exp_assop ('=', symname,
1259 exp_nameop (NAME, ".")));
1260 }
1262 /* Restore the global list pointer. */
1263 stat_ptr = old;
1265 if (place != NULL && os->bfd_section != NULL)
1266 {
1267 asection *snew, **pps;
1269 snew = os->bfd_section;
1271 /* Shuffle the bfd section list to make the output file look
1272 neater. This is really only cosmetic. */
1273 if (place->section == NULL)
1274 {
1275 asection *bfd_section = place->os->bfd_section;
1277 /* If the output statement hasn't been used to place
1278 any input sections (and thus doesn't have an output
1279 bfd_section), look for the closest prior output statement
1280 having an output section. */
1281 if (bfd_section == NULL)
1282 bfd_section = output_prev_sec_find (place->os);
1284 if (bfd_section != NULL && bfd_section != snew)
1285 place->section = &bfd_section->next;
1286 }
1288 if (place->section != NULL)
1289 {
1290 /* Unlink the section. */
1291 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1292 ;
1293 bfd_section_list_remove (output_bfd, pps);
1295 /* Now tack it on to the "place->os" section list. */
1296 bfd_section_list_insert (output_bfd, place->section, snew);
1297 }
1299 /* Save the end of this list. Further ophans of this type will
1300 follow the one we've just added. */
1301 place->section = &snew->next;
1303 /* The following is non-cosmetic. We try to put the output
1304 statements in some sort of reasonable order here, because
1305 they determine the final load addresses of the orphan
1306 sections. In addition, placing output statements in the
1307 wrong order may require extra segments. For instance,
1308 given a typical situation of all read-only sections placed
1309 in one segment and following that a segment containing all
1310 the read-write sections, we wouldn't want to place an orphan
1311 read/write section before or amongst the read-only ones. */
1312 if (add.head != NULL)
1313 {
1314 if (place->stmt == NULL)
1315 {
1316 /* Put the new statement list right at the head. */
1317 *add.tail = place->os->header.next;
1318 place->os->header.next = add.head;
1319 }
1320 else
1321 {
1322 /* Put it after the last orphan statement we added. */
1323 *add.tail = *place->stmt;
1324 *place->stmt = add.head;
1325 }
1327 /* Fix the global list pointer if we happened to tack our
1328 new list at the tail. */
1329 if (*old->tail == add.head)
1330 old->tail = add.tail;
1332 /* Save the end of this list. */
1333 place->stmt = add.tail;
1334 }
1335 }
1337 return true;
1338 }
1339 EOF
1340 fi
1342 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1343 cat >>e${EMULATION_NAME}.c <<EOF
1345 static void
1346 gld${EMULATION_NAME}_finish ()
1347 {
1348 if (bfd_elf${ELFSIZE}_discard_info (output_bfd, &link_info))
1349 {
1350 lang_reset_memory_regions ();
1352 /* Resize the sections. */
1353 lang_size_sections (stat_ptr->head, abs_output_section,
1354 &stat_ptr->head, 0, (bfd_vma) 0, NULL);
1356 /* Redo special stuff. */
1357 ldemul_after_allocation ();
1359 /* Do the assignments again. */
1360 lang_do_assignments (stat_ptr->head, abs_output_section,
1361 (fill_type *) 0, (bfd_vma) 0);
1362 }
1363 }
1364 EOF
1365 fi
1367 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1368 cat >>e${EMULATION_NAME}.c <<EOF
1370 static char *
1371 gld${EMULATION_NAME}_get_script (isfile)
1372 int *isfile;
1373 EOF
1375 if test -n "$COMPILE_IN"
1376 then
1377 # Scripts compiled in.
1379 # sed commands to quote an ld script as a C string.
1380 sc="-f stringify.sed"
1382 cat >>e${EMULATION_NAME}.c <<EOF
1383 {
1384 *isfile = 0;
1386 if (link_info.relocateable == true && config.build_constructors == true)
1387 return
1388 EOF
1389 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1390 echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1391 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1392 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1393 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1394 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1395 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1396 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1397 fi
1398 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1399 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1400 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1401 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1402 fi
1403 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1404 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1405 fi
1406 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1407 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1408 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1409 fi
1410 echo ' ; else return' >> e${EMULATION_NAME}.c
1411 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1412 echo '; }' >> e${EMULATION_NAME}.c
1414 else
1415 # Scripts read from the filesystem.
1417 cat >>e${EMULATION_NAME}.c <<EOF
1418 {
1419 *isfile = 1;
1421 if (link_info.relocateable == true && config.build_constructors == true)
1422 return "ldscripts/${EMULATION_NAME}.xu";
1423 else if (link_info.relocateable == true)
1424 return "ldscripts/${EMULATION_NAME}.xr";
1425 else if (!config.text_read_only)
1426 return "ldscripts/${EMULATION_NAME}.xbn";
1427 else if (!config.magic_demand_paged)
1428 return "ldscripts/${EMULATION_NAME}.xn";
1429 else if (link_info.shared)
1430 return "ldscripts/${EMULATION_NAME}.xs";
1431 else
1432 return "ldscripts/${EMULATION_NAME}.x";
1433 }
1435 EOF
1436 fi
1437 fi
1439 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1441 if test x"$LDEMUL_PARSE_ARGS" != xgld"$EMULATION_NAME"_parse_args; then
1443 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1444 cat >>e${EMULATION_NAME}.c <<EOF
1445 $PARSE_AND_LIST_PROLOGUE
1446 EOF
1447 fi
1449 cat >>e${EMULATION_NAME}.c <<EOF
1451 #include "getopt.h"
1453 #define OPTION_DISABLE_NEW_DTAGS (400)
1454 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1455 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1456 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
1458 static struct option longopts[] =
1459 {
1460 EOF
1462 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1463 cat >>e${EMULATION_NAME}.c <<EOF
1464 /* getopt allows abbreviations, so we do this to stop it from
1465 treating -d/-e as abbreviations for these options. */
1466 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1467 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1468 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1469 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1470 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1471 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1472 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1473 EOF
1474 fi
1476 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1477 cat >>e${EMULATION_NAME}.c <<EOF
1478 $PARSE_AND_LIST_LONGOPTS
1479 EOF
1480 fi
1482 cat >>e${EMULATION_NAME}.c <<EOF
1483 {NULL, no_argument, NULL, 0}
1484 };
1487 static int gld${EMULATION_NAME}_parse_args PARAMS ((int, char **));
1489 static int
1490 gld${EMULATION_NAME}_parse_args (argc, argv)
1491 int argc;
1492 char ** argv;
1493 {
1494 int longind;
1495 int optc;
1496 static int prevoptind = -1;
1497 int prevopterr = opterr;
1498 int wanterror;
1500 if (prevoptind != optind)
1501 opterr = 0;
1503 wanterror = opterr;
1504 prevoptind = optind;
1506 optc = getopt_long_only (argc, argv,
1507 "-${PARSE_AND_LIST_SHORTOPTS}z:", longopts,
1508 &longind);
1509 opterr = prevopterr;
1511 switch (optc)
1512 {
1513 default:
1514 if (wanterror)
1515 xexit (1);
1516 optind = prevoptind;
1517 return 0;
1519 EOF
1521 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1522 cat >>e${EMULATION_NAME}.c <<EOF
1523 case OPTION_DISABLE_NEW_DTAGS:
1524 link_info.new_dtags = false;
1525 break;
1527 case OPTION_ENABLE_NEW_DTAGS:
1528 link_info.new_dtags = true;
1529 break;
1531 case OPTION_EH_FRAME_HDR:
1532 link_info.eh_frame_hdr = true;
1533 break;
1535 case OPTION_GROUP:
1536 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1537 /* Groups must be self-contained. */
1538 link_info.no_undefined = true;
1539 break;
1541 case 'z':
1542 if (strcmp (optarg, "initfirst") == 0)
1543 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1544 else if (strcmp (optarg, "interpose") == 0)
1545 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1546 else if (strcmp (optarg, "loadfltr") == 0)
1547 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1548 else if (strcmp (optarg, "nodefaultlib") == 0)
1549 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1550 else if (strcmp (optarg, "nodelete") == 0)
1551 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1552 else if (strcmp (optarg, "nodlopen") == 0)
1553 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1554 else if (strcmp (optarg, "nodump") == 0)
1555 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1556 else if (strcmp (optarg, "now") == 0)
1557 {
1558 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1559 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1560 }
1561 else if (strcmp (optarg, "origin") == 0)
1562 {
1563 link_info.flags |= (bfd_vma) DF_ORIGIN;
1564 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1565 }
1566 else if (strcmp (optarg, "defs") == 0)
1567 link_info.no_undefined = true;
1568 else if (strcmp (optarg, "muldefs") == 0)
1569 link_info.allow_multiple_definition = true;
1570 else if (strcmp (optarg, "combreloc") == 0)
1571 link_info.combreloc = true;
1572 else if (strcmp (optarg, "nocombreloc") == 0)
1573 link_info.combreloc = false;
1574 else if (strcmp (optarg, "nocopyreloc") == 0)
1575 link_info.nocopyreloc = true;
1576 /* What about the other Solaris -z options? FIXME. */
1577 break;
1578 EOF
1579 fi
1581 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1582 cat >>e${EMULATION_NAME}.c <<EOF
1583 $PARSE_AND_LIST_ARGS_CASES
1584 EOF
1585 fi
1587 cat >>e${EMULATION_NAME}.c <<EOF
1588 }
1590 return 1;
1591 }
1593 EOF
1594 fi
1596 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1597 cat >>e${EMULATION_NAME}.c <<EOF
1599 static void gld${EMULATION_NAME}_list_options PARAMS ((FILE * file));
1601 static void
1602 gld${EMULATION_NAME}_list_options (file)
1603 FILE * file;
1604 {
1605 EOF
1607 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1608 cat >>e${EMULATION_NAME}.c <<EOF
1609 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1610 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1611 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1612 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1613 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1614 fprintf (file, _(" -z defs\t\tDisallows undefined symbols\n"));
1615 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1616 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1617 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1618 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n"));
1619 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1620 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1621 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1622 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1623 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1624 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1625 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1626 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n"));
1627 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1628 EOF
1629 fi
1631 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1632 cat >>e${EMULATION_NAME}.c <<EOF
1633 $PARSE_AND_LIST_OPTIONS
1634 EOF
1635 fi
1637 cat >>e${EMULATION_NAME}.c <<EOF
1638 }
1639 EOF
1641 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1642 cat >>e${EMULATION_NAME}.c <<EOF
1643 $PARSE_AND_LIST_EPILOGUE
1644 EOF
1645 fi
1646 fi
1647 else
1648 if test x"$LDEMUL_PARSE_ARGS" != xgld"$EMULATION_NAME"_parse_args; then
1649 cat >>e${EMULATION_NAME}.c <<EOF
1650 #define gld${EMULATION_NAME}_parse_args NULL
1651 EOF
1652 fi
1653 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1654 cat >>e${EMULATION_NAME}.c <<EOF
1655 #define gld${EMULATION_NAME}_list_options NULL
1656 EOF
1657 fi
1658 fi
1660 cat >>e${EMULATION_NAME}.c <<EOF
1662 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1663 {
1664 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1665 ${LDEMUL_SYSLIB-syslib_default},
1666 ${LDEMUL_HLL-hll_default},
1667 ${LDEMUL_AFTER_PARSE-after_parse_default},
1668 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1669 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1670 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1671 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1672 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1673 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1674 "${EMULATION_NAME}",
1675 "${OUTPUT_FORMAT}",
1676 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1677 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1678 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1679 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1680 ${LDEMUL_SET_SYMBOLS-NULL},
1681 ${LDEMUL_PARSE_ARGS-gld${EMULATION_NAME}_parse_args},
1682 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1683 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1684 ${LDEMUL_RECOGNIZED_FILE-NULL},
1685 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1686 ${LDEMUL_NEW_VERS_PATTERN-NULL}
1687 };
1688 EOF