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           s = bfd_make_section_with_flags (abfd, ".eh_frame_hdr",
1138                                            bed->dynamic_sec_flags
1139                                            | SEC_READONLY);
1140           if (s != NULL
1141               && bfd_set_section_alignment (abfd, s, 2))
1142             htab->eh_info.hdr_sec = s;
1143           else
1144             einfo ("%P: warning: Cannot create .eh_frame_hdr section,"
1145                    " --eh-frame-hdr ignored.\n");
1146         }
1147     }
1148
1149   /* Get the list of files which appear in DT_NEEDED entries in
1150      dynamic objects included in the link (often there will be none).
1151      For each such file, we want to track down the corresponding
1152      library, and include the symbol table in the link.  This is what
1153      the runtime dynamic linker will do.  Tracking the files down here
1154      permits one dynamic object to include another without requiring
1155      special action by the person doing the link.  Note that the
1156      needed list can actually grow while we are stepping through this
1157      loop.  */
1158   if (!link_info.executable)
1159     return;
1160   needed = bfd_elf_get_needed_list (link_info.output_bfd, &link_info);
1161   for (l = needed; l != NULL; l = l->next)
1162     {
1163       struct bfd_link_needed_list *ll;
1164       struct dt_needed n, nn;
1165       int force;
1166
1167       /* If the lib that needs this one was --as-needed and wasn't
1168          found to be needed, then this lib isn't needed either.  */
1169       if (l->by != NULL
1170           && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
1171         continue;
1172
1173       /* If we've already seen this file, skip it.  */
1174       for (ll = needed; ll != l; ll = ll->next)
1175         if ((ll->by == NULL
1176              || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
1177             && strcmp (ll->name, l->name) == 0)
1178           break;
1179       if (ll != l)
1180         continue;
1181
1182       /* See if this file was included in the link explicitly.  */
1183       global_needed = l;
1184       global_found = NULL;
1185       lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
1186       if (global_found != NULL
1187           && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
1188               & DYN_AS_NEEDED) == 0)
1189         continue;
1190
1191       n.by = l->by;
1192       n.name = l->name;
1193       nn.by = l->by;
1194       if (trace_file_tries)
1195         info_msg (_("%s needed by %B\n"), l->name, l->by);
1196
1197       /* As-needed libs specified on the command line (or linker script)
1198          take priority over libs found in search dirs.  */
1199       if (global_found != NULL)
1200         {
1201           nn.name = global_found->filename;
1202           if (gld${EMULATION_NAME}_try_needed (&nn, TRUE))
1203             continue;
1204         }
1205
1206       /* We need to find this file and include the symbol table.  We
1207          want to search for the file in the same way that the dynamic
1208          linker will search.  That means that we want to use
1209          rpath_link, rpath, then the environment variable
1210          LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
1211          entries (native only), then the linker script LIB_SEARCH_DIRS.
1212          We do not search using the -L arguments.
1213
1214          We search twice.  The first time, we skip objects which may
1215          introduce version mismatches.  The second time, we force
1216          their use.  See gld${EMULATION_NAME}_vercheck comment.  */
1217       for (force = 0; force < 2; force++)
1218         {
1219           size_t len;
1220           search_dirs_type *search;
1221 EOF
1222 if [ "x${NATIVE}" = xyes ] ; then
1223 fragment <<EOF
1224           const char *lib_path;
1225 EOF
1226 fi
1227 if [ "x${USE_LIBPATH}" = xyes ] ; then
1228 fragment <<EOF
1229           struct bfd_link_needed_list *rp;
1230           int found;
1231 EOF
1232 fi
1233 fragment <<EOF
1234
1235           if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
1236                                                   &n, force))
1237             break;
1238 EOF
1239 if [ "x${USE_LIBPATH}" = xyes ] ; then
1240 fragment <<EOF
1241           if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
1242                                                   &n, force))
1243             break;
1244 EOF
1245 fi
1246 if [ "x${NATIVE}" = xyes ] ; then
1247 fragment <<EOF
1248           if (command_line.rpath_link == NULL
1249               && command_line.rpath == NULL)
1250             {
1251               lib_path = (const char *) getenv ("LD_RUN_PATH");
1252               if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
1253                                                       force))
1254                 break;
1255             }
1256           lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
1257           if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
1258             break;
1259 EOF
1260 fi
1261 if [ "x${USE_LIBPATH}" = xyes ] ; then
1262 fragment <<EOF
1263           found = 0;
1264           rp = bfd_elf_get_runpath_list (link_info.output_bfd, &link_info);
1265           for (; !found && rp != NULL; rp = rp->next)
1266             {
1267               char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
1268               found = (rp->by == l->by
1269                        && gld${EMULATION_NAME}_search_needed (tmpname,
1270                                                               &n,
1271                                                               force));
1272               free (tmpname);
1273             }
1274           if (found)
1275             break;
1276
1277 EOF
1278 fi
1279 if [ "x${USE_LIBPATH}" = xyes ] ; then
1280   case ${target} in
1281     *-*-freebsd* | *-*-dragonfly*)
1282       fragment <<EOF
1283           if (gld${EMULATION_NAME}_check_ld_elf_hints (l->name, force))
1284             break;
1285 EOF
1286     # FreeBSD
1287     ;;
1288
1289     *-*-linux-* | *-*-k*bsd*-*)
1290     # Linux
1291       fragment <<EOF
1292           if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
1293             break;
1294
1295 EOF
1296     ;;
1297   esac
1298 fi
1299 fragment <<EOF
1300           len = strlen (l->name);
1301           for (search = search_head; search != NULL; search = search->next)
1302             {
1303               char *filename;
1304
1305               if (search->cmdline)
1306                 continue;
1307               filename = (char *) xmalloc (strlen (search->name) + len + 2);
1308               sprintf (filename, "%s/%s", search->name, l->name);
1309               nn.name = filename;
1310               if (gld${EMULATION_NAME}_try_needed (&nn, force))
1311                 break;
1312               free (filename);
1313             }
1314           if (search != NULL)
1315             break;
1316 EOF
1317 fragment <<EOF
1318         }
1319
1320       if (force < 2)
1321         continue;
1322
1323       einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
1324              l->name, l->by);
1325     }
1326 }
1327
1328 EOF
1329 fi
1330
1331 fragment <<EOF
1332
1333 /* Look through an expression for an assignment statement.  */
1334
1335 static void
1336 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1337 {
1338   bfd_boolean provide = FALSE;
1339
1340   switch (exp->type.node_class)
1341     {
1342     case etree_provide:
1343     case etree_provided:
1344       provide = TRUE;
1345       /* Fall thru */
1346     case etree_assign:
1347       /* We call record_link_assignment even if the symbol is defined.
1348          This is because if it is defined by a dynamic object, we
1349          actually want to use the value defined by the linker script,
1350          not the value from the dynamic object (because we are setting
1351          symbols like etext).  If the symbol is defined by a regular
1352          object, then, as it happens, calling record_link_assignment
1353          will do no harm.  */
1354       if (strcmp (exp->assign.dst, ".") != 0)
1355         {
1356           if (!bfd_elf_record_link_assignment (link_info.output_bfd,
1357                                                &link_info,
1358                                                exp->assign.dst, provide,
1359                                                exp->assign.hidden))
1360             einfo ("%P%F: failed to record assignment to %s: %E\n",
1361                    exp->assign.dst);
1362         }
1363       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1364       break;
1365
1366     case etree_binary:
1367       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1368       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1369       break;
1370
1371     case etree_trinary:
1372       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1373       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1374       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1375       break;
1376
1377     case etree_unary:
1378       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1379       break;
1380
1381     default:
1382       break;
1383     }
1384 }
1385
1386
1387 /* This is called by the before_allocation routine via
1388    lang_for_each_statement.  It locates any assignment statements, and
1389    tells the ELF backend about them, in case they are assignments to
1390    symbols which are referred to by dynamic objects.  */
1391
1392 static void
1393 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1394 {
1395   if (s->header.type == lang_assignment_statement_enum)
1396     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1397 }
1398
1399 EOF
1400
1401 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1402   if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1403     ELF_INTERPRETER_SET_DEFAULT="
1404   if (sinterp != NULL)
1405     {
1406       sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1407       sinterp->size = strlen ((char *) sinterp->contents) + 1;
1408     }
1409
1410 "
1411   else
1412     ELF_INTERPRETER_SET_DEFAULT=
1413   fi
1414 fragment <<EOF
1415
1416 /* used by before_allocation and handle_option. */
1417 static void
1418 gld${EMULATION_NAME}_append_to_separated_string (char **to, char *op_arg)
1419 {
1420   if (*to == NULL)
1421     *to = xstrdup (op_arg);
1422   else
1423     {
1424       size_t to_len = strlen (*to);
1425       size_t op_arg_len = strlen (op_arg);
1426       char *buf;
1427       char *cp = *to;
1428
1429       /* First see whether OPTARG is already in the path.  */
1430       do
1431         {
1432           if (strncmp (op_arg, cp, op_arg_len) == 0
1433               && (cp[op_arg_len] == 0
1434                   || cp[op_arg_len] == config.rpath_separator))
1435             /* We found it.  */
1436             break;
1437
1438           /* Not yet found.  */
1439           cp = strchr (cp, config.rpath_separator);
1440           if (cp != NULL)
1441             ++cp;
1442         }
1443       while (cp != NULL);
1444
1445       if (cp == NULL)
1446         {
1447           buf = xmalloc (to_len + op_arg_len + 2);
1448           sprintf (buf, "%s%c%s", *to,
1449                    config.rpath_separator, op_arg);
1450           free (*to);
1451           *to = buf;
1452         }
1453     }
1454 }
1455
1456 /* This is called after the sections have been attached to output
1457    sections, but before any sizes or addresses have been set.  */
1458
1459 static void
1460 gld${EMULATION_NAME}_before_allocation (void)
1461 {
1462   const char *rpath;
1463   asection *sinterp;
1464   bfd *abfd;
1465
1466   if (link_info.hash->type == bfd_link_elf_hash_table)
1467     _bfd_elf_tls_setup (link_info.output_bfd, &link_info);
1468
1469   /* If we are going to make any variable assignments, we need to let
1470      the ELF backend know about them in case the variables are
1471      referred to by dynamic objects.  */
1472   lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1473
1474   /* Let the ELF backend work out the sizes of any sections required
1475      by dynamic linking.  */
1476   rpath = command_line.rpath;
1477   if (rpath == NULL)
1478     rpath = (const char *) getenv ("LD_RUN_PATH");
1479
1480   for (abfd = link_info.input_bfds; abfd; abfd = abfd->link_next)
1481     {
1482       const char *audit_libs = elf_dt_audit (abfd);
1483
1484       /* If the input bfd contains an audit entry, we need to add it as
1485          a dep audit entry.  */
1486       if (audit_libs && *audit_libs != '\0')
1487         {
1488           char *cp = xstrdup (audit_libs);
1489           do
1490             {
1491               int more = 0;
1492               char *cp2 = strchr (cp, config.rpath_separator);
1493
1494               if (cp2)
1495                 {
1496                   *cp2 = '\0';
1497                   more = 1;
1498                 }
1499
1500               if (cp != NULL && *cp != '\0')
1501                 gld${EMULATION_NAME}_append_to_separated_string (&depaudit, cp);
1502
1503               cp = more ? ++cp2 : NULL;
1504             }
1505           while (cp != NULL);
1506         }
1507     }
1508
1509   if (! (bfd_elf_size_dynamic_sections
1510          (link_info.output_bfd, command_line.soname, rpath,
1511           command_line.filter_shlib, audit, depaudit,
1512           (const char * const *) command_line.auxiliary_filters,
1513           &link_info, &sinterp, lang_elf_version_info)))
1514     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1515
1516 ${ELF_INTERPRETER_SET_DEFAULT}
1517   /* Let the user override the dynamic linker we are using.  */
1518   if (command_line.interpreter != NULL
1519       && sinterp != NULL)
1520     {
1521       sinterp->contents = (bfd_byte *) command_line.interpreter;
1522       sinterp->size = strlen (command_line.interpreter) + 1;
1523     }
1524
1525   /* Look for any sections named .gnu.warning.  As a GNU extensions,
1526      we treat such sections as containing warning messages.  We print
1527      out the warning message, and then zero out the section size so
1528      that it does not get copied into the output file.  */
1529
1530   {
1531     LANG_FOR_EACH_INPUT_STATEMENT (is)
1532       {
1533         asection *s;
1534         bfd_size_type sz;
1535         char *msg;
1536         bfd_boolean ret;
1537
1538         if (is->just_syms_flag)
1539           continue;
1540
1541         s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1542         if (s == NULL)
1543           continue;
1544
1545         sz = s->size;
1546         msg = (char *) xmalloc ((size_t) (sz + 1));
1547         if (! bfd_get_section_contents (is->the_bfd, s, msg,
1548                                         (file_ptr) 0, sz))
1549           einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1550                  is->the_bfd);
1551         msg[sz] = '\0';
1552         ret = link_info.callbacks->warning (&link_info, msg,
1553                                             (const char *) NULL,
1554                                             is->the_bfd, (asection *) NULL,
1555                                             (bfd_vma) 0);
1556         ASSERT (ret);
1557         free (msg);
1558
1559         /* Clobber the section size, so that we don't waste space
1560            copying the warning into the output file.  If we've already
1561            sized the output section, adjust its size.  The adjustment
1562            is on rawsize because targets that size sections early will
1563            have called lang_reset_memory_regions after sizing.  */
1564         if (s->output_section != NULL
1565             && s->output_section->rawsize >= s->size)
1566           s->output_section->rawsize -= s->size;
1567
1568         s->size = 0;
1569
1570         /* Also set SEC_EXCLUDE, so that local symbols defined in the
1571            warning section don't get copied to the output.  */
1572         s->flags |= SEC_EXCLUDE | SEC_KEEP;
1573       }
1574   }
1575
1576   before_allocation_default ();
1577
1578   if (!bfd_elf_size_dynsym_hash_dynstr (link_info.output_bfd, &link_info))
1579     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1580 }
1581
1582 EOF
1583 fi
1584
1585 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1586 fragment <<EOF
1587
1588 /* Try to open a dynamic archive.  This is where we know that ELF
1589    dynamic libraries have an extension of .so (or .sl on oddball systems
1590    like hpux).  */
1591
1592 static bfd_boolean
1593 gld${EMULATION_NAME}_open_dynamic_archive
1594   (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1595 {
1596   const char *filename;
1597   char *string;
1598
1599   if (! entry->is_archive)
1600     return FALSE;
1601
1602   filename = entry->filename;
1603
1604   /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1605      is defined, but it does not seem worth the headache to optimize
1606      away those two bytes of space.  */
1607   string = (char *) xmalloc (strlen (search->name)
1608                              + strlen (filename)
1609                              + strlen (arch)
1610 #ifdef EXTRA_SHLIB_EXTENSION
1611                              + strlen (EXTRA_SHLIB_EXTENSION)
1612 #endif
1613                              + sizeof "/lib.so");
1614
1615   sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1616
1617 #ifdef EXTRA_SHLIB_EXTENSION
1618   /* Try the .so extension first.  If that fails build a new filename
1619      using EXTRA_SHLIB_EXTENSION.  */
1620   if (! ldfile_try_open_bfd (string, entry))
1621     {
1622       sprintf (string, "%s/lib%s%s%s", search->name,
1623                filename, arch, EXTRA_SHLIB_EXTENSION);
1624 #endif
1625
1626   if (! ldfile_try_open_bfd (string, entry))
1627     {
1628       free (string);
1629       return FALSE;
1630     }
1631 #ifdef EXTRA_SHLIB_EXTENSION
1632     }
1633 #endif
1634
1635   entry->filename = string;
1636
1637   /* We have found a dynamic object to include in the link.  The ELF
1638      backend linker will create a DT_NEEDED entry in the .dynamic
1639      section naming this file.  If this file includes a DT_SONAME
1640      entry, it will be used.  Otherwise, the ELF linker will just use
1641      the name of the file.  For an archive found by searching, like
1642      this one, the DT_NEEDED entry should consist of just the name of
1643      the file, without the path information used to find it.  Note
1644      that we only need to do this if we have a dynamic object; an
1645      archive will never be referenced by a DT_NEEDED entry.
1646
1647      FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1648      very pretty.  I haven't been able to think of anything that is
1649      pretty, though.  */
1650   if (bfd_check_format (entry->the_bfd, bfd_object)
1651       && (entry->the_bfd->flags & DYNAMIC) != 0)
1652     {
1653       ASSERT (entry->is_archive && entry->search_dirs_flag);
1654
1655       /* Rather than duplicating the logic above.  Just use the
1656          filename we recorded earlier.  */
1657
1658       filename = lbasename (entry->filename);
1659       bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1660     }
1661
1662   return TRUE;
1663 }
1664
1665 EOF
1666 fi
1667
1668 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1669 fragment <<EOF
1670
1671 /* A variant of lang_output_section_find used by place_orphan.  */
1672
1673 static lang_output_section_statement_type *
1674 output_rel_find (asection *sec, int isdyn)
1675 {
1676   lang_output_section_statement_type *lookup;
1677   lang_output_section_statement_type *last = NULL;
1678   lang_output_section_statement_type *last_alloc = NULL;
1679   lang_output_section_statement_type *last_ro_alloc = NULL;
1680   lang_output_section_statement_type *last_rel = NULL;
1681   lang_output_section_statement_type *last_rel_alloc = NULL;
1682   int rela = sec->name[4] == 'a';
1683
1684   for (lookup = &lang_output_section_statement.head->output_section_statement;
1685        lookup != NULL;
1686        lookup = lookup->next)
1687     {
1688       if (lookup->constraint >= 0
1689           && CONST_STRNEQ (lookup->name, ".rel"))
1690         {
1691           int lookrela = lookup->name[4] == 'a';
1692
1693           /* .rel.dyn must come before all other reloc sections, to suit
1694              GNU ld.so.  */
1695           if (isdyn)
1696             break;
1697
1698           /* Don't place after .rel.plt as doing so results in wrong
1699              dynamic tags.  */
1700           if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1701             break;
1702
1703           if (rela == lookrela || last_rel == NULL)
1704             last_rel = lookup;
1705           if ((rela == lookrela || last_rel_alloc == NULL)
1706               && lookup->bfd_section != NULL
1707               && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1708             last_rel_alloc = lookup;
1709         }
1710
1711       last = lookup;
1712       if (lookup->bfd_section != NULL
1713           && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1714         {
1715           last_alloc = lookup;
1716           if ((lookup->bfd_section->flags & SEC_READONLY) != 0)
1717             last_ro_alloc = lookup;
1718         }
1719     }
1720
1721   if (last_rel_alloc)
1722     return last_rel_alloc;
1723
1724   if (last_rel)
1725     return last_rel;
1726
1727   if (last_ro_alloc)
1728     return last_ro_alloc;
1729
1730   if (last_alloc)
1731     return last_alloc;
1732
1733   return last;
1734 }
1735
1736 /* Place an orphan section.  We use this to put random SHF_ALLOC
1737    sections in the right segment.  */
1738
1739 static lang_output_section_statement_type *
1740 gld${EMULATION_NAME}_place_orphan (asection *s,
1741                                    const char *secname,
1742                                    int constraint)
1743 {
1744   static struct orphan_save hold[] =
1745     {
1746       { ".text",
1747         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1748         0, 0, 0, 0 },
1749       { ".rodata",
1750         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1751         0, 0, 0, 0 },
1752       { ".data",
1753         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1754         0, 0, 0, 0 },
1755       { ".bss",
1756         SEC_ALLOC,
1757         0, 0, 0, 0 },
1758       { 0,
1759         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1760         0, 0, 0, 0 },
1761       { ".interp",
1762         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1763         0, 0, 0, 0 },
1764       { ".sdata",
1765         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1766         0, 0, 0, 0 },
1767       { 0,
1768         SEC_HAS_CONTENTS,
1769         0, 0, 0, 0 },
1770     };
1771   enum orphan_save_index
1772     {
1773       orphan_text = 0,
1774       orphan_rodata,
1775       orphan_data,
1776       orphan_bss,
1777       orphan_rel,
1778       orphan_interp,
1779       orphan_sdata,
1780       orphan_nonalloc
1781     };
1782   static int orphan_init_done = 0;
1783   struct orphan_save *place;
1784   lang_output_section_statement_type *after;
1785   lang_output_section_statement_type *os;
1786   lang_output_section_statement_type *match_by_name = NULL;
1787   int isdyn = 0;
1788   int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1789   unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
1790
1791   if (! link_info.relocatable
1792       && link_info.combreloc
1793       && (s->flags & SEC_ALLOC))
1794     {
1795       if (iself)
1796         switch (sh_type)
1797           {
1798           case SHT_RELA:
1799             secname = ".rela.dyn";
1800             isdyn = 1;
1801             break;
1802           case SHT_REL:
1803             secname = ".rel.dyn";
1804             isdyn = 1;
1805             break;
1806           default:
1807             break;
1808           }
1809       else if (CONST_STRNEQ (secname, ".rel"))
1810         {
1811           secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1812           isdyn = 1;
1813         }
1814     }
1815
1816   /* Look through the script to see where to place this section.  */
1817   if (constraint == 0)
1818     for (os = lang_output_section_find (secname);
1819          os != NULL;
1820          os = next_matching_output_section_statement (os, 0))
1821       {
1822         /* If we don't match an existing output section, tell
1823            lang_insert_orphan to create a new output section.  */
1824         constraint = SPECIAL;
1825
1826         if (os->bfd_section != NULL
1827             && (os->bfd_section->flags == 0
1828                 || (_bfd_elf_match_sections_by_type (link_info.output_bfd,
1829                                                      os->bfd_section,
1830                                                      s->owner, s)
1831                     && ((s->flags ^ os->bfd_section->flags)
1832                         & (SEC_LOAD | SEC_ALLOC)) == 0)))
1833           {
1834             /* We already have an output section statement with this
1835                name, and its bfd section has compatible flags.
1836                If the section already exists but does not have any flags
1837                set, then it has been created by the linker, probably as a
1838                result of a --section-start command line switch.  */
1839             lang_add_section (&os->children, s, os);
1840             return os;
1841           }
1842
1843         /* Save unused output sections in case we can match them
1844            against orphans later.  */
1845         if (os->bfd_section == NULL)
1846           match_by_name = os;
1847       }
1848
1849   /* If we didn't match an active output section, see if we matched an
1850      unused one and use that.  */
1851   if (match_by_name)
1852     {
1853       lang_add_section (&match_by_name->children, s, match_by_name);
1854       return match_by_name;
1855     }
1856
1857   if (!orphan_init_done)
1858     {
1859       lang_output_section_statement_type *lookup;
1860       struct orphan_save *ho;
1861
1862       for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1863         if (ho->name != NULL)
1864           {
1865             ho->os = lang_output_section_find (ho->name);
1866             if (ho->os != NULL && ho->os->flags == 0)
1867               ho->os->flags = ho->flags;
1868           }
1869       lookup = hold[orphan_bss].os;
1870       if (lookup == NULL)
1871         lookup = &lang_output_section_statement.head->output_section_statement;
1872       for (; lookup != NULL; lookup = lookup->next)
1873         if ((lookup->bfd_section != NULL
1874              && (lookup->bfd_section->flags & SEC_DEBUGGING) != 0)
1875             || strcmp (lookup->name, ".comment") == 0)
1876           break;
1877       hold[orphan_nonalloc].os = lookup ? lookup->prev : NULL;
1878       hold[orphan_nonalloc].name = ".comment";
1879       orphan_init_done = 1;
1880     }
1881
1882   /* If this is a final link, then always put .gnu.warning.SYMBOL
1883      sections into the .text section to get them out of the way.  */
1884   if (link_info.executable
1885       && ! link_info.relocatable
1886       && CONST_STRNEQ (s->name, ".gnu.warning.")
1887       && hold[orphan_text].os != NULL)
1888     {
1889       os = hold[orphan_text].os;
1890       lang_add_section (&os->children, s, os);
1891       return os;
1892     }
1893
1894   /* Decide which segment the section should go in based on the
1895      section name and section flags.  We put loadable .note sections
1896      right after the .interp section, so that the PT_NOTE segment is
1897      stored right after the program headers where the OS can read it
1898      in the first page.  */
1899
1900   place = NULL;
1901   if ((s->flags & (SEC_ALLOC | SEC_DEBUGGING)) == 0)
1902     place = &hold[orphan_nonalloc];
1903   else if ((s->flags & SEC_ALLOC) == 0)
1904     ;
1905   else if ((s->flags & SEC_LOAD) != 0
1906            && ((iself && sh_type == SHT_NOTE)
1907                || (!iself && CONST_STRNEQ (secname, ".note"))))
1908     place = &hold[orphan_interp];
1909   else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1910     place = &hold[orphan_bss];
1911   else if ((s->flags & SEC_SMALL_DATA) != 0)
1912     place = &hold[orphan_sdata];
1913   else if ((s->flags & SEC_READONLY) == 0)
1914     place = &hold[orphan_data];
1915   else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
1916             || (!iself && CONST_STRNEQ (secname, ".rel")))
1917            && (s->flags & SEC_LOAD) != 0)
1918     place = &hold[orphan_rel];
1919   else if ((s->flags & SEC_CODE) == 0)
1920     place = &hold[orphan_rodata];
1921   else
1922     place = &hold[orphan_text];
1923
1924   after = NULL;
1925   if (place != NULL)
1926     {
1927       if (place->os == NULL)
1928         {
1929           if (place->name != NULL)
1930             place->os = lang_output_section_find (place->name);
1931           else
1932             place->os = output_rel_find (s, isdyn);
1933         }
1934       after = place->os;
1935       if (after == NULL)
1936         after = lang_output_section_find_by_flags
1937           (s, &place->os, _bfd_elf_match_sections_by_type);
1938       if (after == NULL)
1939         /* *ABS* is always the first output section statement.  */
1940         after = &lang_output_section_statement.head->output_section_statement;
1941     }
1942
1943   return lang_insert_orphan (s, secname, constraint, after, place, NULL, NULL);
1944 }
1945 EOF
1946 fi
1947
1948 if test x"$LDEMUL_AFTER_ALLOCATION" != xgld"$EMULATION_NAME"_after_allocation; then
1949 fragment <<EOF
1950
1951 static void
1952 gld${EMULATION_NAME}_after_allocation (void)
1953 {
1954   bfd_boolean need_layout = bfd_elf_discard_info (link_info.output_bfd,
1955                                                   &link_info);
1956   gld${EMULATION_NAME}_map_segments (need_layout);
1957 }
1958 EOF
1959 fi
1960
1961 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1962 fragment <<EOF
1963
1964 static char *
1965 gld${EMULATION_NAME}_get_script (int *isfile)
1966 EOF
1967
1968 if test -n "$COMPILE_IN"
1969 then
1970 # Scripts compiled in.
1971
1972 # sed commands to quote an ld script as a C string.
1973 sc="-f stringify.sed"
1974
1975 fragment <<EOF
1976 {
1977   *isfile = 0;
1978
1979   if (link_info.relocatable && config.build_constructors)
1980     return
1981 EOF
1982 sed $sc ldscripts/${EMULATION_NAME}.xu                  >> e${EMULATION_NAME}.c
1983 echo '  ; else if (link_info.relocatable) return'       >> e${EMULATION_NAME}.c
1984 sed $sc ldscripts/${EMULATION_NAME}.xr                  >> e${EMULATION_NAME}.c
1985 echo '  ; else if (!config.text_read_only) return'      >> e${EMULATION_NAME}.c
1986 sed $sc ldscripts/${EMULATION_NAME}.xbn                 >> e${EMULATION_NAME}.c
1987 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1988 echo '  ; else if (!config.magic_demand_paged) return'  >> e${EMULATION_NAME}.c
1989 sed $sc ldscripts/${EMULATION_NAME}.xn                  >> e${EMULATION_NAME}.c
1990 fi
1991 if test -n "$GENERATE_PIE_SCRIPT" ; then
1992 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1993 echo '  ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1994 echo '             && link_info.relro' >> e${EMULATION_NAME}.c
1995 echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1996 sed $sc ldscripts/${EMULATION_NAME}.xdw                 >> e${EMULATION_NAME}.c
1997 echo '  ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1998 sed $sc ldscripts/${EMULATION_NAME}.xdc                 >> e${EMULATION_NAME}.c
1999 fi
2000 echo '  ; else if (link_info.pie) return'               >> e${EMULATION_NAME}.c
2001 sed $sc ldscripts/${EMULATION_NAME}.xd                  >> e${EMULATION_NAME}.c
2002 fi
2003 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
2004 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2005 echo '  ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
2006 echo '             && link_info.relro' >> e${EMULATION_NAME}.c
2007 echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2008 sed $sc ldscripts/${EMULATION_NAME}.xsw                 >> e${EMULATION_NAME}.c
2009 echo '  ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
2010 sed $sc ldscripts/${EMULATION_NAME}.xsc                 >> e${EMULATION_NAME}.c
2011 fi
2012 echo '  ; else if (link_info.shared) return'            >> e${EMULATION_NAME}.c
2013 sed $sc ldscripts/${EMULATION_NAME}.xs                  >> e${EMULATION_NAME}.c
2014 fi
2015 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2016 echo '  ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
2017 echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
2018 sed $sc ldscripts/${EMULATION_NAME}.xw                  >> e${EMULATION_NAME}.c
2019 echo '  ; else if (link_info.combreloc) return'         >> e${EMULATION_NAME}.c
2020 sed $sc ldscripts/${EMULATION_NAME}.xc                  >> e${EMULATION_NAME}.c
2021 fi
2022 echo '  ; else return'                                  >> e${EMULATION_NAME}.c
2023 sed $sc ldscripts/${EMULATION_NAME}.x                   >> e${EMULATION_NAME}.c
2024 echo '; }'                                              >> e${EMULATION_NAME}.c
2025
2026 else
2027 # Scripts read from the filesystem.
2028
2029 fragment <<EOF
2030 {
2031   *isfile = 1;
2032
2033   if (link_info.relocatable && config.build_constructors)
2034     return "ldscripts/${EMULATION_NAME}.xu";
2035   else if (link_info.relocatable)
2036     return "ldscripts/${EMULATION_NAME}.xr";
2037   else if (!config.text_read_only)
2038     return "ldscripts/${EMULATION_NAME}.xbn";
2039 EOF
2040 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
2041 else
2042 fragment <<EOF
2043   else if (!config.magic_demand_paged)
2044     return "ldscripts/${EMULATION_NAME}.xn";
2045 EOF
2046 fi
2047 if test -n "$GENERATE_PIE_SCRIPT" ; then
2048 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2049 fragment <<EOF
2050   else if (link_info.pie && link_info.combreloc
2051            && link_info.relro && (link_info.flags & DF_BIND_NOW))
2052     return "ldscripts/${EMULATION_NAME}.xdw";
2053   else if (link_info.pie && link_info.combreloc)
2054     return "ldscripts/${EMULATION_NAME}.xdc";
2055 EOF
2056 fi
2057 fragment <<EOF
2058   else if (link_info.pie)
2059     return "ldscripts/${EMULATION_NAME}.xd";
2060 EOF
2061 fi
2062 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
2063 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2064 fragment <<EOF
2065   else if (link_info.shared && link_info.combreloc
2066            && link_info.relro && (link_info.flags & DF_BIND_NOW))
2067     return "ldscripts/${EMULATION_NAME}.xsw";
2068   else if (link_info.shared && link_info.combreloc)
2069     return "ldscripts/${EMULATION_NAME}.xsc";
2070 EOF
2071 fi
2072 fragment <<EOF
2073   else if (link_info.shared)
2074     return "ldscripts/${EMULATION_NAME}.xs";
2075 EOF
2076 fi
2077 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
2078 fragment <<EOF
2079   else if (link_info.combreloc && link_info.relro
2080            && (link_info.flags & DF_BIND_NOW))
2081     return "ldscripts/${EMULATION_NAME}.xw";
2082   else if (link_info.combreloc)
2083     return "ldscripts/${EMULATION_NAME}.xc";
2084 EOF
2085 fi
2086 fragment <<EOF
2087   else
2088     return "ldscripts/${EMULATION_NAME}.x";
2089 }
2090
2091 EOF
2092 fi
2093 fi
2094
2095 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2096
2097 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
2098 fragment <<EOF
2099  $PARSE_AND_LIST_PROLOGUE
2100 EOF
2101 fi
2102
2103 fragment <<EOF
2104
2105 #define OPTION_DISABLE_NEW_DTAGS        (400)
2106 #define OPTION_ENABLE_NEW_DTAGS         (OPTION_DISABLE_NEW_DTAGS + 1)
2107 #define OPTION_GROUP                    (OPTION_ENABLE_NEW_DTAGS + 1)
2108 #define OPTION_EH_FRAME_HDR             (OPTION_GROUP + 1)
2109 #define OPTION_EXCLUDE_LIBS             (OPTION_EH_FRAME_HDR + 1)
2110 #define OPTION_HASH_STYLE               (OPTION_EXCLUDE_LIBS + 1)
2111 #define OPTION_BUILD_ID                 (OPTION_HASH_STYLE + 1)
2112 #define OPTION_AUDIT                    (OPTION_BUILD_ID + 1)
2113
2114 static void
2115 gld${EMULATION_NAME}_add_options
2116   (int ns, char **shortopts, int nl, struct option **longopts,
2117    int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
2118 {
2119   static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:P:";
2120   static const struct option xtra_long[] = {
2121     {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
2122     {"audit", required_argument, NULL, OPTION_AUDIT},
2123     {"depaudit", required_argument, NULL, 'P'},
2124 EOF
2125
2126 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2127 fragment <<EOF
2128     {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
2129     {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
2130     {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
2131     {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
2132     {"hash-style", required_argument, NULL, OPTION_HASH_STYLE},
2133     {"Bgroup", no_argument, NULL, OPTION_GROUP},
2134 EOF
2135 fi
2136
2137 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
2138 fragment <<EOF
2139     $PARSE_AND_LIST_LONGOPTS
2140 EOF
2141 fi
2142
2143 fragment <<EOF
2144     {NULL, no_argument, NULL, 0}
2145   };
2146
2147   *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
2148   memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
2149   *longopts = (struct option *)
2150     xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
2151   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
2152 }
2153
2154 #define DEFAULT_BUILD_ID_STYLE  "sha1"
2155
2156 static bfd_boolean
2157 gld${EMULATION_NAME}_handle_option (int optc)
2158 {
2159   switch (optc)
2160     {
2161     default:
2162       return FALSE;
2163
2164     case OPTION_BUILD_ID:
2165       if (link_info.emit_note_gnu_build_id != NULL)
2166         {
2167           free (link_info.emit_note_gnu_build_id);
2168           link_info.emit_note_gnu_build_id = NULL;
2169         }
2170       if (optarg == NULL)
2171         optarg = DEFAULT_BUILD_ID_STYLE;
2172       if (strcmp (optarg, "none"))
2173         link_info.emit_note_gnu_build_id = xstrdup (optarg);
2174       break;
2175     case OPTION_AUDIT:
2176         gld${EMULATION_NAME}_append_to_separated_string (&audit, optarg);
2177         break;
2178     case 'P':
2179         gld${EMULATION_NAME}_append_to_separated_string (&depaudit, optarg);
2180         break;
2181
2182 EOF
2183
2184 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2185 fragment <<EOF
2186     case OPTION_DISABLE_NEW_DTAGS:
2187       link_info.new_dtags = FALSE;
2188       break;
2189
2190     case OPTION_ENABLE_NEW_DTAGS:
2191       link_info.new_dtags = TRUE;
2192       break;
2193
2194     case OPTION_EH_FRAME_HDR:
2195       link_info.eh_frame_hdr = TRUE;
2196       break;
2197
2198     case OPTION_GROUP:
2199       link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
2200       /* Groups must be self-contained.  */
2201       link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2202       link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
2203       break;
2204
2205     case OPTION_EXCLUDE_LIBS:
2206       add_excluded_libs (optarg);
2207       break;
2208
2209     case OPTION_HASH_STYLE:
2210       link_info.emit_hash = FALSE;
2211       link_info.emit_gnu_hash = FALSE;
2212       if (strcmp (optarg, "sysv") == 0)
2213         link_info.emit_hash = TRUE;
2214       else if (strcmp (optarg, "gnu") == 0)
2215         link_info.emit_gnu_hash = TRUE;
2216       else if (strcmp (optarg, "both") == 0)
2217         {
2218           link_info.emit_hash = TRUE;
2219           link_info.emit_gnu_hash = TRUE;
2220         }
2221       else
2222         einfo (_("%P%F: invalid hash style \`%s'\n"), optarg);
2223       break;
2224
2225     case 'z':
2226       if (strcmp (optarg, "initfirst") == 0)
2227         link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
2228       else if (strcmp (optarg, "interpose") == 0)
2229         link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
2230       else if (strcmp (optarg, "loadfltr") == 0)
2231         link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
2232       else if (strcmp (optarg, "nodefaultlib") == 0)
2233         link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
2234       else if (strcmp (optarg, "nodelete") == 0)
2235         link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
2236       else if (strcmp (optarg, "nodlopen") == 0)
2237         link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
2238       else if (strcmp (optarg, "nodump") == 0)
2239         link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
2240       else if (strcmp (optarg, "now") == 0)
2241         {
2242           link_info.flags |= (bfd_vma) DF_BIND_NOW;
2243           link_info.flags_1 |= (bfd_vma) DF_1_NOW;
2244         }
2245       else if (strcmp (optarg, "lazy") == 0)
2246         {
2247           link_info.flags &= ~(bfd_vma) DF_BIND_NOW;
2248           link_info.flags_1 &= ~(bfd_vma) DF_1_NOW;
2249         }
2250       else if (strcmp (optarg, "origin") == 0)
2251         {
2252           link_info.flags |= (bfd_vma) DF_ORIGIN;
2253           link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
2254         }
2255       else if (strcmp (optarg, "defs") == 0)
2256         link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2257       else if (strcmp (optarg, "muldefs") == 0)
2258         link_info.allow_multiple_definition = TRUE;
2259       else if (strcmp (optarg, "combreloc") == 0)
2260         link_info.combreloc = TRUE;
2261       else if (strcmp (optarg, "nocombreloc") == 0)
2262         link_info.combreloc = FALSE;
2263       else if (strcmp (optarg, "nocopyreloc") == 0)
2264         link_info.nocopyreloc = TRUE;
2265       else if (strcmp (optarg, "execstack") == 0)
2266         {
2267           link_info.execstack = TRUE;
2268           link_info.noexecstack = FALSE;
2269         }
2270       else if (strcmp (optarg, "noexecstack") == 0)
2271         {
2272           link_info.noexecstack = TRUE;
2273           link_info.execstack = FALSE;
2274         }
2275 EOF
2276
2277   if test -n "$COMMONPAGESIZE"; then
2278 fragment <<EOF
2279       else if (strcmp (optarg, "relro") == 0)
2280         link_info.relro = TRUE;
2281       else if (strcmp (optarg, "norelro") == 0)
2282         link_info.relro = FALSE;
2283 EOF
2284   fi
2285
2286 fragment <<EOF
2287       else if (CONST_STRNEQ (optarg, "max-page-size="))
2288         {
2289           char *end;
2290
2291           config.maxpagesize = strtoul (optarg + 14, &end, 0);
2292           if (*end || (config.maxpagesize & (config.maxpagesize - 1)) != 0)
2293             einfo (_("%P%F: invalid maxium page size \`%s'\n"),
2294                    optarg + 14);
2295         }
2296       else if (CONST_STRNEQ (optarg, "common-page-size="))
2297         {
2298           char *end;
2299           config.commonpagesize = strtoul (optarg + 17, &end, 0);
2300           if (*end
2301               || (config.commonpagesize & (config.commonpagesize - 1)) != 0)
2302             einfo (_("%P%F: invalid common page size \`%s'\n"),
2303                    optarg + 17);
2304         }
2305       /* What about the other Solaris -z options? FIXME.  */
2306       break;
2307 EOF
2308 fi
2309
2310 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
2311 fragment <<EOF
2312  $PARSE_AND_LIST_ARGS_CASES
2313 EOF
2314 fi
2315
2316 fragment <<EOF
2317     }
2318
2319   return TRUE;
2320 }
2321
2322 EOF
2323
2324 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2325 fragment <<EOF
2326
2327 static void
2328 gld${EMULATION_NAME}_list_options (FILE * file)
2329 {
2330   fprintf (file, _("\
2331   --build-id[=STYLE]          Generate build ID note\n"));
2332   fprintf (file, _("\
2333   --audit=AUDITLIB            Specify a library to use for auditing\n"));
2334   fprintf (file, _("\
2335   -P AUDITLIB, --depaudit=AUDITLIB\n" "\
2336                               Specify a library to use for auditing dependencies\n"));
2337 EOF
2338
2339 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2340 fragment <<EOF
2341   fprintf (file, _("\
2342   -Bgroup                     Selects group name lookup rules for DSO\n"));
2343   fprintf (file, _("\
2344   --disable-new-dtags         Disable new dynamic tags\n"));
2345   fprintf (file, _("\
2346   --enable-new-dtags          Enable new dynamic tags\n"));
2347   fprintf (file, _("\
2348   --eh-frame-hdr              Create .eh_frame_hdr section\n"));
2349   fprintf (file, _("\
2350   --hash-style=STYLE          Set hash style to sysv, gnu or both\n"));
2351   fprintf (file, _("\
2352   -z combreloc                Merge dynamic relocs into one section and sort\n"));
2353   fprintf (file, _("\
2354   -z defs                     Report unresolved symbols in object files.\n"));
2355   fprintf (file, _("\
2356   -z execstack                Mark executable as requiring executable stack\n"));
2357   fprintf (file, _("\
2358   -z initfirst                Mark DSO to be initialized first at runtime\n"));
2359   fprintf (file, _("\
2360   -z interpose                Mark object to interpose all DSOs but executable\n"));
2361   fprintf (file, _("\
2362   -z lazy                     Mark object lazy runtime binding (default)\n"));
2363   fprintf (file, _("\
2364   -z loadfltr                 Mark object requiring immediate process\n"));
2365   fprintf (file, _("\
2366   -z muldefs                  Allow multiple definitions\n"));
2367   fprintf (file, _("\
2368   -z nocombreloc              Don't merge dynamic relocs into one section\n"));
2369   fprintf (file, _("\
2370   -z nocopyreloc              Don't create copy relocs\n"));
2371   fprintf (file, _("\
2372   -z nodefaultlib             Mark object not to use default search paths\n"));
2373   fprintf (file, _("\
2374   -z nodelete                 Mark DSO non-deletable at runtime\n"));
2375   fprintf (file, _("\
2376   -z nodlopen                 Mark DSO not available to dlopen\n"));
2377   fprintf (file, _("\
2378   -z nodump                   Mark DSO not available to dldump\n"));
2379   fprintf (file, _("\
2380   -z noexecstack              Mark executable as not requiring executable stack\n"));
2381 EOF
2382
2383   if test -n "$COMMONPAGESIZE"; then
2384 fragment <<EOF
2385   fprintf (file, _("\
2386   -z norelro                  Don't create RELRO program header\n"));
2387 EOF
2388   fi
2389
2390 fragment <<EOF
2391   fprintf (file, _("\
2392   -z now                      Mark object non-lazy runtime binding\n"));
2393   fprintf (file, _("\
2394   -z origin                   Mark object requiring immediate \$ORIGIN\n\
2395                                 processing at runtime\n"));
2396 EOF
2397
2398   if test -n "$COMMONPAGESIZE"; then
2399 fragment <<EOF
2400   fprintf (file, _("\
2401   -z relro                    Create RELRO program header\n"));
2402 EOF
2403   fi
2404
2405 fragment <<EOF
2406   fprintf (file, _("\
2407   -z max-page-size=SIZE       Set maximum page size to SIZE\n"));
2408   fprintf (file, _("\
2409   -z common-page-size=SIZE    Set common page size to SIZE\n"));
2410   fprintf (file, _("\
2411   -z KEYWORD                  Ignored for Solaris compatibility\n"));
2412 EOF
2413 fi
2414
2415 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
2416 fragment <<EOF
2417  $PARSE_AND_LIST_OPTIONS
2418 EOF
2419 fi
2420
2421 fragment <<EOF
2422 }
2423 EOF
2424
2425 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
2426 fragment <<EOF
2427  $PARSE_AND_LIST_EPILOGUE
2428 EOF
2429 fi
2430 fi
2431 else
2432 fragment <<EOF
2433 #define gld${EMULATION_NAME}_add_options NULL
2434 #define gld${EMULATION_NAME}_handle_option NULL
2435 EOF
2436 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2437 fragment <<EOF
2438 #define gld${EMULATION_NAME}_list_options NULL
2439 EOF
2440 fi
2441 fi
2442
2443 fragment <<EOF
2444
2445 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
2446 {
2447   ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
2448   ${LDEMUL_SYSLIB-syslib_default},
2449   ${LDEMUL_HLL-hll_default},
2450   ${LDEMUL_AFTER_PARSE-after_parse_default},
2451   ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
2452   ${LDEMUL_AFTER_ALLOCATION-gld${EMULATION_NAME}_after_allocation},
2453   ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
2454   ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
2455   ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
2456   ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
2457   "${EMULATION_NAME}",
2458   "${OUTPUT_FORMAT}",
2459   ${LDEMUL_FINISH-finish_default},
2460   ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
2461   ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
2462   ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
2463   ${LDEMUL_SET_SYMBOLS-NULL},
2464   ${LDEMUL_PARSE_ARGS-NULL},
2465   gld${EMULATION_NAME}_add_options,
2466   gld${EMULATION_NAME}_handle_option,
2467   ${LDEMUL_UNRECOGNIZED_FILE-NULL},
2468   ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
2469   ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
2470   ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
2471   ${LDEMUL_NEW_VERS_PATTERN-NULL}
2472 };
2473 EOF