ld/emultempl/elf32.em

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