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