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