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