update copyright dates
[external/binutils.git] / ld / emultempl / elf32.em
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 fragment <<EOF
12 /* This file is is generated by a shell script.  DO NOT EDIT! */
13
14 /* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
15    Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
16    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
17    Free Software Foundation, Inc.
18    Written by Steve Chamberlain <sac@cygnus.com>
19    ELF support by Ian Lance Taylor <ian@cygnus.com>
20
21    This file is part of the GNU Binutils.
22
23    This program is free software; you can redistribute it and/or modify
24    it under the terms of the GNU General Public License as published by
25    the Free Software Foundation; either version 3 of the License, or
26    (at your option) any later version.
27
28    This program is distributed in the hope that it will be useful,
29    but WITHOUT ANY WARRANTY; without even the implied warranty of
30    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
31    GNU General Public License for more details.
32
33    You should have received a copy of the GNU General Public License
34    along with this program; if not, write to the Free Software
35    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
36    MA 02110-1301, USA.  */
37
38 #define TARGET_IS_${EMULATION_NAME}
39
40 #include "sysdep.h"
41 #include "bfd.h"
42 #include "libiberty.h"
43 #include "safe-ctype.h"
44 #include "getopt.h"
45 #include "md5.h"
46 #include "sha1.h"
47 #include <fcntl.h>
48
49 #include "bfdlink.h"
50
51 #include "ld.h"
52 #include "ldmain.h"
53 #include "ldmisc.h"
54 #include "ldexp.h"
55 #include "ldlang.h"
56 #include "ldfile.h"
57 #include "ldemul.h"
58 #include <ldgram.h>
59 #include "elf/common.h"
60 #include "elf-bfd.h"
61
62 /* Declare functions used by various EXTRA_EM_FILEs.  */
63 static void gld${EMULATION_NAME}_before_parse (void);
64 static void gld${EMULATION_NAME}_after_open (void);
65 static void gld${EMULATION_NAME}_before_allocation (void);
66 static void gld${EMULATION_NAME}_after_allocation (void);
67 static lang_output_section_statement_type *gld${EMULATION_NAME}_place_orphan
68   (asection *, const char *, int);
69 EOF
70
71 if [ "x${USE_LIBPATH}" = xyes ] ; then
72   case ${target} in
73     *-*-linux-* | *-*-k*bsd*-*)
74   fragment <<EOF
75 #ifdef HAVE_GLOB
76 #include <glob.h>
77 #endif
78 EOF
79     ;;
80   esac
81 fi
82
83 # Import any needed special functions and/or overrides.
84 #
85 source_em ${srcdir}/emultempl/elf-generic.em
86 if test -n "$EXTRA_EM_FILE" ; then
87   source_em ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
88 fi
89
90 # Functions in this file can be overridden by setting the LDEMUL_* shell
91 # variables.  If the name of the overriding function is the same as is
92 # defined in this file, then don't output this file's version.
93 # If a different overriding name is given then output the standard function
94 # as presumably it is called from the overriding function.
95 #
96 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
97 fragment <<EOF
98
99 static void
100 gld${EMULATION_NAME}_before_parse (void)
101 {
102   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
103   config.dynamic_link = ${DYNAMIC_LINK-TRUE};
104   config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
105 }
106
107 EOF
108 fi
109
110 if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
111 fragment <<EOF
112 /* Handle as_needed DT_NEEDED.  */
113
114 static bfd_boolean
115 gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
116 {
117   int class = 0;
118
119   /* Tell the ELF linker that we don't want the output file to have a
120      DT_NEEDED entry for this file, unless it is used to resolve
121      references in a regular object.  */
122   if (entry->as_needed)
123     class = DYN_AS_NEEDED;
124
125   /* Tell the ELF linker that we don't want the output file to have a
126      DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
127      this file at all.  */
128   if (!entry->add_needed)
129     class |= DYN_NO_ADD_NEEDED;
130
131   if (entry->just_syms_flag
132       && (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) != 0)
133     einfo (_("%P%F: --just-symbols may not be used on DSO: %B\n"),
134            entry->the_bfd);
135
136   if (!class
137       || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
138     return FALSE;
139
140   bfd_elf_set_dyn_lib_class (entry->the_bfd, class);
141
142   /* Continue on with normal load_symbols processing.  */
143   return FALSE;
144 }
145 EOF
146 fi
147
148 fragment <<EOF
149
150 /* These variables are required to pass information back and forth
151    between after_open and check_needed and stat_needed and vercheck.  */
152
153 static struct bfd_link_needed_list *global_needed;
154 static struct stat global_stat;
155 static lang_input_statement_type *global_found;
156 static struct bfd_link_needed_list *global_vercheck_needed;
157 static bfd_boolean global_vercheck_failed;
158
159
160 /* On Linux, it's possible to have different versions of the same
161    shared library linked against different versions of libc.  The
162    dynamic linker somehow tags which libc version to use in
163    /etc/ld.so.cache, and, based on the libc that it sees in the
164    executable, chooses which version of the shared library to use.
165
166    We try to do a similar check here by checking whether this shared
167    library needs any other shared libraries which may conflict with
168    libraries we have already included in the link.  If it does, we
169    skip it, and try to find another shared library farther on down the
170    link path.
171
172    This is called via lang_for_each_input_file.
173    GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
174    which we are checking.  This sets GLOBAL_VERCHECK_FAILED if we find
175    a conflicting version.  */
176
177 static void
178 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
179 {
180   const char *soname;
181   struct bfd_link_needed_list *l;
182
183   if (global_vercheck_failed)
184     return;
185   if (s->the_bfd == NULL
186       || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
187     return;
188
189   soname = bfd_elf_get_dt_soname (s->the_bfd);
190   if (soname == NULL)
191     soname = lbasename (bfd_get_filename (s->the_bfd));
192
193   for (l = global_vercheck_needed; l != NULL; l = l->next)
194     {
195       const char *suffix;
196
197       if (strcmp (soname, l->name) == 0)
198         {
199           /* Probably can't happen, but it's an easy check.  */
200           continue;
201         }
202
203       if (strchr (l->name, '/') != NULL)
204         continue;
205
206       suffix = strstr (l->name, ".so.");
207       if (suffix == NULL)
208         continue;
209
210       suffix += sizeof ".so." - 1;
211
212       if (strncmp (soname, l->name, suffix - l->name) == 0)
213         {
214           /* Here we know that S is a dynamic object FOO.SO.VER1, and
215              the object we are considering needs a dynamic object
216              FOO.SO.VER2, and VER1 and VER2 are different.  This
217              appears to be a version mismatch, so we tell the caller
218              to try a different version of this library.  */
219           global_vercheck_failed = TRUE;
220           return;
221         }
222     }
223 }
224
225
226 /* See if an input file matches a DT_NEEDED entry by running stat on
227    the file.  */
228
229 static void
230 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
231 {
232   struct stat st;
233   const char *suffix;
234   const char *soname;
235
236   if (global_found != NULL)
237     return;
238   if (s->the_bfd == NULL)
239     return;
240
241   /* If this input file was an as-needed entry, and wasn't found to be
242      needed at the stage it was linked, then don't say we have loaded it.  */
243   if ((bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
244     return;
245
246   if (bfd_stat (s->the_bfd, &st) != 0)
247     {
248       einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
249       return;
250     }
251
252   /* Some operating systems, e.g. Windows, do not provide a meaningful
253      st_ino; they always set it to zero.  (Windows does provide a
254      meaningful st_dev.)  Do not indicate a duplicate library in that
255      case.  While there is no guarantee that a system that provides
256      meaningful inode numbers will never set st_ino to zero, this is
257      merely an optimization, so we do not need to worry about false
258      negatives.  */
259   if (st.st_dev == global_stat.st_dev
260       && st.st_ino == global_stat.st_ino
261       && st.st_ino != 0)
262     {
263       global_found = s;
264       return;
265     }
266
267   /* We issue a warning if it looks like we are including two
268      different versions of the same shared library.  For example,
269      there may be a problem if -lc picks up libc.so.6 but some other
270      shared library has a DT_NEEDED entry of libc.so.5.  This is a
271      heuristic test, and it will only work if the name looks like
272      NAME.so.VERSION.  FIXME: Depending on file names is error-prone.
273      If we really want to issue warnings about mixing version numbers
274      of shared libraries, we need to find a better way.  */
275
276   if (strchr (global_needed->name, '/') != NULL)
277     return;
278   suffix = strstr (global_needed->name, ".so.");
279   if (suffix == NULL)
280     return;
281   suffix += sizeof ".so." - 1;
282
283   soname = bfd_elf_get_dt_soname (s->the_bfd);
284   if (soname == NULL)
285     soname = lbasename (s->filename);
286
287   if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
288     einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
289            global_needed->name, global_needed->by, soname);
290 }
291
292 struct dt_needed
293 {
294   bfd *by;
295   const char *name;
296 };
297
298 /* This function is called for each possible name for a dynamic object
299    named by a DT_NEEDED entry.  The FORCE parameter indicates whether
300    to skip the check for a conflicting version.  */
301
302 static bfd_boolean
303 gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
304                                  int force)
305 {
306   bfd *abfd;
307   const char *name = needed->name;
308   const char *soname;
309   int class;
310
311   abfd = bfd_openr (name, bfd_get_target (link_info.output_bfd));
312   if (abfd == NULL)
313     return FALSE;
314   if (! bfd_check_format (abfd, bfd_object))
315     {
316       bfd_close (abfd);
317       return FALSE;
318     }
319   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
320     {
321       bfd_close (abfd);
322       return FALSE;
323     }
324
325   /* For DT_NEEDED, they have to match.  */
326   if (abfd->xvec != link_info.output_bfd->xvec)
327     {
328       bfd_close (abfd);
329       return FALSE;
330     }
331
332   /* Check whether this object would include any conflicting library
333      versions.  If FORCE is set, then we skip this check; we use this
334      the second time around, if we couldn't find any compatible
335      instance of the shared library.  */
336
337   if (! force)
338     {
339       struct bfd_link_needed_list *needed;
340
341       if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
342         einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
343
344       if (needed != NULL)
345         {
346           global_vercheck_needed = needed;
347           global_vercheck_failed = FALSE;
348           lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
349           if (global_vercheck_failed)
350             {
351               bfd_close (abfd);
352               /* Return FALSE to force the caller to move on to try
353                  another file on the search path.  */
354               return FALSE;
355             }
356
357           /* But wait!  It gets much worse.  On Linux, if a shared
358              library does not use libc at all, we are supposed to skip
359              it the first time around in case we encounter a shared
360              library later on with the same name which does use the
361              version of libc that we want.  This is much too horrible
362              to use on any system other than Linux.  */
363
364 EOF
365 case ${target} in
366   *-*-linux-* | *-*-k*bsd*-*)
367     fragment <<EOF
368           {
369             struct bfd_link_needed_list *l;
370
371             for (l = needed; l != NULL; l = l->next)
372               if (CONST_STRNEQ (l->name, "libc.so"))
373                 break;
374             if (l == NULL)
375               {
376                 bfd_close (abfd);
377                 return FALSE;
378               }
379           }
380
381 EOF
382     ;;
383 esac
384 fragment <<EOF
385         }
386     }
387
388   /* We've found a dynamic object matching the DT_NEEDED entry.  */
389
390   /* We have already checked that there is no other input file of the
391      same name.  We must now check again that we are not including the
392      same file twice.  We need to do this because on many systems
393      libc.so is a symlink to, e.g., libc.so.1.  The SONAME entry will
394      reference libc.so.1.  If we have already included libc.so, we
395      don't want to include libc.so.1 if they are the same file, and we
396      can only check that using stat.  */
397
398   if (bfd_stat (abfd, &global_stat) != 0)
399     einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
400
401   /* First strip off everything before the last '/'.  */
402   soname = lbasename (abfd->filename);
403
404   if (trace_file_tries)
405     info_msg (_("found %s at %s\n"), soname, name);
406
407   global_found = NULL;
408   lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
409   if (global_found != NULL)
410     {
411       /* Return TRUE to indicate that we found the file, even though
412          we aren't going to do anything with it.  */
413       return TRUE;
414     }
415
416   /* Specify the soname to use.  */
417   bfd_elf_set_dt_needed_name (abfd, soname);
418
419   /* Tell the ELF linker that we don't want the output file to have a
420      DT_NEEDED entry for this file, unless it is used to resolve
421      references in a regular object.  */
422   class = DYN_DT_NEEDED;
423
424   /* Tell the ELF linker that we don't want the output file to have a
425      DT_NEEDED entry for this file at all if the entry is from a file
426      with DYN_NO_ADD_NEEDED.  */
427   if (needed->by != NULL
428       && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
429     class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
430
431   bfd_elf_set_dyn_lib_class (abfd, class);
432
433   /* Add this file into the symbol table.  */
434   if (! bfd_link_add_symbols (abfd, &link_info))
435     einfo ("%F%B: could not read symbols: %E\n", abfd);
436
437   return TRUE;
438 }
439
440
441 /* Search for a needed file in a path.  */
442
443 static bfd_boolean
444 gld${EMULATION_NAME}_search_needed (const char *path,
445                                     struct dt_needed *n, int force)
446 {
447   const char *s;
448   const char *name = n->name;
449   size_t len;
450   struct dt_needed needed;
451
452   if (name[0] == '/')
453     return gld${EMULATION_NAME}_try_needed (n, force);
454
455   if (path == NULL || *path == '\0')
456     return FALSE;
457
458   needed.by = n->by;
459   needed.name = n->name;
460
461   len = strlen (name);
462   while (1)
463     {
464       char *filename, *sset;
465
466       s = strchr (path, config.rpath_separator);
467       if (s == NULL)
468         s = path + strlen (path);
469
470       filename = (char *) xmalloc (s - path + len + 2);
471       if (s == path)
472         sset = filename;
473       else
474         {
475           memcpy (filename, path, s - path);
476           filename[s - path] = '/';
477           sset = filename + (s - path) + 1;
478         }
479       strcpy (sset, name);
480
481       needed.name = filename;
482       if (gld${EMULATION_NAME}_try_needed (&needed, force))
483         return TRUE;
484
485       free (filename);
486
487       if (*s == '\0')
488         break;
489       path = s + 1;
490     }
491
492   return FALSE;
493 }
494
495 EOF
496 if [ "x${USE_LIBPATH}" = xyes ] ; then
497   fragment <<EOF
498
499 /* Add the sysroot to every entry in a path separated by
500    config.rpath_separator.  */
501
502 static char *
503 gld${EMULATION_NAME}_add_sysroot (const char *path)
504 {
505   int len, colons, i;
506   char *ret, *p;
507
508   len = strlen (path);
509   colons = 0;
510   i = 0;
511   while (path[i])
512     if (path[i++] == config.rpath_separator)
513       colons++;
514
515   if (path[i])
516     colons++;
517
518   len = len + (colons + 1) * strlen (ld_sysroot);
519   ret = xmalloc (len + 1);
520   strcpy (ret, ld_sysroot);
521   p = ret + strlen (ret);
522   i = 0;
523   while (path[i])
524     if (path[i] == config.rpath_separator)
525       {
526         *p++ = path[i++];
527         strcpy (p, ld_sysroot);
528         p = p + strlen (p);
529       }
530     else
531       *p++ = path[i++];
532
533   *p = 0;
534   return ret;
535 }
536
537 EOF
538   case ${target} in
539     *-*-freebsd* | *-*-dragonfly*)
540       fragment <<EOF
541 /* Read the system search path the FreeBSD way rather than the Linux way.  */
542 #ifdef HAVE_ELF_HINTS_H
543 #include <elf-hints.h>
544 #else
545 #include "elf-hints-local.h"
546 #endif
547
548 static bfd_boolean
549 gld${EMULATION_NAME}_check_ld_elf_hints (const char *name, int force)
550 {
551   static bfd_boolean initialized;
552   static char *ld_elf_hints;
553   struct dt_needed needed;
554
555   if (!initialized)
556     {
557       FILE *f;
558       char *tmppath;
559
560       tmppath = concat (ld_sysroot, _PATH_ELF_HINTS, (const char *) NULL);
561       f = fopen (tmppath, FOPEN_RB);
562       free (tmppath);
563       if (f != NULL)
564         {
565           struct elfhints_hdr hdr;
566
567           if (fread (&hdr, 1, sizeof (hdr), f) == sizeof (hdr)
568               && hdr.magic == ELFHINTS_MAGIC
569               && hdr.version == 1)
570             {
571               if (fseek (f, hdr.strtab + hdr.dirlist, SEEK_SET) != -1)
572                 {
573                   char *b;
574
575                   b = xmalloc (hdr.dirlistlen + 1);
576                   if (fread (b, 1, hdr.dirlistlen + 1, f) ==
577                       hdr.dirlistlen + 1)
578                     ld_elf_hints = gld${EMULATION_NAME}_add_sysroot (b);
579
580                   free (b);
581                 }
582             }
583           fclose (f);
584         }
585
586       initialized = TRUE;
587     }
588
589   if (ld_elf_hints == NULL)
590     return FALSE;
591
592   needed.by = NULL;
593   needed.name = name;
594   return gld${EMULATION_NAME}_search_needed (ld_elf_hints, & needed,
595                                              force);
596 }
597 EOF
598     # FreeBSD
599     ;;
600
601     *-*-linux-* | *-*-k*bsd*-*)
602       fragment <<EOF
603 /* For a native linker, check the file /etc/ld.so.conf for directories
604    in which we may find shared libraries.  /etc/ld.so.conf is really
605    only meaningful on Linux.  */
606
607 struct gld${EMULATION_NAME}_ld_so_conf
608 {
609   char *path;
610   size_t len, alloc;
611 };
612
613 static bfd_boolean
614 gld${EMULATION_NAME}_parse_ld_so_conf
615      (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
616
617 static void
618 gld${EMULATION_NAME}_parse_ld_so_conf_include
619      (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
620       const char *pattern)
621 {
622   char *newp = NULL;
623 #ifdef HAVE_GLOB
624   glob_t gl;
625 #endif
626
627   if (pattern[0] != '/')
628     {
629       char *p = strrchr (filename, '/');
630       size_t patlen = strlen (pattern) + 1;
631
632       newp = xmalloc (p - filename + 1 + patlen);
633       memcpy (newp, filename, p - filename + 1);
634       memcpy (newp + (p - filename + 1), pattern, patlen);
635       pattern = newp;
636     }
637
638 #ifdef HAVE_GLOB
639   if (glob (pattern, 0, NULL, &gl) == 0)
640     {
641       size_t i;
642
643       for (i = 0; i < gl.gl_pathc; ++i)
644         gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
645       globfree (&gl);
646     }
647 #else
648   /* If we do not have glob, treat the pattern as a literal filename.  */
649   gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
650 #endif
651
652   if (newp)
653     free (newp);
654 }
655
656 static bfd_boolean
657 gld${EMULATION_NAME}_parse_ld_so_conf
658      (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
659 {
660   FILE *f = fopen (filename, FOPEN_RT);
661   char *line;
662   size_t linelen;
663
664   if (f == NULL)
665     return FALSE;
666
667   linelen = 256;
668   line = xmalloc (linelen);
669   do
670     {
671       char *p = line, *q;
672
673       /* Normally this would use getline(3), but we need to be portable.  */
674       while ((q = fgets (p, linelen - (p - line), f)) != NULL
675              && strlen (q) == linelen - (p - line) - 1
676              && line[linelen - 2] != '\n')
677         {
678           line = xrealloc (line, 2 * linelen);
679           p = line + linelen - 1;
680           linelen += linelen;
681         }
682
683       if (q == NULL && p == line)
684         break;
685
686       p = strchr (line, '\n');
687       if (p)
688         *p = '\0';
689
690       /* Because the file format does not know any form of quoting we
691          can search forward for the next '#' character and if found
692          make it terminating the line.  */
693       p = strchr (line, '#');
694       if (p)
695         *p = '\0';
696
697       /* Remove leading whitespace.  NUL is no whitespace character.  */
698       p = line;
699       while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
700         ++p;
701
702       /* If the line is blank it is ignored.  */
703       if (p[0] == '\0')
704         continue;
705
706       if (CONST_STRNEQ (p, "include") && (p[7] == ' ' || p[7] == '\t'))
707         {
708           char *dir, c;
709           p += 8;
710           do
711             {
712               while (*p == ' ' || *p == '\t')
713                 ++p;
714
715               if (*p == '\0')
716                 break;
717
718               dir = p;
719
720               while (*p != ' ' && *p != '\t' && *p)
721                 ++p;
722
723               c = *p;
724               *p++ = '\0';
725               if (dir[0] != '\0')
726                 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
727                                                                dir);
728             }
729           while (c != '\0');
730         }
731       else
732         {
733           char *dir = p;
734           while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
735                  && *p != '\r' && *p != '\v')
736             ++p;
737
738           while (p != dir && p[-1] == '/')
739             --p;
740           if (info->path == NULL)
741             {
742               info->alloc = p - dir + 1 + 256;
743               info->path = xmalloc (info->alloc);
744               info->len = 0;
745             }
746           else
747             {
748               if (info->len + 1 + (p - dir) >= info->alloc)
749                 {
750                   info->alloc += p - dir + 256;
751                   info->path = xrealloc (info->path, info->alloc);
752                 }
753               info->path[info->len++] = config.rpath_separator;
754             }
755           memcpy (info->path + info->len, dir, p - dir);
756           info->len += p - dir;
757           info->path[info->len] = '\0';
758         }
759     }
760   while (! feof (f));
761   free (line);
762   fclose (f);
763   return TRUE;
764 }
765
766 static bfd_boolean
767 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
768 {
769   static bfd_boolean initialized;
770   static char *ld_so_conf;
771   struct dt_needed needed;
772
773   if (! initialized)
774     {
775       char *tmppath;
776       struct gld${EMULATION_NAME}_ld_so_conf info;
777
778       info.path = NULL;
779       info.len = info.alloc = 0;
780       tmppath = concat (ld_sysroot, "${prefix}/etc/ld.so.conf",
781                         (const char *) NULL);
782       if (!gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath))
783         {
784           free (tmppath);
785           tmppath = concat (ld_sysroot, "/etc/ld.so.conf",
786                             (const char *) NULL);
787           gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
788         }
789       free (tmppath);
790
791       if (info.path)
792         {
793           char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
794           free (info.path);
795           ld_so_conf = d;
796         }
797       initialized = TRUE;
798     }
799
800   if (ld_so_conf == NULL)
801     return FALSE;
802
803
804   needed.by = NULL;
805   needed.name = name;
806   return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
807 }
808
809 EOF
810     # Linux
811     ;;
812   esac
813 fi
814 fragment <<EOF
815
816 /* See if an input file matches a DT_NEEDED entry by name.  */
817
818 static void
819 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
820 {
821   const char *soname;
822
823   /* Stop looking if we've found a loaded lib.  */
824   if (global_found != NULL
825       && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
826           & DYN_AS_NEEDED) == 0)
827     return;
828
829   if (s->filename == NULL || s->the_bfd == NULL)
830     return;
831
832   /* Don't look for a second non-loaded as-needed lib.  */
833   if (global_found != NULL
834       && (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
835     return;
836
837   if (strcmp (s->filename, global_needed->name) == 0)
838     {
839       global_found = s;
840       return;
841     }
842
843   if (s->search_dirs_flag)
844     {
845       const char *f = strrchr (s->filename, '/');
846       if (f != NULL
847           && strcmp (f + 1, global_needed->name) == 0)
848         {
849           global_found = s;
850           return;
851         }
852     }
853
854   soname = bfd_elf_get_dt_soname (s->the_bfd);
855   if (soname != NULL
856       && strcmp (soname, global_needed->name) == 0)
857     {
858       global_found = s;
859       return;
860     }
861 }
862
863 EOF
864
865 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
866 fragment <<EOF
867
868 static bfd_size_type
869 gld${EMULATION_NAME}_id_note_section_size (bfd *abfd,
870                                            struct bfd_link_info *link_info)
871 {
872   const char *style = link_info->emit_note_gnu_build_id;
873   bfd_size_type size;
874
875   abfd = abfd;
876
877   size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
878   size = (size + 3) & -(bfd_size_type) 4;
879
880   if (!strcmp (style, "md5") || !strcmp (style, "uuid"))
881     size += 128 / 8;
882   else if (!strcmp (style, "sha1"))
883     size += 160 / 8;
884   else if (!strncmp (style, "0x", 2))
885     {
886       /* ID is in string form (hex).  Convert to bits.  */
887       const char *id = style + 2;
888       do
889         {
890           if (ISXDIGIT (id[0]) && ISXDIGIT (id[1]))
891             {
892               ++size;
893               id += 2;
894             }
895           else if (*id == '-' || *id == ':')
896             ++id;
897           else
898             {
899               size = 0;
900               break;
901             }
902         } while (*id != '\0');
903     }
904   else
905     size = 0;
906
907   return size;
908 }
909
910 static unsigned char
911 read_hex (const char xdigit)
912 {
913   if (ISDIGIT (xdigit))
914     return xdigit - '0';
915   if (ISUPPER (xdigit))
916     return xdigit - 'A' + 0xa;
917   if (ISLOWER (xdigit))
918     return xdigit - 'a' + 0xa;
919   abort ();
920   return 0;
921 }
922
923 struct build_id_info
924 {
925   const char *style;
926   asection *sec;
927 };
928
929 static bfd_boolean
930 gld${EMULATION_NAME}_write_build_id_section (bfd *abfd)
931 {
932   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
933   struct build_id_info *info =
934     elf_tdata (abfd)->after_write_object_contents_info;
935   asection *asec;
936   Elf_Internal_Shdr *i_shdr;
937   unsigned char *contents, *id_bits;
938   bfd_size_type size;
939   Elf_External_Note *e_note;
940
941   asec = info->sec;
942   if (bfd_is_abs_section (asec->output_section))
943     {
944       einfo (_("%P: warning: .note.gnu.build-id section discarded,"
945                " --build-id ignored.\n"));
946       return TRUE;
947     }
948   i_shdr = &elf_section_data (asec->output_section)->this_hdr;
949
950   if (i_shdr->contents == NULL)
951     {
952       if (asec->contents == NULL)
953         asec->contents = xmalloc (asec->size);
954       contents = asec->contents;
955     }
956   else
957     contents = i_shdr->contents + asec->output_offset;
958
959   e_note = (void *) contents;
960   size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
961   size = (size + 3) & -(bfd_size_type) 4;
962   id_bits = contents + size;
963   size = asec->size - size;
964
965   bfd_h_put_32 (abfd, sizeof "GNU", &e_note->namesz);
966   bfd_h_put_32 (abfd, size, &e_note->descsz);
967   bfd_h_put_32 (abfd, NT_GNU_BUILD_ID, &e_note->type);
968   memcpy (e_note->name, "GNU", sizeof "GNU");
969
970   if (!strcmp (info->style, "md5"))
971     {
972       struct md5_ctx ctx;
973       md5_init_ctx (&ctx);
974       if (bed->s->checksum_contents (abfd,
975                                      (void (*) (const void *, size_t, void *))
976                                      &md5_process_bytes,
977                                      &ctx))
978         md5_finish_ctx (&ctx, id_bits);
979       else
980         return FALSE;
981     }
982   else if (!strcmp (info->style, "sha1"))
983     {
984       struct sha1_ctx ctx;
985       sha1_init_ctx (&ctx);
986       if (bed->s->checksum_contents (abfd,
987                                      (void (*) (const void *, size_t, void *))
988                                      &sha1_process_bytes,
989                                      &ctx))
990         sha1_finish_ctx (&ctx, id_bits);
991       else
992         return FALSE;
993     }
994   else if (!strcmp (info->style, "uuid"))
995     {
996       int n;
997       int fd = open ("/dev/urandom", O_RDONLY);
998       if (fd < 0)
999         return FALSE;
1000       n = read (fd, id_bits, size);
1001       close (fd);
1002       if (n < (int) size)
1003         return FALSE;
1004     }
1005   else if (!strncmp (info->style, "0x", 2))
1006     {
1007       /* ID is in string form (hex).  Convert to bits.  */
1008       const char *id = info->style + 2;
1009       size_t n = 0;
1010       do
1011         {
1012           if (ISXDIGIT (id[0]) && ISXDIGIT (id[1]))
1013             {
1014               id_bits[n] = read_hex (*id++) << 4;
1015               id_bits[n++] |= read_hex (*id++);
1016             }
1017           else if (*id == '-' || *id == ':')
1018             ++id;
1019           else
1020             abort ();           /* Should have been validated earlier.  */
1021         } while (*id != '\0');
1022     }
1023   else
1024     abort ();                   /* Should have been validated earlier.  */
1025
1026   size = asec->size;
1027   return (bfd_seek (abfd,
1028                     i_shdr->sh_offset + asec->output_offset, SEEK_SET) == 0
1029           && bfd_bwrite (contents, size, abfd) == size);
1030 }
1031
1032
1033 /* This is called after all the input files have been opened.  */
1034
1035 static void
1036 gld${EMULATION_NAME}_after_open (void)
1037 {
1038   struct bfd_link_needed_list *needed, *l;
1039   struct elf_link_hash_table *htab;
1040
1041   htab = elf_hash_table (&link_info);
1042   if (!is_elf_hash_table (htab))
1043     return;
1044
1045   if (link_info.emit_note_gnu_build_id)
1046     {
1047       bfd *abfd;
1048       asection *s;
1049       bfd_size_type size;
1050
1051       abfd = link_info.input_bfds;
1052
1053       if (abfd == NULL)
1054         {
1055           /* PR 10555: If there are no input files do not
1056              try to create a .note.gnu-build-id section.  */
1057           free (link_info.emit_note_gnu_build_id);
1058           link_info.emit_note_gnu_build_id = NULL;
1059         }
1060       else
1061         {
1062           size = gld${EMULATION_NAME}_id_note_section_size (abfd, &link_info);
1063           if (size == 0)
1064             {
1065               einfo ("%P: warning: unrecognized --build-id style ignored.\n");
1066               free (link_info.emit_note_gnu_build_id);
1067               link_info.emit_note_gnu_build_id = NULL;
1068             }
1069           else
1070             {
1071               s = bfd_make_section_with_flags (abfd, ".note.gnu.build-id",
1072                                                SEC_ALLOC | SEC_LOAD
1073                                                | SEC_IN_MEMORY | SEC_LINKER_CREATED
1074                                                | SEC_READONLY | SEC_DATA);
1075               if (s != NULL && bfd_set_section_alignment (abfd, s, 2))
1076                 {
1077                   struct elf_obj_tdata *t = elf_tdata (link_info.output_bfd);
1078                   struct build_id_info *b = xmalloc (sizeof *b);
1079
1080                   b->style = link_info.emit_note_gnu_build_id;
1081                   b->sec = s;
1082                   elf_section_type (s) = SHT_NOTE;
1083                   s->size = size;
1084                   t->after_write_object_contents
1085                     = &gld${EMULATION_NAME}_write_build_id_section;
1086                   t->after_write_object_contents_info = b;
1087                 }
1088               else
1089                 {
1090                   einfo ("%P: warning: Cannot create .note.gnu.build-id section,"
1091                          " --build-id ignored.\n");
1092                   free (link_info.emit_note_gnu_build_id);
1093                   link_info.emit_note_gnu_build_id = NULL;
1094                 }
1095             }
1096         }
1097     }
1098
1099   if (link_info.relocatable)
1100     return;
1101
1102   if (link_info.eh_frame_hdr
1103       && !link_info.traditional_format)
1104     {
1105       bfd *abfd;
1106       asection *s;
1107
1108       for (abfd = link_info.input_bfds; abfd; abfd = abfd->link_next)
1109         {
1110           s = bfd_get_section_by_name (abfd, ".eh_frame");
1111           if (s && s->size > 8 && !bfd_is_abs_section (s->output_section))
1112             break;
1113         }
1114       if (abfd)
1115         {
1116           const struct elf_backend_data *bed;
1117
1118           bed = get_elf_backend_data (abfd);
1119           s = bfd_make_section_with_flags (abfd, ".eh_frame_hdr",
1120                                            bed->dynamic_sec_flags
1121                                            | SEC_READONLY);
1122           if (s != NULL
1123               && bfd_set_section_alignment (abfd, s, 2))
1124             htab->eh_info.hdr_sec = s;
1125           else
1126             einfo ("%P: warning: Cannot create .eh_frame_hdr section,"
1127                    " --eh-frame-hdr ignored.\n");
1128         }
1129     }
1130
1131   /* Get the list of files which appear in DT_NEEDED entries in
1132      dynamic objects included in the link (often there will be none).
1133      For each such file, we want to track down the corresponding
1134      library, and include the symbol table in the link.  This is what
1135      the runtime dynamic linker will do.  Tracking the files down here
1136      permits one dynamic object to include another without requiring
1137      special action by the person doing the link.  Note that the
1138      needed list can actually grow while we are stepping through this
1139      loop.  */
1140   if (!link_info.executable)
1141     return;
1142   needed = bfd_elf_get_needed_list (link_info.output_bfd, &link_info);
1143   for (l = needed; l != NULL; l = l->next)
1144     {
1145       struct bfd_link_needed_list *ll;
1146       struct dt_needed n, nn;
1147       int force;
1148
1149       /* If the lib that needs this one was --as-needed and wasn't
1150          found to be needed, then this lib isn't needed either.  */
1151       if (l->by != NULL
1152           && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
1153         continue;
1154
1155       /* If we've already seen this file, skip it.  */
1156       for (ll = needed; ll != l; ll = ll->next)
1157         if ((ll->by == NULL
1158              || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
1159             && strcmp (ll->name, l->name) == 0)
1160           break;
1161       if (ll != l)
1162         continue;
1163
1164       /* See if this file was included in the link explicitly.  */
1165       global_needed = l;
1166       global_found = NULL;
1167       lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
1168       if (global_found != NULL
1169           && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
1170               & DYN_AS_NEEDED) == 0)
1171         continue;
1172
1173       n.by = l->by;
1174       n.name = l->name;
1175       nn.by = l->by;
1176       if (trace_file_tries)
1177         info_msg (_("%s needed by %B\n"), l->name, l->by);
1178
1179       /* As-needed libs specified on the command line (or linker script)
1180          take priority over libs found in search dirs.  */
1181       if (global_found != NULL)
1182         {
1183           nn.name = global_found->filename;
1184           if (gld${EMULATION_NAME}_try_needed (&nn, TRUE))
1185             continue;
1186         }
1187
1188       /* We need to find this file and include the symbol table.  We
1189          want to search for the file in the same way that the dynamic
1190          linker will search.  That means that we want to use
1191          rpath_link, rpath, then the environment variable
1192          LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
1193          entries (native only), then the linker script LIB_SEARCH_DIRS.
1194          We do not search using the -L arguments.
1195
1196          We search twice.  The first time, we skip objects which may
1197          introduce version mismatches.  The second time, we force
1198          their use.  See gld${EMULATION_NAME}_vercheck comment.  */
1199       for (force = 0; force < 2; force++)
1200         {
1201           size_t len;
1202           search_dirs_type *search;
1203 EOF
1204 if [ "x${NATIVE}" = xyes ] ; then
1205 fragment <<EOF
1206           const char *lib_path;
1207 EOF
1208 fi
1209 if [ "x${USE_LIBPATH}" = xyes ] ; then
1210 fragment <<EOF
1211           struct bfd_link_needed_list *rp;
1212           int found;
1213 EOF
1214 fi
1215 fragment <<EOF
1216
1217           if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
1218                                                   &n, force))
1219             break;
1220 EOF
1221 if [ "x${USE_LIBPATH}" = xyes ] ; then
1222 fragment <<EOF
1223           if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
1224                                                   &n, force))
1225             break;
1226 EOF
1227 fi
1228 if [ "x${NATIVE}" = xyes ] ; then
1229 fragment <<EOF
1230           if (command_line.rpath_link == NULL
1231               && command_line.rpath == NULL)
1232             {
1233               lib_path = (const char *) getenv ("LD_RUN_PATH");
1234               if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
1235                                                       force))
1236                 break;
1237             }
1238           lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
1239           if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
1240             break;
1241 EOF
1242 fi
1243 if [ "x${USE_LIBPATH}" = xyes ] ; then
1244 fragment <<EOF
1245           found = 0;
1246           rp = bfd_elf_get_runpath_list (link_info.output_bfd, &link_info);
1247           for (; !found && rp != NULL; rp = rp->next)
1248             {
1249               char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
1250               found = (rp->by == l->by
1251                        && gld${EMULATION_NAME}_search_needed (tmpname,
1252                                                               &n,
1253                                                               force));
1254               free (tmpname);
1255             }
1256           if (found)
1257             break;
1258
1259 EOF
1260 fi
1261 if [ "x${USE_LIBPATH}" = xyes ] ; then
1262   case ${target} in
1263     *-*-freebsd* | *-*-dragonfly*)
1264       fragment <<EOF
1265           if (gld${EMULATION_NAME}_check_ld_elf_hints (l->name, force))
1266             break;
1267 EOF
1268     # FreeBSD
1269     ;;
1270
1271     *-*-linux-* | *-*-k*bsd*-*)
1272     # Linux
1273       fragment <<EOF
1274           if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
1275             break;
1276
1277 EOF
1278     ;;
1279   esac
1280 fi
1281 fragment <<EOF
1282           len = strlen (l->name);
1283           for (search = search_head; search != NULL; search = search->next)
1284             {
1285               char *filename;
1286
1287               if (search->cmdline)
1288                 continue;
1289               filename = (char *) xmalloc (strlen (search->name) + len + 2);
1290               sprintf (filename, "%s/%s", search->name, l->name);
1291               nn.name = filename;
1292               if (gld${EMULATION_NAME}_try_needed (&nn, force))
1293                 break;
1294               free (filename);
1295             }
1296           if (search != NULL)
1297             break;
1298 EOF
1299 fragment <<EOF
1300         }
1301
1302       if (force < 2)
1303         continue;
1304
1305       einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
1306              l->name, l->by);
1307     }
1308 }
1309
1310 EOF
1311 fi
1312
1313 fragment <<EOF
1314
1315 /* Look through an expression for an assignment statement.  */
1316
1317 static void
1318 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1319 {
1320   bfd_boolean provide = FALSE;
1321
1322   switch (exp->type.node_class)
1323     {
1324     case etree_provide:
1325       provide = TRUE;
1326       /* Fall thru */
1327     case etree_assign:
1328       /* We call record_link_assignment even if the symbol is defined.
1329          This is because if it is defined by a dynamic object, we
1330          actually want to use the value defined by the linker script,
1331          not the value from the dynamic object (because we are setting
1332          symbols like etext).  If the symbol is defined by a regular
1333          object, then, as it happens, calling record_link_assignment
1334          will do no harm.  */
1335       if (strcmp (exp->assign.dst, ".") != 0)
1336         {
1337           if (!bfd_elf_record_link_assignment (link_info.output_bfd,
1338                                                &link_info,
1339                                                exp->assign.dst, provide,
1340                                                exp->assign.hidden))
1341             einfo ("%P%F: failed to record assignment to %s: %E\n",
1342                    exp->assign.dst);
1343         }
1344       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1345       break;
1346
1347     case etree_binary:
1348       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1349       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1350       break;
1351
1352     case etree_trinary:
1353       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1354       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1355       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1356       break;
1357
1358     case etree_unary:
1359       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1360       break;
1361
1362     default:
1363       break;
1364     }
1365 }
1366
1367
1368 /* This is called by the before_allocation routine via
1369    lang_for_each_statement.  It locates any assignment statements, and
1370    tells the ELF backend about them, in case they are assignments to
1371    symbols which are referred to by dynamic objects.  */
1372
1373 static void
1374 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1375 {
1376   if (s->header.type == lang_assignment_statement_enum)
1377     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1378 }
1379
1380 EOF
1381
1382 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1383   if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1384     ELF_INTERPRETER_SET_DEFAULT="
1385   if (sinterp != NULL)
1386     {
1387       sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1388       sinterp->size = strlen ((char *) sinterp->contents) + 1;
1389     }
1390
1391 "
1392   else
1393     ELF_INTERPRETER_SET_DEFAULT=
1394   fi
1395 fragment <<EOF
1396
1397 /* This is called after the sections have been attached to output
1398    sections, but before any sizes or addresses have been set.  */
1399
1400 static void
1401 gld${EMULATION_NAME}_before_allocation (void)
1402 {
1403   const char *rpath;
1404   asection *sinterp;
1405
1406   if (link_info.hash->type == bfd_link_elf_hash_table)
1407     _bfd_elf_tls_setup (link_info.output_bfd, &link_info);
1408
1409   /* If we are going to make any variable assignments, we need to let
1410      the ELF backend know about them in case the variables are
1411      referred to by dynamic objects.  */
1412   lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1413
1414   /* Let the ELF backend work out the sizes of any sections required
1415      by dynamic linking.  */
1416   rpath = command_line.rpath;
1417   if (rpath == NULL)
1418     rpath = (const char *) getenv ("LD_RUN_PATH");
1419   if (! (bfd_elf_size_dynamic_sections
1420          (link_info.output_bfd, command_line.soname, rpath,
1421           command_line.filter_shlib,
1422           (const char * const *) command_line.auxiliary_filters,
1423           &link_info, &sinterp, lang_elf_version_info)))
1424     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1425
1426 ${ELF_INTERPRETER_SET_DEFAULT}
1427   /* Let the user override the dynamic linker we are using.  */
1428   if (command_line.interpreter != NULL
1429       && sinterp != NULL)
1430     {
1431       sinterp->contents = (bfd_byte *) command_line.interpreter;
1432       sinterp->size = strlen (command_line.interpreter) + 1;
1433     }
1434
1435   /* Look for any sections named .gnu.warning.  As a GNU extensions,
1436      we treat such sections as containing warning messages.  We print
1437      out the warning message, and then zero out the section size so
1438      that it does not get copied into the output file.  */
1439
1440   {
1441     LANG_FOR_EACH_INPUT_STATEMENT (is)
1442       {
1443         asection *s;
1444         bfd_size_type sz;
1445         char *msg;
1446         bfd_boolean ret;
1447
1448         if (is->just_syms_flag)
1449           continue;
1450
1451         s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1452         if (s == NULL)
1453           continue;
1454
1455         sz = s->size;
1456         msg = xmalloc ((size_t) (sz + 1));
1457         if (! bfd_get_section_contents (is->the_bfd, s, msg,
1458                                         (file_ptr) 0, sz))
1459           einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1460                  is->the_bfd);
1461         msg[sz] = '\0';
1462         ret = link_info.callbacks->warning (&link_info, msg,
1463                                             (const char *) NULL,
1464                                             is->the_bfd, (asection *) NULL,
1465                                             (bfd_vma) 0);
1466         ASSERT (ret);
1467         free (msg);
1468
1469         /* Clobber the section size, so that we don't waste space
1470            copying the warning into the output file.  If we've already
1471            sized the output section, adjust its size.  The adjustment
1472            is on rawsize because targets that size sections early will
1473            have called lang_reset_memory_regions after sizing.  */
1474         if (s->output_section != NULL
1475             && s->output_section->rawsize >= s->size)
1476           s->output_section->rawsize -= s->size;
1477
1478         s->size = 0;
1479
1480         /* Also set SEC_EXCLUDE, so that local symbols defined in the
1481            warning section don't get copied to the output.  */
1482         s->flags |= SEC_EXCLUDE | SEC_KEEP;
1483       }
1484   }
1485
1486   before_allocation_default ();
1487
1488   if (!bfd_elf_size_dynsym_hash_dynstr (link_info.output_bfd, &link_info))
1489     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1490 }
1491
1492 EOF
1493 fi
1494
1495 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1496 fragment <<EOF
1497
1498 /* Try to open a dynamic archive.  This is where we know that ELF
1499    dynamic libraries have an extension of .so (or .sl on oddball systems
1500    like hpux).  */
1501
1502 static bfd_boolean
1503 gld${EMULATION_NAME}_open_dynamic_archive
1504   (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1505 {
1506   const char *filename;
1507   char *string;
1508
1509   if (! entry->is_archive)
1510     return FALSE;
1511
1512   filename = entry->filename;
1513
1514   /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1515      is defined, but it does not seem worth the headache to optimize
1516      away those two bytes of space.  */
1517   string = (char *) xmalloc (strlen (search->name)
1518                              + strlen (filename)
1519                              + strlen (arch)
1520 #ifdef EXTRA_SHLIB_EXTENSION
1521                              + strlen (EXTRA_SHLIB_EXTENSION)
1522 #endif
1523                              + sizeof "/lib.so");
1524
1525   sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1526
1527 #ifdef EXTRA_SHLIB_EXTENSION
1528   /* Try the .so extension first.  If that fails build a new filename
1529      using EXTRA_SHLIB_EXTENSION.  */
1530   if (! ldfile_try_open_bfd (string, entry))
1531     {
1532       sprintf (string, "%s/lib%s%s%s", search->name,
1533                filename, arch, EXTRA_SHLIB_EXTENSION);
1534 #endif
1535
1536   if (! ldfile_try_open_bfd (string, entry))
1537     {
1538       free (string);
1539       return FALSE;
1540     }
1541 #ifdef EXTRA_SHLIB_EXTENSION
1542     }
1543 #endif
1544
1545   entry->filename = string;
1546
1547   /* We have found a dynamic object to include in the link.  The ELF
1548      backend linker will create a DT_NEEDED entry in the .dynamic
1549      section naming this file.  If this file includes a DT_SONAME
1550      entry, it will be used.  Otherwise, the ELF linker will just use
1551      the name of the file.  For an archive found by searching, like
1552      this one, the DT_NEEDED entry should consist of just the name of
1553      the file, without the path information used to find it.  Note
1554      that we only need to do this if we have a dynamic object; an
1555      archive will never be referenced by a DT_NEEDED entry.
1556
1557      FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1558      very pretty.  I haven't been able to think of anything that is
1559      pretty, though.  */
1560   if (bfd_check_format (entry->the_bfd, bfd_object)
1561       && (entry->the_bfd->flags & DYNAMIC) != 0)
1562     {
1563       ASSERT (entry->is_archive && entry->search_dirs_flag);
1564
1565       /* Rather than duplicating the logic above.  Just use the
1566          filename we recorded earlier.  */
1567
1568       filename = lbasename (entry->filename);
1569       bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1570     }
1571
1572   return TRUE;
1573 }
1574
1575 EOF
1576 fi
1577
1578 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1579 fragment <<EOF
1580
1581 /* A variant of lang_output_section_find used by place_orphan.  */
1582
1583 static lang_output_section_statement_type *
1584 output_rel_find (asection *sec, int isdyn)
1585 {
1586   lang_output_section_statement_type *lookup;
1587   lang_output_section_statement_type *last = NULL;
1588   lang_output_section_statement_type *last_alloc = NULL;
1589   lang_output_section_statement_type *last_ro_alloc = NULL;
1590   lang_output_section_statement_type *last_rel = NULL;
1591   lang_output_section_statement_type *last_rel_alloc = NULL;
1592   int rela = sec->name[4] == 'a';
1593
1594   for (lookup = &lang_output_section_statement.head->output_section_statement;
1595        lookup != NULL;
1596        lookup = lookup->next)
1597     {
1598       if (lookup->constraint >= 0
1599           && CONST_STRNEQ (lookup->name, ".rel"))
1600         {
1601           int lookrela = lookup->name[4] == 'a';
1602
1603           /* .rel.dyn must come before all other reloc sections, to suit
1604              GNU ld.so.  */
1605           if (isdyn)
1606             break;
1607
1608           /* Don't place after .rel.plt as doing so results in wrong
1609              dynamic tags.  */
1610           if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1611             break;
1612
1613           if (rela == lookrela || last_rel == NULL)
1614             last_rel = lookup;
1615           if ((rela == lookrela || last_rel_alloc == NULL)
1616               && lookup->bfd_section != NULL
1617               && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1618             last_rel_alloc = lookup;
1619         }
1620
1621       last = lookup;
1622       if (lookup->bfd_section != NULL
1623           && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1624         {
1625           last_alloc = lookup;
1626           if ((lookup->bfd_section->flags & SEC_READONLY) != 0)
1627             last_ro_alloc = lookup;
1628         }
1629     }
1630
1631   if (last_rel_alloc)
1632     return last_rel_alloc;
1633
1634   if (last_rel)
1635     return last_rel;
1636
1637   if (last_ro_alloc)
1638     return last_ro_alloc;
1639
1640   if (last_alloc)
1641     return last_alloc;
1642
1643   return last;
1644 }
1645
1646 /* Place an orphan section.  We use this to put random SHF_ALLOC
1647    sections in the right segment.  */
1648
1649 static lang_output_section_statement_type *
1650 gld${EMULATION_NAME}_place_orphan (asection *s,
1651                                    const char *secname,
1652                                    int constraint)
1653 {
1654   static struct orphan_save hold[] =
1655     {
1656       { ".text",
1657         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1658         0, 0, 0, 0 },
1659       { ".rodata",
1660         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1661         0, 0, 0, 0 },
1662       { ".data",
1663         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1664         0, 0, 0, 0 },
1665       { ".bss",
1666         SEC_ALLOC,
1667         0, 0, 0, 0 },
1668       { 0,
1669         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1670         0, 0, 0, 0 },
1671       { ".interp",
1672         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1673         0, 0, 0, 0 },
1674       { ".sdata",
1675         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1676         0, 0, 0, 0 },
1677       { 0,
1678         SEC_HAS_CONTENTS,
1679         0, 0, 0, 0 },
1680     };
1681   enum orphan_save_index
1682     {
1683       orphan_text = 0,
1684       orphan_rodata,
1685       orphan_data,
1686       orphan_bss,
1687       orphan_rel,
1688       orphan_interp,
1689       orphan_sdata,
1690       orphan_nonalloc
1691     };
1692   static int orphan_init_done = 0;
1693   struct orphan_save *place;
1694   lang_output_section_statement_type *after;
1695   lang_output_section_statement_type *os;
1696   int isdyn = 0;
1697   int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1698   unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
1699
1700   if (! link_info.relocatable
1701       && link_info.combreloc
1702       && (s->flags & SEC_ALLOC))
1703     {
1704       if (iself)
1705         switch (sh_type)
1706           {
1707           case SHT_RELA:
1708             secname = ".rela.dyn";
1709             isdyn = 1;
1710             break;
1711           case SHT_REL:
1712             secname = ".rel.dyn";
1713             isdyn = 1;
1714             break;
1715           default:
1716             break;
1717           }
1718       else if (CONST_STRNEQ (secname, ".rel"))
1719         {
1720           secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1721           isdyn = 1;
1722         }
1723     }
1724
1725   /* Look through the script to see where to place this section.  */
1726   if (constraint == 0)
1727     for (os = lang_output_section_find (secname);
1728          os != NULL;
1729          os = next_matching_output_section_statement (os, 0))
1730       {
1731         /* If we don't match an existing output section, tell
1732            lang_insert_orphan to create a new output section.  */
1733         constraint = SPECIAL;
1734
1735         if (os->bfd_section != NULL
1736             && (os->bfd_section->flags == 0
1737                 || (_bfd_elf_match_sections_by_type (link_info.output_bfd,
1738                                                      os->bfd_section,
1739                                                      s->owner, s)
1740                     && ((s->flags ^ os->bfd_section->flags)
1741                         & (SEC_LOAD | SEC_ALLOC)) == 0)))
1742           {
1743             /* We already have an output section statement with this
1744                name, and its bfd section has compatible flags.
1745                If the section already exists but does not have any flags
1746                set, then it has been created by the linker, probably as a
1747                result of a --section-start command line switch.  */
1748             lang_add_section (&os->children, s, os);
1749             return os;
1750           }
1751       }
1752
1753   if (!orphan_init_done)
1754     {
1755       lang_output_section_statement_type *lookup;
1756       struct orphan_save *ho;
1757
1758       for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1759         if (ho->name != NULL)
1760           {
1761             ho->os = lang_output_section_find (ho->name);
1762             if (ho->os != NULL && ho->os->flags == 0)
1763               ho->os->flags = ho->flags;
1764           }
1765       lookup = hold[orphan_bss].os;
1766       if (lookup == NULL)
1767         lookup = &lang_output_section_statement.head->output_section_statement;
1768       for (; lookup != NULL; lookup = lookup->next)
1769         if ((lookup->bfd_section != NULL
1770              && (lookup->bfd_section->flags & SEC_DEBUGGING) != 0)
1771             || strcmp (lookup->name, ".comment") == 0)
1772           break;
1773       hold[orphan_nonalloc].os = lookup ? lookup->prev : NULL;
1774       hold[orphan_nonalloc].name = ".comment";
1775       orphan_init_done = 1;
1776     }
1777
1778   /* If this is a final link, then always put .gnu.warning.SYMBOL
1779      sections into the .text section to get them out of the way.  */
1780   if (link_info.executable
1781       && ! link_info.relocatable
1782       && CONST_STRNEQ (s->name, ".gnu.warning.")
1783       && hold[orphan_text].os != NULL)
1784     {
1785       os = hold[orphan_text].os;
1786       lang_add_section (&os->children, s, os);
1787       return os;
1788     }
1789
1790   /* Decide which segment the section should go in based on the
1791      section name and section flags.  We put loadable .note sections
1792      right after the .interp section, so that the PT_NOTE segment is
1793      stored right after the program headers where the OS can read it
1794      in the first page.  */
1795
1796   place = NULL;
1797   if ((s->flags & (SEC_ALLOC | SEC_DEBUGGING)) == 0)
1798     place = &hold[orphan_nonalloc];
1799   else if ((s->flags & SEC_ALLOC) == 0)
1800     ;
1801   else if ((s->flags & SEC_LOAD) != 0
1802            && ((iself && sh_type == SHT_NOTE)
1803                || (!iself && CONST_STRNEQ (secname, ".note"))))
1804     place = &hold[orphan_interp];
1805   else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1806     place = &hold[orphan_bss];
1807   else if ((s->flags & SEC_SMALL_DATA) != 0)
1808     place = &hold[orphan_sdata];
1809   else if ((s->flags & SEC_READONLY) == 0)
1810     place = &hold[orphan_data];
1811   else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
1812             || (!iself && CONST_STRNEQ (secname, ".rel")))
1813            && (s->flags & SEC_LOAD) != 0)
1814     place = &hold[orphan_rel];
1815   else if ((s->flags & SEC_CODE) == 0)
1816     place = &hold[orphan_rodata];
1817   else
1818     place = &hold[orphan_text];
1819
1820   after = NULL;
1821   if (place != NULL)
1822     {
1823       if (place->os == NULL)
1824         {
1825           if (place->name != NULL)
1826             place->os = lang_output_section_find (place->name);
1827           else
1828             place->os = output_rel_find (s, isdyn);
1829         }
1830       after = place->os;
1831       if (after == NULL)
1832         after = lang_output_section_find_by_flags
1833           (s, &place->os, _bfd_elf_match_sections_by_type);
1834       if (after == NULL)
1835         /* *ABS* is always the first output section statement.  */
1836         after = &lang_output_section_statement.head->output_section_statement;
1837     }
1838
1839   return lang_insert_orphan (s, secname, constraint, after, place, NULL, NULL);
1840 }
1841 EOF
1842 fi
1843
1844 if test x"$LDEMUL_AFTER_ALLOCATION" != xgld"$EMULATION_NAME"_after_allocation; then
1845 fragment <<EOF
1846
1847 static void
1848 gld${EMULATION_NAME}_after_allocation (void)
1849 {
1850   bfd_boolean need_layout = bfd_elf_discard_info (link_info.output_bfd,
1851                                                   &link_info);
1852   gld${EMULATION_NAME}_map_segments (need_layout);
1853 }
1854 EOF
1855 fi
1856
1857 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1858 fragment <<EOF
1859
1860 static char *
1861 gld${EMULATION_NAME}_get_script (int *isfile)
1862 EOF
1863
1864 if test -n "$COMPILE_IN"
1865 then
1866 # Scripts compiled in.
1867
1868 # sed commands to quote an ld script as a C string.
1869 sc="-f stringify.sed"
1870
1871 fragment <<EOF
1872 {
1873   *isfile = 0;
1874
1875   if (link_info.relocatable && config.build_constructors)
1876     return
1877 EOF
1878 sed $sc ldscripts/${EMULATION_NAME}.xu                  >> e${EMULATION_NAME}.c
1879 echo '  ; else if (link_info.relocatable) return'       >> e${EMULATION_NAME}.c
1880 sed $sc ldscripts/${EMULATION_NAME}.xr                  >> e${EMULATION_NAME}.c
1881 echo '  ; else if (!config.text_read_only) return'      >> e${EMULATION_NAME}.c
1882 sed $sc ldscripts/${EMULATION_NAME}.xbn                 >> e${EMULATION_NAME}.c
1883 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1884 echo '  ; else if (!config.magic_demand_paged) return'  >> e${EMULATION_NAME}.c
1885 sed $sc ldscripts/${EMULATION_NAME}.xn                  >> e${EMULATION_NAME}.c
1886 fi
1887 if test -n "$GENERATE_PIE_SCRIPT" ; then
1888 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1889 echo '  ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1890 echo '             && link_info.relro' >> e${EMULATION_NAME}.c
1891 echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1892 sed $sc ldscripts/${EMULATION_NAME}.xdw                 >> e${EMULATION_NAME}.c
1893 echo '  ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1894 sed $sc ldscripts/${EMULATION_NAME}.xdc                 >> e${EMULATION_NAME}.c
1895 fi
1896 echo '  ; else if (link_info.pie) return'               >> e${EMULATION_NAME}.c
1897 sed $sc ldscripts/${EMULATION_NAME}.xd                  >> e${EMULATION_NAME}.c
1898 fi
1899 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1900 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1901 echo '  ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1902 echo '             && link_info.relro' >> e${EMULATION_NAME}.c
1903 echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1904 sed $sc ldscripts/${EMULATION_NAME}.xsw                 >> e${EMULATION_NAME}.c
1905 echo '  ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1906 sed $sc ldscripts/${EMULATION_NAME}.xsc                 >> e${EMULATION_NAME}.c
1907 fi
1908 echo '  ; else if (link_info.shared) return'            >> e${EMULATION_NAME}.c
1909 sed $sc ldscripts/${EMULATION_NAME}.xs                  >> e${EMULATION_NAME}.c
1910 fi
1911 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1912 echo '  ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1913 echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1914 sed $sc ldscripts/${EMULATION_NAME}.xw                  >> e${EMULATION_NAME}.c
1915 echo '  ; else if (link_info.combreloc) return'         >> e${EMULATION_NAME}.c
1916 sed $sc ldscripts/${EMULATION_NAME}.xc                  >> e${EMULATION_NAME}.c
1917 fi
1918 echo '  ; else return'                                  >> e${EMULATION_NAME}.c
1919 sed $sc ldscripts/${EMULATION_NAME}.x                   >> e${EMULATION_NAME}.c
1920 echo '; }'                                              >> e${EMULATION_NAME}.c
1921
1922 else
1923 # Scripts read from the filesystem.
1924
1925 fragment <<EOF
1926 {
1927   *isfile = 1;
1928
1929   if (link_info.relocatable && config.build_constructors)
1930     return "ldscripts/${EMULATION_NAME}.xu";
1931   else if (link_info.relocatable)
1932     return "ldscripts/${EMULATION_NAME}.xr";
1933   else if (!config.text_read_only)
1934     return "ldscripts/${EMULATION_NAME}.xbn";
1935 EOF
1936 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1937 else
1938 fragment <<EOF
1939   else if (!config.magic_demand_paged)
1940     return "ldscripts/${EMULATION_NAME}.xn";
1941 EOF
1942 fi
1943 if test -n "$GENERATE_PIE_SCRIPT" ; then
1944 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1945 fragment <<EOF
1946   else if (link_info.pie && link_info.combreloc
1947            && link_info.relro && (link_info.flags & DF_BIND_NOW))
1948     return "ldscripts/${EMULATION_NAME}.xdw";
1949   else if (link_info.pie && link_info.combreloc)
1950     return "ldscripts/${EMULATION_NAME}.xdc";
1951 EOF
1952 fi
1953 fragment <<EOF
1954   else if (link_info.pie)
1955     return "ldscripts/${EMULATION_NAME}.xd";
1956 EOF
1957 fi
1958 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1959 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1960 fragment <<EOF
1961   else if (link_info.shared && link_info.combreloc
1962            && link_info.relro && (link_info.flags & DF_BIND_NOW))
1963     return "ldscripts/${EMULATION_NAME}.xsw";
1964   else if (link_info.shared && link_info.combreloc)
1965     return "ldscripts/${EMULATION_NAME}.xsc";
1966 EOF
1967 fi
1968 fragment <<EOF
1969   else if (link_info.shared)
1970     return "ldscripts/${EMULATION_NAME}.xs";
1971 EOF
1972 fi
1973 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1974 fragment <<EOF
1975   else if (link_info.combreloc && link_info.relro
1976            && (link_info.flags & DF_BIND_NOW))
1977     return "ldscripts/${EMULATION_NAME}.xw";
1978   else if (link_info.combreloc)
1979     return "ldscripts/${EMULATION_NAME}.xc";
1980 EOF
1981 fi
1982 fragment <<EOF
1983   else
1984     return "ldscripts/${EMULATION_NAME}.x";
1985 }
1986
1987 EOF
1988 fi
1989 fi
1990
1991 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1992
1993 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1994 fragment <<EOF
1995  $PARSE_AND_LIST_PROLOGUE
1996 EOF
1997 fi
1998
1999 fragment <<EOF
2000
2001 #define OPTION_DISABLE_NEW_DTAGS        (400)
2002 #define OPTION_ENABLE_NEW_DTAGS         (OPTION_DISABLE_NEW_DTAGS + 1)
2003 #define OPTION_GROUP                    (OPTION_ENABLE_NEW_DTAGS + 1)
2004 #define OPTION_EH_FRAME_HDR             (OPTION_GROUP + 1)
2005 #define OPTION_EXCLUDE_LIBS             (OPTION_EH_FRAME_HDR + 1)
2006 #define OPTION_HASH_STYLE               (OPTION_EXCLUDE_LIBS + 1)
2007 #define OPTION_BUILD_ID                 (OPTION_HASH_STYLE + 1)
2008
2009 static void
2010 gld${EMULATION_NAME}_add_options
2011   (int ns, char **shortopts, int nl, struct option **longopts,
2012    int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
2013 {
2014   static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
2015   static const struct option xtra_long[] = {
2016     {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
2017 EOF
2018
2019 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2020 fragment <<EOF
2021     {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
2022     {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
2023     {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
2024     {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
2025     {"hash-style", required_argument, NULL, OPTION_HASH_STYLE},
2026     {"Bgroup", no_argument, NULL, OPTION_GROUP},
2027 EOF
2028 fi
2029
2030 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
2031 fragment <<EOF
2032     $PARSE_AND_LIST_LONGOPTS
2033 EOF
2034 fi
2035
2036 fragment <<EOF
2037     {NULL, no_argument, NULL, 0}
2038   };
2039
2040   *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
2041   memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
2042   *longopts = (struct option *)
2043     xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
2044   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
2045 }
2046
2047 #define DEFAULT_BUILD_ID_STYLE  "sha1"
2048
2049 static bfd_boolean
2050 gld${EMULATION_NAME}_handle_option (int optc)
2051 {
2052   switch (optc)
2053     {
2054     default:
2055       return FALSE;
2056
2057     case OPTION_BUILD_ID:
2058       if (link_info.emit_note_gnu_build_id != NULL)
2059         {
2060           free (link_info.emit_note_gnu_build_id);
2061           link_info.emit_note_gnu_build_id = NULL;
2062         }
2063       if (optarg == NULL)
2064         optarg = DEFAULT_BUILD_ID_STYLE;
2065       if (strcmp (optarg, "none"))
2066         link_info.emit_note_gnu_build_id = xstrdup (optarg);
2067       break;
2068
2069 EOF
2070
2071 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2072 fragment <<EOF
2073     case OPTION_DISABLE_NEW_DTAGS:
2074       link_info.new_dtags = FALSE;
2075       break;
2076
2077     case OPTION_ENABLE_NEW_DTAGS:
2078       link_info.new_dtags = TRUE;
2079       break;
2080
2081     case OPTION_EH_FRAME_HDR:
2082       link_info.eh_frame_hdr = TRUE;
2083       break;
2084
2085     case OPTION_GROUP:
2086       link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
2087       /* Groups must be self-contained.  */
2088       link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2089       link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
2090       break;
2091
2092     case OPTION_EXCLUDE_LIBS:
2093       add_excluded_libs (optarg);
2094       break;
2095
2096     case OPTION_HASH_STYLE:
2097       link_info.emit_hash = FALSE;
2098       link_info.emit_gnu_hash = FALSE;
2099       if (strcmp (optarg, "sysv") == 0)
2100         link_info.emit_hash = TRUE;
2101       else if (strcmp (optarg, "gnu") == 0)
2102         link_info.emit_gnu_hash = TRUE;
2103       else if (strcmp (optarg, "both") == 0)
2104         {
2105           link_info.emit_hash = TRUE;
2106           link_info.emit_gnu_hash = TRUE;
2107         }
2108       else
2109         einfo (_("%P%F: invalid hash style \`%s'\n"), optarg);
2110       break;
2111
2112     case 'z':
2113       if (strcmp (optarg, "initfirst") == 0)
2114         link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
2115       else if (strcmp (optarg, "interpose") == 0)
2116         link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
2117       else if (strcmp (optarg, "loadfltr") == 0)
2118         link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
2119       else if (strcmp (optarg, "nodefaultlib") == 0)
2120         link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
2121       else if (strcmp (optarg, "nodelete") == 0)
2122         link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
2123       else if (strcmp (optarg, "nodlopen") == 0)
2124         link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
2125       else if (strcmp (optarg, "nodump") == 0)
2126         link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
2127       else if (strcmp (optarg, "now") == 0)
2128         {
2129           link_info.flags |= (bfd_vma) DF_BIND_NOW;
2130           link_info.flags_1 |= (bfd_vma) DF_1_NOW;
2131         }
2132       else if (strcmp (optarg, "lazy") == 0)
2133         {
2134           link_info.flags &= ~(bfd_vma) DF_BIND_NOW;
2135           link_info.flags_1 &= ~(bfd_vma) DF_1_NOW;
2136         }
2137       else if (strcmp (optarg, "origin") == 0)
2138         {
2139           link_info.flags |= (bfd_vma) DF_ORIGIN;
2140           link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
2141         }
2142       else if (strcmp (optarg, "defs") == 0)
2143         link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2144       else if (strcmp (optarg, "muldefs") == 0)
2145         link_info.allow_multiple_definition = TRUE;
2146       else if (strcmp (optarg, "combreloc") == 0)
2147         link_info.combreloc = TRUE;
2148       else if (strcmp (optarg, "nocombreloc") == 0)
2149         link_info.combreloc = FALSE;
2150       else if (strcmp (optarg, "nocopyreloc") == 0)
2151         link_info.nocopyreloc = TRUE;
2152       else if (strcmp (optarg, "execstack") == 0)
2153         {
2154           link_info.execstack = TRUE;
2155           link_info.noexecstack = FALSE;
2156         }
2157       else if (strcmp (optarg, "noexecstack") == 0)
2158         {
2159           link_info.noexecstack = TRUE;
2160           link_info.execstack = FALSE;
2161         }
2162 EOF
2163
2164   if test -n "$COMMONPAGESIZE"; then
2165 fragment <<EOF
2166       else if (strcmp (optarg, "relro") == 0)
2167         link_info.relro = TRUE;
2168       else if (strcmp (optarg, "norelro") == 0)
2169         link_info.relro = FALSE;
2170 EOF
2171   fi
2172
2173 fragment <<EOF
2174       else if (CONST_STRNEQ (optarg, "max-page-size="))
2175         {
2176           char *end;
2177
2178           config.maxpagesize = strtoul (optarg + 14, &end, 0);
2179           if (*end || (config.maxpagesize & (config.maxpagesize - 1)) != 0)
2180             einfo (_("%P%F: invalid maxium page size \`%s'\n"),
2181                    optarg + 14);
2182         }
2183       else if (CONST_STRNEQ (optarg, "common-page-size="))
2184         {
2185           char *end;
2186           config.commonpagesize = strtoul (optarg + 17, &end, 0);
2187           if (*end
2188               || (config.commonpagesize & (config.commonpagesize - 1)) != 0)
2189             einfo (_("%P%F: invalid common page size \`%s'\n"),
2190                    optarg + 17);
2191         }
2192       /* What about the other Solaris -z options? FIXME.  */
2193       break;
2194 EOF
2195 fi
2196
2197 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
2198 fragment <<EOF
2199  $PARSE_AND_LIST_ARGS_CASES
2200 EOF
2201 fi
2202
2203 fragment <<EOF
2204     }
2205
2206   return TRUE;
2207 }
2208
2209 EOF
2210
2211 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2212 fragment <<EOF
2213
2214 static void
2215 gld${EMULATION_NAME}_list_options (FILE * file)
2216 {
2217   fprintf (file, _("\
2218   --build-id[=STYLE]          Generate build ID note\n"));
2219 EOF
2220
2221 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2222 fragment <<EOF
2223   fprintf (file, _("\
2224   -Bgroup                     Selects group name lookup rules for DSO\n"));
2225   fprintf (file, _("\
2226   --disable-new-dtags         Disable new dynamic tags\n"));
2227   fprintf (file, _("\
2228   --enable-new-dtags          Enable new dynamic tags\n"));
2229   fprintf (file, _("\
2230   --eh-frame-hdr              Create .eh_frame_hdr section\n"));
2231   fprintf (file, _("\
2232   --hash-style=STYLE          Set hash style to sysv, gnu or both\n"));
2233   fprintf (file, _("\
2234   -z combreloc                Merge dynamic relocs into one section and sort\n"));
2235   fprintf (file, _("\
2236   -z defs                     Report unresolved symbols in object files.\n"));
2237   fprintf (file, _("\
2238   -z execstack                Mark executable as requiring executable stack\n"));
2239   fprintf (file, _("\
2240   -z initfirst                Mark DSO to be initialized first at runtime\n"));
2241   fprintf (file, _("\
2242   -z interpose                Mark object to interpose all DSOs but executable\n"));
2243   fprintf (file, _("\
2244   -z lazy                     Mark object lazy runtime binding (default)\n"));
2245   fprintf (file, _("\
2246   -z loadfltr                 Mark object requiring immediate process\n"));
2247   fprintf (file, _("\
2248   -z muldefs                  Allow multiple definitions\n"));
2249   fprintf (file, _("\
2250   -z nocombreloc              Don't merge dynamic relocs into one section\n"));
2251   fprintf (file, _("\
2252   -z nocopyreloc              Don't create copy relocs\n"));
2253   fprintf (file, _("\
2254   -z nodefaultlib             Mark object not to use default search paths\n"));
2255   fprintf (file, _("\
2256   -z nodelete                 Mark DSO non-deletable at runtime\n"));
2257   fprintf (file, _("\
2258   -z nodlopen                 Mark DSO not available to dlopen\n"));
2259   fprintf (file, _("\
2260   -z nodump                   Mark DSO not available to dldump\n"));
2261   fprintf (file, _("\
2262   -z noexecstack              Mark executable as not requiring executable stack\n"));
2263 EOF
2264
2265   if test -n "$COMMONPAGESIZE"; then
2266 fragment <<EOF
2267   fprintf (file, _("\
2268   -z norelro                  Don't create RELRO program header\n"));
2269 EOF
2270   fi
2271
2272 fragment <<EOF
2273   fprintf (file, _("\
2274   -z now                      Mark object non-lazy runtime binding\n"));
2275   fprintf (file, _("\
2276   -z origin                   Mark object requiring immediate \$ORIGIN\n\
2277                                 processing at runtime\n"));
2278 EOF
2279
2280   if test -n "$COMMONPAGESIZE"; then
2281 fragment <<EOF
2282   fprintf (file, _("\
2283   -z relro                    Create RELRO program header\n"));
2284 EOF
2285   fi
2286
2287 fragment <<EOF
2288   fprintf (file, _("\
2289   -z max-page-size=SIZE       Set maximum page size to SIZE\n"));
2290   fprintf (file, _("\
2291   -z common-page-size=SIZE    Set common page size to SIZE\n"));
2292   fprintf (file, _("\
2293   -z KEYWORD                  Ignored for Solaris compatibility\n"));
2294 EOF
2295 fi
2296
2297 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
2298 fragment <<EOF
2299  $PARSE_AND_LIST_OPTIONS
2300 EOF
2301 fi
2302
2303 fragment <<EOF
2304 }
2305 EOF
2306
2307 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
2308 fragment <<EOF
2309  $PARSE_AND_LIST_EPILOGUE
2310 EOF
2311 fi
2312 fi
2313 else
2314 fragment <<EOF
2315 #define gld${EMULATION_NAME}_add_options NULL
2316 #define gld${EMULATION_NAME}_handle_option NULL
2317 EOF
2318 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2319 fragment <<EOF
2320 #define gld${EMULATION_NAME}_list_options NULL
2321 EOF
2322 fi
2323 fi
2324
2325 fragment <<EOF
2326
2327 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
2328 {
2329   ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
2330   ${LDEMUL_SYSLIB-syslib_default},
2331   ${LDEMUL_HLL-hll_default},
2332   ${LDEMUL_AFTER_PARSE-after_parse_default},
2333   ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
2334   ${LDEMUL_AFTER_ALLOCATION-gld${EMULATION_NAME}_after_allocation},
2335   ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
2336   ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
2337   ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
2338   ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
2339   "${EMULATION_NAME}",
2340   "${OUTPUT_FORMAT}",
2341   ${LDEMUL_FINISH-finish_default},
2342   ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
2343   ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
2344   ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
2345   ${LDEMUL_SET_SYMBOLS-NULL},
2346   ${LDEMUL_PARSE_ARGS-NULL},
2347   gld${EMULATION_NAME}_add_options,
2348   gld${EMULATION_NAME}_handle_option,
2349   ${LDEMUL_UNRECOGNIZED_FILE-NULL},
2350   ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
2351   ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
2352   ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
2353   ${LDEMUL_NEW_VERS_PATTERN-NULL}
2354 };
2355 EOF