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       { ".tdata",
1816         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_THREAD_LOCAL,
1817         0, 0, 0, 0 },
1818       { ".data",
1819         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1820         0, 0, 0, 0 },
1821       { ".bss",
1822         SEC_ALLOC,
1823         0, 0, 0, 0 },
1824       { 0,
1825         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1826         0, 0, 0, 0 },
1827       { ".interp",
1828         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1829         0, 0, 0, 0 },
1830       { ".sdata",
1831         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1832         0, 0, 0, 0 },
1833       { ".comment",
1834         SEC_HAS_CONTENTS,
1835         0, 0, 0, 0 },
1836     };
1837   enum orphan_save_index
1838     {
1839       orphan_text = 0,
1840       orphan_rodata,
1841       orphan_tdata,
1842       orphan_data,
1843       orphan_bss,
1844       orphan_rel,
1845       orphan_interp,
1846       orphan_sdata,
1847       orphan_nonalloc
1848     };
1849   static int orphan_init_done = 0;
1850   struct orphan_save *place;
1851   lang_output_section_statement_type *after;
1852   lang_output_section_statement_type *os;
1853   lang_output_section_statement_type *match_by_name = NULL;
1854   int isdyn = 0;
1855   int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1856   unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
1857
1858   if (! link_info.relocatable
1859       && link_info.combreloc
1860       && (s->flags & SEC_ALLOC))
1861     {
1862       if (iself)
1863         switch (sh_type)
1864           {
1865           case SHT_RELA:
1866             secname = ".rela.dyn";
1867             isdyn = 1;
1868             break;
1869           case SHT_REL:
1870             secname = ".rel.dyn";
1871             isdyn = 1;
1872             break;
1873           default:
1874             break;
1875           }
1876       else if (CONST_STRNEQ (secname, ".rel"))
1877         {
1878           secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1879           isdyn = 1;
1880         }
1881     }
1882
1883   /* Look through the script to see where to place this section.  */
1884   if (constraint == 0)
1885     for (os = lang_output_section_find (secname);
1886          os != NULL;
1887          os = next_matching_output_section_statement (os, 0))
1888       {
1889         /* If we don't match an existing output section, tell
1890            lang_insert_orphan to create a new output section.  */
1891         constraint = SPECIAL;
1892
1893         if (os->bfd_section != NULL
1894             && (os->bfd_section->flags == 0
1895                 || (_bfd_elf_match_sections_by_type (link_info.output_bfd,
1896                                                      os->bfd_section,
1897                                                      s->owner, s)
1898                     && ((s->flags ^ os->bfd_section->flags)
1899                         & (SEC_LOAD | SEC_ALLOC)) == 0)))
1900           {
1901             /* We already have an output section statement with this
1902                name, and its bfd section has compatible flags.
1903                If the section already exists but does not have any flags
1904                set, then it has been created by the linker, probably as a
1905                result of a --section-start command line switch.  */
1906             lang_add_section (&os->children, s, NULL, os);
1907             return os;
1908           }
1909
1910         /* Save unused output sections in case we can match them
1911            against orphans later.  */
1912         if (os->bfd_section == NULL)
1913           match_by_name = os;
1914       }
1915
1916   /* If we didn't match an active output section, see if we matched an
1917      unused one and use that.  */
1918   if (match_by_name)
1919     {
1920       lang_add_section (&match_by_name->children, s, NULL, match_by_name);
1921       return match_by_name;
1922     }
1923
1924   if (!orphan_init_done)
1925     {
1926       struct orphan_save *ho;
1927
1928       for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1929         if (ho->name != NULL)
1930           {
1931             ho->os = lang_output_section_find (ho->name);
1932             if (ho->os != NULL && ho->os->flags == 0)
1933               ho->os->flags = ho->flags;
1934           }
1935       orphan_init_done = 1;
1936     }
1937
1938   /* If this is a final link, then always put .gnu.warning.SYMBOL
1939      sections into the .text section to get them out of the way.  */
1940   if (link_info.executable
1941       && ! link_info.relocatable
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   /* Decide which segment the section should go in based on the
1951      section name and section flags.  We put loadable .note sections
1952      right after the .interp section, so that the PT_NOTE segment is
1953      stored right after the program headers where the OS can read it
1954      in the first page.  */
1955
1956   place = NULL;
1957   if ((s->flags & (SEC_ALLOC | SEC_DEBUGGING)) == 0)
1958     place = &hold[orphan_nonalloc];
1959   else if ((s->flags & SEC_ALLOC) == 0)
1960     ;
1961   else if ((s->flags & SEC_LOAD) != 0
1962            && ((iself && sh_type == SHT_NOTE)
1963                || (!iself && CONST_STRNEQ (secname, ".note"))))
1964     place = &hold[orphan_interp];
1965   else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) == 0)
1966     place = &hold[orphan_bss];
1967   else if ((s->flags & SEC_SMALL_DATA) != 0)
1968     place = &hold[orphan_sdata];
1969   else if ((s->flags & SEC_THREAD_LOCAL) != 0)
1970     place = &hold[orphan_tdata];
1971   else if ((s->flags & SEC_READONLY) == 0)
1972     place = &hold[orphan_data];
1973   else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
1974             || (!iself && CONST_STRNEQ (secname, ".rel")))
1975            && (s->flags & SEC_LOAD) != 0)
1976     place = &hold[orphan_rel];
1977   else if ((s->flags & SEC_CODE) == 0)
1978     place = &hold[orphan_rodata];
1979   else
1980     place = &hold[orphan_text];
1981
1982   after = NULL;
1983   if (place != NULL)
1984     {
1985       if (place->os == NULL)
1986         {
1987           if (place->name != NULL)
1988             place->os = lang_output_section_find (place->name);
1989           else
1990             place->os = output_rel_find (s, isdyn);
1991         }
1992       after = place->os;
1993       if (after == NULL)
1994         after = lang_output_section_find_by_flags
1995           (s, &place->os, _bfd_elf_match_sections_by_type);
1996       if (after == NULL)
1997         /* *ABS* is always the first output section statement.  */
1998         after = &lang_output_section_statement.head->output_section_statement;
1999     }
2000
2001   return lang_insert_orphan (s, secname, constraint, after, place, NULL, NULL);
2002 }
2003 EOF
2004 fi
2005
2006 if test x"$LDEMUL_AFTER_ALLOCATION" != xgld"$EMULATION_NAME"_after_allocation; then
2007 fragment <<EOF
2008
2009 static void
2010 gld${EMULATION_NAME}_after_allocation (void)
2011 {
2012   bfd_boolean need_layout = bfd_elf_discard_info (link_info.output_bfd,
2013                                                   &link_info);
2014   gld${EMULATION_NAME}_map_segments (need_layout);
2015 }
2016 EOF
2017 fi
2018
2019 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
2020 fragment <<EOF
2021
2022 static char *
2023 gld${EMULATION_NAME}_get_script (int *isfile)
2024 EOF
2025
2026 if test x"$COMPILE_IN" = xyes
2027 then
2028 # Scripts compiled in.
2029
2030 # sed commands to quote an ld script as a C string.
2031 sc="-f stringify.sed"
2032
2033 fragment <<EOF
2034 {
2035   *isfile = 0;
2036
2037   if (link_info.relocatable && config.build_constructors)
2038     return
2039 EOF
2040 sed $sc ldscripts/${EMULATION_NAME}.xu                  >> e${EMULATION_NAME}.c
2041 echo '  ; else if (link_info.relocatable) return'       >> e${EMULATION_NAME}.c
2042 sed $sc ldscripts/${EMULATION_NAME}.xr                  >> e${EMULATION_NAME}.c
2043 echo '  ; else if (!config.text_read_only) return'      >> e${EMULATION_NAME}.c
2044 sed $sc ldscripts/${EMULATION_NAME}.xbn                 >> e${EMULATION_NAME}.c
2045 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
2046 echo '  ; else if (!config.magic_demand_paged) return'  >> e${EMULATION_NAME}.c
2047 sed $sc ldscripts/${EMULATION_NAME}.xn                  >> e${EMULATION_NAME}.c
2048 fi
2049 if test -n "$GENERATE_PIE_SCRIPT" ; then
2050 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2051 echo '  ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
2052 echo '             && link_info.relro' >> e${EMULATION_NAME}.c
2053 echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2054 sed $sc ldscripts/${EMULATION_NAME}.xdw                 >> e${EMULATION_NAME}.c
2055 echo '  ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
2056 sed $sc ldscripts/${EMULATION_NAME}.xdc                 >> e${EMULATION_NAME}.c
2057 fi
2058 echo '  ; else if (link_info.pie) return'               >> e${EMULATION_NAME}.c
2059 sed $sc ldscripts/${EMULATION_NAME}.xd                  >> e${EMULATION_NAME}.c
2060 fi
2061 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
2062 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2063 echo '  ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
2064 echo '             && link_info.relro' >> e${EMULATION_NAME}.c
2065 echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2066 sed $sc ldscripts/${EMULATION_NAME}.xsw                 >> e${EMULATION_NAME}.c
2067 echo '  ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
2068 sed $sc ldscripts/${EMULATION_NAME}.xsc                 >> e${EMULATION_NAME}.c
2069 fi
2070 echo '  ; else if (link_info.shared) return'            >> e${EMULATION_NAME}.c
2071 sed $sc ldscripts/${EMULATION_NAME}.xs                  >> e${EMULATION_NAME}.c
2072 fi
2073 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2074 echo '  ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
2075 echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2076 sed $sc ldscripts/${EMULATION_NAME}.xw                  >> e${EMULATION_NAME}.c
2077 echo '  ; else if (link_info.combreloc) return'         >> e${EMULATION_NAME}.c
2078 sed $sc ldscripts/${EMULATION_NAME}.xc                  >> e${EMULATION_NAME}.c
2079 fi
2080 echo '  ; else return'                                  >> e${EMULATION_NAME}.c
2081 sed $sc ldscripts/${EMULATION_NAME}.x                   >> e${EMULATION_NAME}.c
2082 echo '; }'                                              >> e${EMULATION_NAME}.c
2083
2084 else
2085 # Scripts read from the filesystem.
2086
2087 fragment <<EOF
2088 {
2089   *isfile = 1;
2090
2091   if (link_info.relocatable && config.build_constructors)
2092     return "ldscripts/${EMULATION_NAME}.xu";
2093   else if (link_info.relocatable)
2094     return "ldscripts/${EMULATION_NAME}.xr";
2095   else if (!config.text_read_only)
2096     return "ldscripts/${EMULATION_NAME}.xbn";
2097 EOF
2098 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
2099 else
2100 fragment <<EOF
2101   else if (!config.magic_demand_paged)
2102     return "ldscripts/${EMULATION_NAME}.xn";
2103 EOF
2104 fi
2105 if test -n "$GENERATE_PIE_SCRIPT" ; then
2106 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2107 fragment <<EOF
2108   else if (link_info.pie && link_info.combreloc
2109            && link_info.relro && (link_info.flags & DF_BIND_NOW))
2110     return "ldscripts/${EMULATION_NAME}.xdw";
2111   else if (link_info.pie && link_info.combreloc)
2112     return "ldscripts/${EMULATION_NAME}.xdc";
2113 EOF
2114 fi
2115 fragment <<EOF
2116   else if (link_info.pie)
2117     return "ldscripts/${EMULATION_NAME}.xd";
2118 EOF
2119 fi
2120 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
2121 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2122 fragment <<EOF
2123   else if (link_info.shared && link_info.combreloc
2124            && link_info.relro && (link_info.flags & DF_BIND_NOW))
2125     return "ldscripts/${EMULATION_NAME}.xsw";
2126   else if (link_info.shared && link_info.combreloc)
2127     return "ldscripts/${EMULATION_NAME}.xsc";
2128 EOF
2129 fi
2130 fragment <<EOF
2131   else if (link_info.shared)
2132     return "ldscripts/${EMULATION_NAME}.xs";
2133 EOF
2134 fi
2135 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2136 fragment <<EOF
2137   else if (link_info.combreloc && link_info.relro
2138            && (link_info.flags & DF_BIND_NOW))
2139     return "ldscripts/${EMULATION_NAME}.xw";
2140   else if (link_info.combreloc)
2141     return "ldscripts/${EMULATION_NAME}.xc";
2142 EOF
2143 fi
2144 fragment <<EOF
2145   else
2146     return "ldscripts/${EMULATION_NAME}.x";
2147 }
2148
2149 EOF
2150 fi
2151 fi
2152
2153 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
2154 fragment <<EOF
2155  $PARSE_AND_LIST_PROLOGUE
2156 EOF
2157 fi
2158
2159 fragment <<EOF
2160
2161 #define OPTION_DISABLE_NEW_DTAGS        (400)
2162 #define OPTION_ENABLE_NEW_DTAGS         (OPTION_DISABLE_NEW_DTAGS + 1)
2163 #define OPTION_GROUP                    (OPTION_ENABLE_NEW_DTAGS + 1)
2164 #define OPTION_EH_FRAME_HDR             (OPTION_GROUP + 1)
2165 #define OPTION_EXCLUDE_LIBS             (OPTION_EH_FRAME_HDR + 1)
2166 #define OPTION_HASH_STYLE               (OPTION_EXCLUDE_LIBS + 1)
2167 #define OPTION_BUILD_ID                 (OPTION_HASH_STYLE + 1)
2168 #define OPTION_AUDIT                    (OPTION_BUILD_ID + 1)
2169
2170 static void
2171 gld${EMULATION_NAME}_add_options
2172   (int ns, char **shortopts, int nl, struct option **longopts,
2173    int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
2174 {
2175 EOF
2176 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2177 fragment <<EOF
2178   static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:P:";
2179 EOF
2180 else
2181 fragment <<EOF
2182   static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
2183 EOF
2184 fi
2185 fragment <<EOF
2186   static const struct option xtra_long[] = {
2187 EOF
2188 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2189 fragment <<EOF
2190     {"audit", required_argument, NULL, OPTION_AUDIT},
2191     {"Bgroup", no_argument, NULL, OPTION_GROUP},
2192 EOF
2193 fi
2194 fragment <<EOF
2195     {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
2196 EOF
2197 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2198 fragment <<EOF
2199     {"depaudit", required_argument, NULL, 'P'},
2200     {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
2201     {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
2202     {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
2203     {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
2204     {"hash-style", required_argument, NULL, OPTION_HASH_STYLE},
2205 EOF
2206 fi
2207 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
2208 fragment <<EOF
2209     $PARSE_AND_LIST_LONGOPTS
2210 EOF
2211 fi
2212 fragment <<EOF
2213     {NULL, no_argument, NULL, 0}
2214   };
2215
2216   *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
2217   memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
2218   *longopts = (struct option *)
2219     xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
2220   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
2221 }
2222
2223 #define DEFAULT_BUILD_ID_STYLE  "sha1"
2224
2225 static bfd_boolean
2226 gld${EMULATION_NAME}_handle_option (int optc)
2227 {
2228   switch (optc)
2229     {
2230     default:
2231       return FALSE;
2232
2233     case OPTION_BUILD_ID:
2234       if (emit_note_gnu_build_id != NULL)
2235         {
2236           free ((char *) emit_note_gnu_build_id);
2237           emit_note_gnu_build_id = NULL;
2238         }
2239       if (optarg == NULL)
2240         optarg = DEFAULT_BUILD_ID_STYLE;
2241       if (strcmp (optarg, "none"))
2242         emit_note_gnu_build_id = xstrdup (optarg);
2243       break;
2244
2245 EOF
2246
2247 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2248 fragment <<EOF
2249     case OPTION_AUDIT:
2250         gld${EMULATION_NAME}_append_to_separated_string (&audit, optarg);
2251         break;
2252
2253     case 'P':
2254         gld${EMULATION_NAME}_append_to_separated_string (&depaudit, optarg);
2255         break;
2256
2257     case OPTION_DISABLE_NEW_DTAGS:
2258       link_info.new_dtags = FALSE;
2259       break;
2260
2261     case OPTION_ENABLE_NEW_DTAGS:
2262       link_info.new_dtags = TRUE;
2263       break;
2264
2265     case OPTION_EH_FRAME_HDR:
2266       link_info.eh_frame_hdr = TRUE;
2267       break;
2268
2269     case OPTION_GROUP:
2270       link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
2271       /* Groups must be self-contained.  */
2272       link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2273       link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
2274       break;
2275
2276     case OPTION_EXCLUDE_LIBS:
2277       add_excluded_libs (optarg);
2278       break;
2279
2280     case OPTION_HASH_STYLE:
2281       link_info.emit_hash = FALSE;
2282       link_info.emit_gnu_hash = FALSE;
2283       if (strcmp (optarg, "sysv") == 0)
2284         link_info.emit_hash = TRUE;
2285       else if (strcmp (optarg, "gnu") == 0)
2286         link_info.emit_gnu_hash = TRUE;
2287       else if (strcmp (optarg, "both") == 0)
2288         {
2289           link_info.emit_hash = TRUE;
2290           link_info.emit_gnu_hash = TRUE;
2291         }
2292       else
2293         einfo (_("%P%F: invalid hash style \`%s'\n"), optarg);
2294       break;
2295
2296 EOF
2297 fi
2298 fragment <<EOF
2299     case 'z':
2300       if (strcmp (optarg, "defs") == 0)
2301         link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2302       else if (strcmp (optarg, "muldefs") == 0)
2303         link_info.allow_multiple_definition = TRUE;
2304       else if (CONST_STRNEQ (optarg, "max-page-size="))
2305         {
2306           char *end;
2307
2308           config.maxpagesize = strtoul (optarg + 14, &end, 0);
2309           if (*end || (config.maxpagesize & (config.maxpagesize - 1)) != 0)
2310             einfo (_("%P%F: invalid maxium page size \`%s'\n"),
2311                    optarg + 14);
2312         }
2313       else if (CONST_STRNEQ (optarg, "common-page-size="))
2314         {
2315           char *end;
2316           config.commonpagesize = strtoul (optarg + 17, &end, 0);
2317           if (*end
2318               || (config.commonpagesize & (config.commonpagesize - 1)) != 0)
2319             einfo (_("%P%F: invalid common page size \`%s'\n"),
2320                    optarg + 17);
2321         }
2322       else if (CONST_STRNEQ (optarg, "stack-size="))
2323         {
2324           char *end;
2325           link_info.stacksize = strtoul (optarg + 11, &end, 0);
2326           if (*end || link_info.stacksize < 0)
2327             einfo (_("%P%F: invalid stack size \`%s'\n"), optarg + 11);
2328           if (!link_info.stacksize)
2329             /* Use -1 for explicit no-stack, because zero means
2330                'default'.   */
2331             link_info.stacksize = -1;
2332         }
2333       else if (strcmp (optarg, "execstack") == 0)
2334         {
2335           link_info.execstack = TRUE;
2336           link_info.noexecstack = FALSE;
2337         }
2338       else if (strcmp (optarg, "noexecstack") == 0)
2339         {
2340           link_info.noexecstack = TRUE;
2341           link_info.execstack = FALSE;
2342         }
2343 EOF
2344 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2345 fragment <<EOF
2346       else if (strcmp (optarg, "global") == 0)
2347         link_info.flags_1 |= (bfd_vma) DF_1_GLOBAL;
2348       else if (strcmp (optarg, "initfirst") == 0)
2349         link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
2350       else if (strcmp (optarg, "interpose") == 0)
2351         link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
2352       else if (strcmp (optarg, "loadfltr") == 0)
2353         link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
2354       else if (strcmp (optarg, "nodefaultlib") == 0)
2355         link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
2356       else if (strcmp (optarg, "nodelete") == 0)
2357         link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
2358       else if (strcmp (optarg, "nodlopen") == 0)
2359         link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
2360       else if (strcmp (optarg, "nodump") == 0)
2361         link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
2362       else if (strcmp (optarg, "now") == 0)
2363         {
2364           link_info.flags |= (bfd_vma) DF_BIND_NOW;
2365           link_info.flags_1 |= (bfd_vma) DF_1_NOW;
2366         }
2367       else if (strcmp (optarg, "lazy") == 0)
2368         {
2369           link_info.flags &= ~(bfd_vma) DF_BIND_NOW;
2370           link_info.flags_1 &= ~(bfd_vma) DF_1_NOW;
2371         }
2372       else if (strcmp (optarg, "origin") == 0)
2373         {
2374           link_info.flags |= (bfd_vma) DF_ORIGIN;
2375           link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
2376         }
2377       else if (strcmp (optarg, "combreloc") == 0)
2378         link_info.combreloc = TRUE;
2379       else if (strcmp (optarg, "nocombreloc") == 0)
2380         link_info.combreloc = FALSE;
2381       else if (strcmp (optarg, "nocopyreloc") == 0)
2382         link_info.nocopyreloc = TRUE;
2383       else if (strcmp (optarg, "relro") == 0)
2384         link_info.relro = TRUE;
2385       else if (strcmp (optarg, "norelro") == 0)
2386         link_info.relro = FALSE;
2387       else if (strcmp (optarg, "text") == 0)
2388         link_info.error_textrel = TRUE;
2389       else if (strcmp (optarg, "notext") == 0)
2390         link_info.error_textrel = FALSE;
2391       else if (strcmp (optarg, "textoff") == 0)
2392         link_info.error_textrel = FALSE;
2393 EOF
2394 fi
2395
2396 fragment <<EOF
2397       else
2398         einfo (_("%P: warning: -z %s ignored.\n"), optarg);
2399       break;
2400 EOF
2401
2402 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
2403 fragment <<EOF
2404  $PARSE_AND_LIST_ARGS_CASES
2405 EOF
2406 fi
2407
2408 fragment <<EOF
2409     }
2410
2411   return TRUE;
2412 }
2413
2414 EOF
2415
2416 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2417 fragment <<EOF
2418
2419 static void
2420 gld${EMULATION_NAME}_list_options (FILE * file)
2421 {
2422 EOF
2423 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2424 fragment <<EOF
2425   fprintf (file, _("\
2426   --audit=AUDITLIB            Specify a library to use for auditing\n"));
2427   fprintf (file, _("\
2428   -Bgroup                     Selects group name lookup rules for DSO\n"));
2429 EOF
2430 fi
2431 fragment <<EOF
2432   fprintf (file, _("\
2433   --build-id[=STYLE]          Generate build ID note\n"));
2434 EOF
2435 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2436 fragment <<EOF
2437   fprintf (file, _("\
2438   -P AUDITLIB, --depaudit=AUDITLIB\n" "\
2439                               Specify a library to use for auditing dependencies\n"));
2440   fprintf (file, _("\
2441   --disable-new-dtags         Disable new dynamic tags\n"));
2442   fprintf (file, _("\
2443   --enable-new-dtags          Enable new dynamic tags\n"));
2444   fprintf (file, _("\
2445   --eh-frame-hdr              Create .eh_frame_hdr section\n"));
2446   fprintf (file, _("\
2447   --exclude-libs=LIBS         Make all symbols in LIBS hidden\n"));
2448   fprintf (file, _("\
2449   --hash-style=STYLE          Set hash style to sysv, gnu or both\n"));
2450   fprintf (file, _("\
2451   -z combreloc                Merge dynamic relocs into one section and sort\n"));
2452 EOF
2453 fi
2454
2455 fragment <<EOF
2456   fprintf (file, _("\
2457   -z common-page-size=SIZE    Set common page size to SIZE\n"));
2458   fprintf (file, _("\
2459   -z defs                     Report unresolved symbols in object files.\n"));
2460   fprintf (file, _("\
2461   -z execstack                Mark executable as requiring executable stack\n"));
2462 EOF
2463
2464 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2465 fragment <<EOF
2466   fprintf (file, _("\
2467   -z global                   Make symbols in DSO available for subsequently\n\
2468                                loaded objects\n"));
2469   fprintf (file, _("\
2470   -z initfirst                Mark DSO to be initialized first at runtime\n"));
2471   fprintf (file, _("\
2472   -z interpose                Mark object to interpose all DSOs but executable\n"));
2473   fprintf (file, _("\
2474   -z lazy                     Mark object lazy runtime binding (default)\n"));
2475   fprintf (file, _("\
2476   -z loadfltr                 Mark object requiring immediate process\n"));
2477 EOF
2478 fi
2479
2480 fragment <<EOF
2481   fprintf (file, _("\
2482   -z max-page-size=SIZE       Set maximum page size to SIZE\n"));
2483   fprintf (file, _("\
2484   -z muldefs                  Allow multiple definitions\n"));
2485 EOF
2486
2487 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2488 fragment <<EOF
2489   fprintf (file, _("\
2490   -z nocombreloc              Don't merge dynamic relocs into one section\n"));
2491   fprintf (file, _("\
2492   -z nocopyreloc              Don't create copy relocs\n"));
2493   fprintf (file, _("\
2494   -z nodefaultlib             Mark object not to use default search paths\n"));
2495   fprintf (file, _("\
2496   -z nodelete                 Mark DSO non-deletable at runtime\n"));
2497   fprintf (file, _("\
2498   -z nodlopen                 Mark DSO not available to dlopen\n"));
2499   fprintf (file, _("\
2500   -z nodump                   Mark DSO not available to dldump\n"));
2501 EOF
2502 fi
2503 fragment <<EOF
2504   fprintf (file, _("\
2505   -z noexecstack              Mark executable as not requiring executable stack\n"));
2506 EOF
2507 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2508 fragment <<EOF
2509   fprintf (file, _("\
2510   -z norelro                  Don't create RELRO program header\n"));
2511   fprintf (file, _("\
2512   -z now                      Mark object non-lazy runtime binding\n"));
2513   fprintf (file, _("\
2514   -z origin                   Mark object requiring immediate \$ORIGIN\n\
2515                                 processing at runtime\n"));
2516   fprintf (file, _("\
2517   -z relro                    Create RELRO program header\n"));
2518   fprintf (file, _("\
2519   -z stacksize=SIZE           Set size of stack segment\n"));
2520 EOF
2521 fi
2522
2523 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
2524 fragment <<EOF
2525  $PARSE_AND_LIST_OPTIONS
2526 EOF
2527 fi
2528
2529 fragment <<EOF
2530 }
2531 EOF
2532
2533 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
2534 fragment <<EOF
2535  $PARSE_AND_LIST_EPILOGUE
2536 EOF
2537 fi
2538 fi
2539
2540 fragment <<EOF
2541
2542 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
2543 {
2544   ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
2545   ${LDEMUL_SYSLIB-syslib_default},
2546   ${LDEMUL_HLL-hll_default},
2547   ${LDEMUL_AFTER_PARSE-after_parse_default},
2548   ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
2549   ${LDEMUL_AFTER_ALLOCATION-gld${EMULATION_NAME}_after_allocation},
2550   ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
2551   ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
2552   ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
2553   ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
2554   "${EMULATION_NAME}",
2555   "${OUTPUT_FORMAT}",
2556   ${LDEMUL_FINISH-finish_default},
2557   ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
2558   ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
2559   ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
2560   ${LDEMUL_SET_SYMBOLS-NULL},
2561   ${LDEMUL_PARSE_ARGS-NULL},
2562   gld${EMULATION_NAME}_add_options,
2563   gld${EMULATION_NAME}_handle_option,
2564   ${LDEMUL_UNRECOGNIZED_FILE-NULL},
2565   ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
2566   ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
2567   ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
2568   ${LDEMUL_NEW_VERS_PATTERN-NULL}
2569 };
2570 EOF