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