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