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