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