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