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