ld/emultempl/elf32.em

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