ld/emultempl/elf32.em

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