ld/emultempl/elf32.em

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