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