contrib/binutils-2.15/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 cat >e${EMULATION_NAME}.c <<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 Free Software Foundation, Inc.
  17    Written by Steve Chamberlain <sac@cygnus.com>
  18    ELF support by Ian Lance Taylor <ian@cygnus.com>
  19
  20 This file is part of GLD, the Gnu Linker.
  21
  22 This program is free software; you can redistribute it and/or modify
  23 it under the terms of the GNU General Public License as published by
  24 the Free Software Foundation; either version 2 of the License, or
  25 (at your option) any later version.
  26
  27 This program is distributed in the hope that it will be useful,
  28 but WITHOUT ANY WARRANTY; without even the implied warranty of
  29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30 GNU General Public License for more details.
  31
  32 You should have received a copy of the GNU General Public License
  33 along with this program; if not, write to the Free Software
  34 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  35
  36 #define TARGET_IS_${EMULATION_NAME}
  37
  38 #include "bfd.h"
  39 #include "sysdep.h"
  40 #include "libiberty.h"
  41 #include "safe-ctype.h"
  42 #include "getopt.h"
  43
  44 #include "bfdlink.h"
  45
  46 #include "ld.h"
  47 #include "ldmain.h"
  48 #include "ldmisc.h"
  49 #include "ldexp.h"
  50 #include "ldlang.h"
  51 #include "ldfile.h"
  52 #include "ldemul.h"
  53 #include <ldgram.h>
  54 #include "elf/common.h"
  55
  56 /* Declare functions used by various EXTRA_EM_FILEs.  */
  57 static void gld${EMULATION_NAME}_before_parse (void);
  58 static void gld${EMULATION_NAME}_after_open (void);
  59 static void gld${EMULATION_NAME}_before_allocation (void);
  60 static bfd_boolean gld${EMULATION_NAME}_place_orphan
  61   (lang_input_statement_type *file, asection *s);
  62 static void gld${EMULATION_NAME}_finish (void);
  63
  64 EOF
  65
  66 # Import any needed special functions and/or overrides.
  67 #
  68 if test -n "$EXTRA_EM_FILE" ; then
  69 . ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
  70 fi
  71
  72 # Functions in this file can be overridden by setting the LDEMUL_* shell
  73 # variables.  If the name of the overriding function is the same as is
  74 # defined in this file, then don't output this file's version.
  75 # If a different overriding name is given then output the standard function
  76 # as presumably it is called from the overriding function.
  77 #
  78 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
  79 cat >>e${EMULATION_NAME}.c <<EOF
  80
  81 static void
  82 gld${EMULATION_NAME}_before_parse (void)
  83 {
  84   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
  85   config.dynamic_link = ${DYNAMIC_LINK-TRUE};
  86   config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
  87 }
  88
  89 EOF
  90 fi
  91
  92 if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
  93 cat >>e${EMULATION_NAME}.c <<EOF
  94 /* Handle as_needed DT_NEEDED.  */
  95
  96 static bfd_boolean
  97 gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
  98 {
  99   if (!entry->as_needed
 100       || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
 101     return FALSE;
 102
 103   /* Tell the ELF linker that we don't want the output file to have a
 104      DT_NEEDED entry for this file, unless it is used to resolve
 105      references in a regular object.  */
 106   bfd_elf_set_dyn_lib_class (entry->the_bfd, DYN_AS_NEEDED);
 107
 108   /* Continue on with normal load_symbols processing.  */
 109   return FALSE;
 110 }
 111 EOF
 112 fi
 113
 114 cat >>e${EMULATION_NAME}.c <<EOF
 115
 116 /* These variables are required to pass information back and forth
 117    between after_open and check_needed and stat_needed and vercheck.  */
 118
 119 static struct bfd_link_needed_list *global_needed;
 120 static struct stat global_stat;
 121 static bfd_boolean global_found;
 122 static struct bfd_link_needed_list *global_vercheck_needed;
 123 static bfd_boolean global_vercheck_failed;
 124
 125
 126 /* On Linux, it's possible to have different versions of the same
 127    shared library linked against different versions of libc.  The
 128    dynamic linker somehow tags which libc version to use in
 129    /etc/ld.so.cache, and, based on the libc that it sees in the
 130    executable, chooses which version of the shared library to use.
 131
 132    We try to do a similar check here by checking whether this shared
 133    library needs any other shared libraries which may conflict with
 134    libraries we have already included in the link.  If it does, we
 135    skip it, and try to find another shared library farther on down the
 136    link path.
 137
 138    This is called via lang_for_each_input_file.
 139    GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
 140    which we are checking.  This sets GLOBAL_VERCHECK_FAILED if we find
 141    a conflicting version.  */
 142
 143 static void
 144 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
 145 {
 146   const char *soname;
 147   struct bfd_link_needed_list *l;
 148
 149   if (global_vercheck_failed)
 150     return;
 151   if (s->the_bfd == NULL
 152       || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
 153     return;
 154
 155   soname = bfd_elf_get_dt_soname (s->the_bfd);
 156   if (soname == NULL)
 157     soname = lbasename (bfd_get_filename (s->the_bfd));
 158
 159   for (l = global_vercheck_needed; l != NULL; l = l->next)
 160     {
 161       const char *suffix;
 162
 163       if (strcmp (soname, l->name) == 0)
 164         {
 165           /* Probably can't happen, but it's an easy check.  */
 166           continue;
 167         }
 168
 169       if (strchr (l->name, '/') != NULL)
 170         continue;
 171
 172       suffix = strstr (l->name, ".so.");
 173       if (suffix == NULL)
 174         continue;
 175
 176       suffix += sizeof ".so." - 1;
 177
 178       if (strncmp (soname, l->name, suffix - l->name) == 0)
 179         {
 180           /* Here we know that S is a dynamic object FOO.SO.VER1, and
 181              the object we are considering needs a dynamic object
 182              FOO.SO.VER2, and VER1 and VER2 are different.  This
 183              appears to be a version mismatch, so we tell the caller
 184              to try a different version of this library.  */
 185           global_vercheck_failed = TRUE;
 186           return;
 187         }
 188     }
 189 }
 190
 191
 192 /* See if an input file matches a DT_NEEDED entry by running stat on
 193    the file.  */
 194
 195 static void
 196 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
 197 {
 198   struct stat st;
 199   const char *suffix;
 200   const char *soname;
 201
 202   if (global_found)
 203     return;
 204   if (s->the_bfd == NULL)
 205     return;
 206
 207   if (bfd_stat (s->the_bfd, &st) != 0)
 208     {
 209       einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
 210       return;
 211     }
 212
 213   if (st.st_dev == global_stat.st_dev
 214       && st.st_ino == global_stat.st_ino)
 215     {
 216       global_found = TRUE;
 217       return;
 218     }
 219
 220   /* We issue a warning if it looks like we are including two
 221      different versions of the same shared library.  For example,
 222      there may be a problem if -lc picks up libc.so.6 but some other
 223      shared library has a DT_NEEDED entry of libc.so.5.  This is a
 224      heuristic test, and it will only work if the name looks like
 225      NAME.so.VERSION.  FIXME: Depending on file names is error-prone.
 226      If we really want to issue warnings about mixing version numbers
 227      of shared libraries, we need to find a better way.  */
 228
 229   if (strchr (global_needed->name, '/') != NULL)
 230     return;
 231   suffix = strstr (global_needed->name, ".so.");
 232   if (suffix == NULL)
 233     return;
 234   suffix += sizeof ".so." - 1;
 235
 236   soname = bfd_elf_get_dt_soname (s->the_bfd);
 237   if (soname == NULL)
 238     soname = lbasename (s->filename);
 239
 240   if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
 241     einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
 242            global_needed->name, global_needed->by, soname);
 243 }
 244
 245
 246 /* This function is called for each possible name for a dynamic object
 247    named by a DT_NEEDED entry.  The FORCE parameter indicates whether
 248    to skip the check for a conflicting version.  */
 249
 250 static bfd_boolean
 251 gld${EMULATION_NAME}_try_needed (const char *name, int force)
 252 {
 253   bfd *abfd;
 254   const char *soname;
 255
 256   abfd = bfd_openr (name, bfd_get_target (output_bfd));
 257   if (abfd == NULL)
 258     return FALSE;
 259   if (! bfd_check_format (abfd, bfd_object))
 260     {
 261       bfd_close (abfd);
 262       return FALSE;
 263     }
 264   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 265     {
 266       bfd_close (abfd);
 267       return FALSE;
 268     }
 269
 270   /* For DT_NEEDED, they have to match.  */
 271   if (abfd->xvec != output_bfd->xvec)
 272     {
 273       bfd_close (abfd);
 274       return FALSE;
 275     }
 276
 277   /* Check whether this object would include any conflicting library
 278      versions.  If FORCE is set, then we skip this check; we use this
 279      the second time around, if we couldn't find any compatible
 280      instance of the shared library.  */
 281
 282   if (! force)
 283     {
 284       struct bfd_link_needed_list *needed;
 285
 286       if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
 287         einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
 288
 289       if (needed != NULL)
 290         {
 291           global_vercheck_needed = needed;
 292           global_vercheck_failed = FALSE;
 293           lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
 294           if (global_vercheck_failed)
 295             {
 296               bfd_close (abfd);
 297               /* Return FALSE to force the caller to move on to try
 298                  another file on the search path.  */
 299               return FALSE;
 300             }
 301
 302           /* But wait!  It gets much worse.  On Linux, if a shared
 303              library does not use libc at all, we are supposed to skip
 304              it the first time around in case we encounter a shared
 305              library later on with the same name which does use the
 306              version of libc that we want.  This is much too horrible
 307              to use on any system other than Linux.  */
 308
 309 EOF
 310 case ${target} in
 311   *-*-linux-gnu*)
 312     cat >>e${EMULATION_NAME}.c <<EOF
 313           {
 314             struct bfd_link_needed_list *l;
 315
 316             for (l = needed; l != NULL; l = l->next)
 317               if (strncmp (l->name, "libc.so", 7) == 0)
 318                 break;
 319             if (l == NULL)
 320               {
 321                 bfd_close (abfd);
 322                 return FALSE;
 323               }
 324           }
 325
 326 EOF
 327     ;;
 328 esac
 329 cat >>e${EMULATION_NAME}.c <<EOF
 330         }
 331     }
 332
 333   /* We've found a dynamic object matching the DT_NEEDED entry.  */
 334
 335   /* We have already checked that there is no other input file of the
 336      same name.  We must now check again that we are not including the
 337      same file twice.  We need to do this because on many systems
 338      libc.so is a symlink to, e.g., libc.so.1.  The SONAME entry will
 339      reference libc.so.1.  If we have already included libc.so, we
 340      don't want to include libc.so.1 if they are the same file, and we
 341      can only check that using stat.  */
 342
 343   if (bfd_stat (abfd, &global_stat) != 0)
 344     einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
 345
 346   /* First strip off everything before the last '/'.  */
 347   soname = lbasename (abfd->filename);
 348
 349   if (trace_file_tries)
 350     info_msg (_("found %s at %s\n"), soname, name);
 351
 352   global_found = FALSE;
 353   lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
 354   if (global_found)
 355     {
 356       /* Return TRUE to indicate that we found the file, even though
 357          we aren't going to do anything with it.  */
 358       return TRUE;
 359     }
 360
 361   /* Specify the soname to use.  */
 362   bfd_elf_set_dt_needed_name (abfd, soname);
 363
 364   /* Tell the ELF linker that we don't want the output file to have a
 365      DT_NEEDED entry for this file, unless it is used to resolve
 366      references in a regular object.  */
 367   bfd_elf_set_dyn_lib_class (abfd, DYN_DT_NEEDED);
 368
 369   /* Add this file into the symbol table.  */
 370   if (! bfd_link_add_symbols (abfd, &link_info))
 371     einfo ("%F%B: could not read symbols: %E\n", abfd);
 372
 373   return TRUE;
 374 }
 375
 376
 377 /* Search for a needed file in a path.  */
 378
 379 static bfd_boolean
 380 gld${EMULATION_NAME}_search_needed (const char *path, const char *name, int force)
 381 {
 382   const char *s;
 383   size_t len;
 384
 385   if (name[0] == '/')
 386     return gld${EMULATION_NAME}_try_needed (name, force);
 387
 388   if (path == NULL || *path == '\0')
 389     return FALSE;
 390   len = strlen (name);
 391   while (1)
 392     {
 393       char *filename, *sset;
 394
 395       s = strchr (path, ':');
 396       if (s == NULL)
 397         s = path + strlen (path);
 398
 399       filename = (char *) xmalloc (s - path + len + 2);
 400       if (s == path)
 401         sset = filename;
 402       else
 403         {
 404           memcpy (filename, path, s - path);
 405           filename[s - path] = '/';
 406           sset = filename + (s - path) + 1;
 407         }
 408       strcpy (sset, name);
 409
 410       if (gld${EMULATION_NAME}_try_needed (filename, force))
 411         return TRUE;
 412
 413       free (filename);
 414
 415       if (*s == '\0')
 416         break;
 417       path = s + 1;
 418     }
 419
 420   return FALSE;
 421 }
 422
 423 EOF
 424 if [ "x${USE_LIBPATH}" = xyes ] ; then
 425   cat >>e${EMULATION_NAME}.c <<EOF
 426
 427 /* Add the sysroot to every entry in a colon-separated path.  */
 428
 429 static char *
 430 gld${EMULATION_NAME}_add_sysroot (const char *path)
 431 {
 432   int len, colons, i;
 433   char *ret, *p;
 434
 435   len = strlen (path);
 436   colons = 0;
 437   i = 0;
 438   while (path[i])
 439     if (path[i++] == ':')
 440       colons++;
 441
 442   if (path[i])
 443     colons++;
 444
 445   len = len + (colons + 1) * strlen (ld_sysroot);
 446   ret = xmalloc (len + 1);
 447   strcpy (ret, ld_sysroot);
 448   p = ret + strlen (ret);
 449   i = 0;
 450   while (path[i])
 451     if (path[i] == ':')
 452       {
 453         *p++ = path[i++];
 454         strcpy (p, ld_sysroot);
 455         p = p + strlen (p);
 456       }
 457     else
 458       *p++ = path[i++];
 459
 460   *p = 0;
 461   return ret;
 462 }
 463
 464 EOF
 465   case ${target} in
 466     *-*-linux-gnu*)
 467       cat >>e${EMULATION_NAME}.c <<EOF
 468 /* For a native linker, check the file /etc/ld.so.conf for directories
 469    in which we may find shared libraries.  /etc/ld.so.conf is really
 470    only meaningful on Linux.  */
 471
 472 static bfd_boolean
 473 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
 474 {
 475   static bfd_boolean initialized;
 476   static char *ld_so_conf;
 477
 478   if (! initialized)
 479     {
 480       FILE *f;
 481       char *tmppath;
 482
 483       tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL);
 484       f = fopen (tmppath, FOPEN_RT);
 485       free (tmppath);
 486       if (f != NULL)
 487         {
 488           char *b;
 489           size_t len, alloc;
 490           int c;
 491
 492           len = 0;
 493           alloc = 100;
 494           b = (char *) xmalloc (alloc);
 495
 496           while ((c = getc (f)) != EOF)
 497             {
 498               if (len + 1 >= alloc)
 499                 {
 500                   alloc *= 2;
 501                   b = (char *) xrealloc (b, alloc);
 502                 }
 503               if (c != ':'
 504                   && c != ' '
 505                   && c != '\t'
 506                   && c != '\n'
 507                   && c != ',')
 508                 {
 509                   b[len] = c;
 510                   ++len;
 511                 }
 512               else
 513                 {
 514                   if (len > 0 && b[len - 1] != ':')
 515                     {
 516                       b[len] = ':';
 517                       ++len;
 518                     }
 519                 }
 520             }
 521
 522           if (len > 0 && b[len - 1] == ':')
 523             --len;
 524
 525           if (len > 0)
 526             b[len] = '\0';
 527           else
 528             {
 529               free (b);
 530               b = NULL;
 531             }
 532
 533           fclose (f);
 534
 535           if (b)
 536             {
 537               char *d = gld${EMULATION_NAME}_add_sysroot (b);
 538               free (b);
 539               b = d;
 540             }
 541
 542           ld_so_conf = b;
 543         }
 544
 545       initialized = TRUE;
 546     }
 547
 548   if (ld_so_conf == NULL)
 549     return FALSE;
 550
 551   return gld${EMULATION_NAME}_search_needed (ld_so_conf, name, force);
 552 }
 553
 554 EOF
 555     # Linux
 556     ;;
 557   esac
 558 fi
 559 cat >>e${EMULATION_NAME}.c <<EOF
 560
 561 /* See if an input file matches a DT_NEEDED entry by name.  */
 562
 563 static void
 564 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
 565 {
 566   if (global_found)
 567     return;
 568
 569   if (s->filename != NULL)
 570     {
 571       const char *f;
 572
 573       if (strcmp (s->filename, global_needed->name) == 0)
 574         {
 575           global_found = TRUE;
 576           return;
 577         }
 578
 579       if (s->search_dirs_flag)
 580         {
 581           f = strrchr (s->filename, '/');
 582           if (f != NULL
 583               && strcmp (f + 1, global_needed->name) == 0)
 584             {
 585               global_found = TRUE;
 586               return;
 587             }
 588         }
 589     }
 590
 591   if (s->the_bfd != NULL)
 592     {
 593       const char *soname;
 594
 595       soname = bfd_elf_get_dt_soname (s->the_bfd);
 596       if (soname != NULL
 597           && strcmp (soname, global_needed->name) == 0)
 598         {
 599           global_found = TRUE;
 600           return;
 601         }
 602     }
 603 }
 604
 605 EOF
 606
 607 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
 608 cat >>e${EMULATION_NAME}.c <<EOF
 609
 610 /* This is called after all the input files have been opened.  */
 611
 612 static void
 613 gld${EMULATION_NAME}_after_open (void)
 614 {
 615   struct bfd_link_needed_list *needed, *l;
 616
 617   /* We only need to worry about this when doing a final link.  */
 618   if (link_info.relocatable || !link_info.executable)
 619     return;
 620
 621   /* Get the list of files which appear in DT_NEEDED entries in
 622      dynamic objects included in the link (often there will be none).
 623      For each such file, we want to track down the corresponding
 624      library, and include the symbol table in the link.  This is what
 625      the runtime dynamic linker will do.  Tracking the files down here
 626      permits one dynamic object to include another without requiring
 627      special action by the person doing the link.  Note that the
 628      needed list can actually grow while we are stepping through this
 629      loop.  */
 630   needed = bfd_elf_get_needed_list (output_bfd, &link_info);
 631   for (l = needed; l != NULL; l = l->next)
 632     {
 633       struct bfd_link_needed_list *ll;
 634       int force;
 635
 636       /* If we've already seen this file, skip it.  */
 637       for (ll = needed; ll != l; ll = ll->next)
 638         if (strcmp (ll->name, l->name) == 0)
 639           break;
 640       if (ll != l)
 641         continue;
 642
 643       /* See if this file was included in the link explicitly.  */
 644       global_needed = l;
 645       global_found = FALSE;
 646       lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
 647       if (global_found)
 648         continue;
 649
 650       if (trace_file_tries)
 651         info_msg (_("%s needed by %B\n"), l->name, l->by);
 652
 653       /* We need to find this file and include the symbol table.  We
 654          want to search for the file in the same way that the dynamic
 655          linker will search.  That means that we want to use
 656          rpath_link, rpath, then the environment variable
 657          LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
 658          entries (native only), then the linker script LIB_SEARCH_DIRS.
 659          We do not search using the -L arguments.
 660
 661          We search twice.  The first time, we skip objects which may
 662          introduce version mismatches.  The second time, we force
 663          their use.  See gld${EMULATION_NAME}_vercheck comment.  */
 664       for (force = 0; force < 2; force++)
 665         {
 666           size_t len;
 667           search_dirs_type *search;
 668 EOF
 669 if [ "x${USE_LIBPATH}" = xyes ] ; then
 670 cat >>e${EMULATION_NAME}.c <<EOF
 671           const char *lib_path;
 672           struct bfd_link_needed_list *rp;
 673           int found;
 674 EOF
 675 fi
 676 cat >>e${EMULATION_NAME}.c <<EOF
 677
 678           if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
 679                                                   l->name, force))
 680             break;
 681 EOF
 682 if [ "x${USE_LIBPATH}" = xyes ] ; then
 683 cat >>e${EMULATION_NAME}.c <<EOF
 684           if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
 685                                                   l->name, force))
 686             break;
 687 EOF
 688 fi
 689 if [ "x${NATIVE}" = xyes ] ; then
 690 cat >>e${EMULATION_NAME}.c <<EOF
 691           if (command_line.rpath_link == NULL
 692               && command_line.rpath == NULL)
 693             {
 694               lib_path = (const char *) getenv ("LD_RUN_PATH");
 695               if (gld${EMULATION_NAME}_search_needed (lib_path, l->name,
 696                                                       force))
 697                 break;
 698             }
 699           lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
 700           if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, force))
 701             break;
 702 EOF
 703 fi
 704 if [ "x${USE_LIBPATH}" = xyes ] ; then
 705 cat >>e${EMULATION_NAME}.c <<EOF
 706           found = 0;
 707           rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
 708           for (; !found && rp != NULL; rp = rp->next)
 709             {
 710               char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
 711               found = (rp->by == l->by
 712                        && gld${EMULATION_NAME}_search_needed (tmpname,
 713                                                               l->name,
 714                                                               force));
 715               free (tmpname);
 716             }
 717           if (found)
 718             break;
 719
 720 EOF
 721 fi
 722 cat >>e${EMULATION_NAME}.c <<EOF
 723           len = strlen (l->name);
 724           for (search = search_head; search != NULL; search = search->next)
 725             {
 726               char *filename;
 727
 728               if (search->cmdline)
 729                 continue;
 730               filename = (char *) xmalloc (strlen (search->name) + len + 2);
 731               sprintf (filename, "%s/%s", search->name, l->name);
 732               if (gld${EMULATION_NAME}_try_needed (filename, force))
 733                 break;
 734               free (filename);
 735             }
 736           if (search != NULL)
 737             break;
 738 EOF
 739 if [ "x${USE_LIBPATH}" = xyes ] ; then
 740   case ${target} in
 741     *-*-linux-gnu*)
 742       cat >>e${EMULATION_NAME}.c <<EOF
 743           if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
 744             break;
 745 EOF
 746     # Linux
 747     ;;
 748   esac
 749 fi
 750 cat >>e${EMULATION_NAME}.c <<EOF
 751         }
 752
 753       if (force < 2)
 754         continue;
 755
 756       einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
 757              l->name, l->by);
 758     }
 759 }
 760
 761 EOF
 762 fi
 763
 764 cat >>e${EMULATION_NAME}.c <<EOF
 765
 766 /* Look through an expression for an assignment statement.  */
 767
 768 static void
 769 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
 770 {
 771   struct bfd_link_hash_entry *h;
 772
 773   switch (exp->type.node_class)
 774     {
 775     case etree_provide:
 776       h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
 777                                 FALSE, FALSE, FALSE);
 778       if (h == NULL)
 779         break;
 780
 781       /* We call record_link_assignment even if the symbol is defined.
 782          This is because if it is defined by a dynamic object, we
 783          actually want to use the value defined by the linker script,
 784          not the value from the dynamic object (because we are setting
 785          symbols like etext).  If the symbol is defined by a regular
 786          object, then, as it happens, calling record_link_assignment
 787          will do no harm.  */
 788
 789       /* Fall through.  */
 790     case etree_assign:
 791       if (strcmp (exp->assign.dst, ".") != 0)
 792         {
 793           if (! (bfd_elf_record_link_assignment
 794                  (output_bfd, &link_info, exp->assign.dst,
 795                   exp->type.node_class == etree_provide ? TRUE : FALSE)))
 796             einfo ("%P%F: failed to record assignment to %s: %E\n",
 797                    exp->assign.dst);
 798         }
 799       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
 800       break;
 801
 802     case etree_binary:
 803       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
 804       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
 805       break;
 806
 807     case etree_trinary:
 808       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
 809       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 810       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
 811       break;
 812
 813     case etree_unary:
 814       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
 815       break;
 816
 817     default:
 818       break;
 819     }
 820 }
 821
 822
 823 /* This is called by the before_allocation routine via
 824    lang_for_each_statement.  It locates any assignment statements, and
 825    tells the ELF backend about them, in case they are assignments to
 826    symbols which are referred to by dynamic objects.  */
 827
 828 static void
 829 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
 830 {
 831   if (s->header.type == lang_assignment_statement_enum)
 832     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
 833 }
 834
 835 EOF
 836
 837 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
 838   if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
 839     ELF_INTERPRETER_SET_DEFAULT="
 840   if (sinterp != NULL)
 841     {
 842       sinterp->contents = ${ELF_INTERPRETER_NAME};
 843       sinterp->_raw_size = strlen (sinterp->contents) + 1;
 844     }
 845
 846 "
 847   else
 848     ELF_INTERPRETER_SET_DEFAULT=
 849   fi
 850 cat >>e${EMULATION_NAME}.c <<EOF
 851
 852 /* This is called after the sections have been attached to output
 853    sections, but before any sizes or addresses have been set.  */
 854
 855 static void
 856 gld${EMULATION_NAME}_before_allocation (void)
 857 {
 858   const char *rpath;
 859   asection *sinterp;
 860
 861   if (link_info.hash->type == bfd_link_elf_hash_table)
 862     _bfd_elf_tls_setup (output_bfd, &link_info);
 863
 864   /* If we are going to make any variable assignments, we need to let
 865      the ELF backend know about them in case the variables are
 866      referred to by dynamic objects.  */
 867   lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
 868
 869   /* Let the ELF backend work out the sizes of any sections required
 870      by dynamic linking.  */
 871   rpath = command_line.rpath;
 872   if (rpath == NULL)
 873     rpath = (const char *) getenv ("LD_RUN_PATH");
 874   if (! (bfd_elf_size_dynamic_sections
 875          (output_bfd, command_line.soname, rpath,
 876           command_line.filter_shlib,
 877           (const char * const *) command_line.auxiliary_filters,
 878           &link_info, &sinterp, lang_elf_version_info)))
 879     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
 880 ${ELF_INTERPRETER_SET_DEFAULT}
 881   /* Let the user override the dynamic linker we are using.  */
 882   if (command_line.interpreter != NULL
 883       && sinterp != NULL)
 884     {
 885       sinterp->contents = (bfd_byte *) command_line.interpreter;
 886       sinterp->_raw_size = strlen (command_line.interpreter) + 1;
 887     }
 888
 889   /* Look for any sections named .gnu.warning.  As a GNU extensions,
 890      we treat such sections as containing warning messages.  We print
 891      out the warning message, and then zero out the section size so
 892      that it does not get copied into the output file.  */
 893
 894   {
 895     LANG_FOR_EACH_INPUT_STATEMENT (is)
 896       {
 897         asection *s;
 898         bfd_size_type sz;
 899         bfd_size_type prefix_len;
 900         char *msg;
 901         bfd_boolean ret;
 902         const char * gnu_warning_prefix = _("warning: ");
 903
 904         if (is->just_syms_flag)
 905           continue;
 906
 907         s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
 908         if (s == NULL)
 909           continue;
 910
 911         sz = bfd_section_size (is->the_bfd, s);
 912         prefix_len = strlen (gnu_warning_prefix);
 913         msg = xmalloc ((size_t) (prefix_len + sz + 1));
 914         strcpy (msg, gnu_warning_prefix);
 915         if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len,
 916                                         (file_ptr) 0, sz))
 917           einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
 918                  is->the_bfd);
 919         msg[prefix_len + sz] = '\0';
 920         ret = link_info.callbacks->warning (&link_info, msg,
 921                                             (const char *) NULL,
 922                                             is->the_bfd, (asection *) NULL,
 923                                             (bfd_vma) 0);
 924         ASSERT (ret);
 925         free (msg);
 926
 927         /* Clobber the section size, so that we don't waste copying the
 928            warning into the output file.  */
 929         s->_raw_size = 0;
 930       }
 931   }
 932 }
 933
 934 EOF
 935 fi
 936
 937 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
 938 cat >>e${EMULATION_NAME}.c <<EOF
 939
 940 /* Try to open a dynamic archive.  This is where we know that ELF
 941    dynamic libraries have an extension of .so (or .sl on oddball systems
 942    like hpux).  */
 943
 944 static bfd_boolean
 945 gld${EMULATION_NAME}_open_dynamic_archive
 946   (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
 947 {
 948   const char *filename;
 949   char *string;
 950
 951   if (! entry->is_archive)
 952     return FALSE;
 953
 954   filename = entry->filename;
 955
 956   /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
 957      is defined, but it does not seem worth the headache to optimize
 958      away those two bytes of space.  */
 959   string = (char *) xmalloc (strlen (search->name)
 960                              + strlen (filename)
 961                              + strlen (arch)
 962 #ifdef EXTRA_SHLIB_EXTENSION
 963                              + strlen (EXTRA_SHLIB_EXTENSION)
 964 #endif
 965                              + sizeof "/lib.so");
 966
 967   sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
 968
 969 #ifdef EXTRA_SHLIB_EXTENSION
 970   /* Try the .so extension first.  If that fails build a new filename
 971      using EXTRA_SHLIB_EXTENSION.  */
 972   if (! ldfile_try_open_bfd (string, entry))
 973     sprintf (string, "%s/lib%s%s%s", search->name,
 974              filename, arch, EXTRA_SHLIB_EXTENSION);
 975 #endif
 976
 977   if (! ldfile_try_open_bfd (string, entry))
 978     {
 979       free (string);
 980       return FALSE;
 981     }
 982
 983   entry->filename = string;
 984
 985   /* We have found a dynamic object to include in the link.  The ELF
 986      backend linker will create a DT_NEEDED entry in the .dynamic
 987      section naming this file.  If this file includes a DT_SONAME
 988      entry, it will be used.  Otherwise, the ELF linker will just use
 989      the name of the file.  For an archive found by searching, like
 990      this one, the DT_NEEDED entry should consist of just the name of
 991      the file, without the path information used to find it.  Note
 992      that we only need to do this if we have a dynamic object; an
 993      archive will never be referenced by a DT_NEEDED entry.
 994
 995      FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
 996      very pretty.  I haven't been able to think of anything that is
 997      pretty, though.  */
 998   if (bfd_check_format (entry->the_bfd, bfd_object)
 999       && (entry->the_bfd->flags & DYNAMIC) != 0)
1000     {
1001       ASSERT (entry->is_archive && entry->search_dirs_flag);
1002
1003       /* Rather than duplicating the logic above.  Just use the
1004          filename we recorded earlier.  */
1005
1006       filename = lbasename (entry->filename);
1007       bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1008     }
1009
1010   return TRUE;
1011 }
1012
1013 EOF
1014 fi
1015
1016 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1017 cat >>e${EMULATION_NAME}.c <<EOF
1018
1019 /* A variant of lang_output_section_find.  Used by place_orphan.  */
1020
1021 static lang_output_section_statement_type *
1022 output_rel_find (asection *sec, int isdyn)
1023 {
1024   lang_statement_union_type *u;
1025   lang_output_section_statement_type *lookup;
1026   lang_output_section_statement_type *last = NULL;
1027   lang_output_section_statement_type *last_alloc = NULL;
1028   lang_output_section_statement_type *last_rel = NULL;
1029   lang_output_section_statement_type *last_rel_alloc = NULL;
1030   int rela = sec->name[4] == 'a';
1031
1032   for (u = lang_output_section_statement.head; u; u = lookup->next)
1033     {
1034       lookup = &u->output_section_statement;
1035       if (strncmp (".rel", lookup->name, 4) == 0)
1036         {
1037           int lookrela = lookup->name[4] == 'a';
1038
1039           /* .rel.dyn must come before all other reloc sections, to suit
1040              GNU ld.so.  */
1041           if (isdyn)
1042             break;
1043
1044           /* Don't place after .rel.plt as doing so results in wrong
1045              dynamic tags.  */
1046           if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1047             break;
1048
1049           if (rela == lookrela || last_rel == NULL)
1050             last_rel = lookup;
1051           if ((rela == lookrela || last_rel_alloc == NULL)
1052               && lookup->bfd_section != NULL
1053               && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1054             last_rel_alloc = lookup;
1055         }
1056
1057       last = lookup;
1058       if (lookup->bfd_section != NULL
1059           && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1060         last_alloc = lookup;
1061     }
1062
1063   if (last_rel_alloc)
1064     return last_rel_alloc;
1065
1066   if (last_rel)
1067     return last_rel;
1068
1069   if (last_alloc)
1070     return last_alloc;
1071
1072   return last;
1073 }
1074
1075 /* Find the last output section before given output statement.
1076    Used by place_orphan.  */
1077
1078 static asection *
1079 output_prev_sec_find (lang_output_section_statement_type *os)
1080 {
1081   asection *s = (asection *) NULL;
1082   lang_statement_union_type *u;
1083   lang_output_section_statement_type *lookup;
1084
1085   for (u = lang_output_section_statement.head;
1086        u != (lang_statement_union_type *) NULL;
1087        u = lookup->next)
1088     {
1089       lookup = &u->output_section_statement;
1090       if (lookup == os)
1091         return s;
1092
1093       if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1094         s = lookup->bfd_section;
1095     }
1096
1097   return NULL;
1098 }
1099
1100 /* Place an orphan section.  We use this to put random SHF_ALLOC
1101    sections in the right segment.  */
1102
1103 struct orphan_save {
1104   lang_output_section_statement_type *os;
1105   asection **section;
1106   lang_statement_union_type **stmt;
1107   lang_statement_union_type **os_tail;
1108 };
1109
1110 static bfd_boolean
1111 gld${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1112 {
1113   static struct orphan_save hold_text;
1114   static struct orphan_save hold_rodata;
1115   static struct orphan_save hold_data;
1116   static struct orphan_save hold_bss;
1117   static struct orphan_save hold_rel;
1118   static struct orphan_save hold_interp;
1119   static struct orphan_save hold_sdata;
1120   static int count = 1;
1121   struct orphan_save *place;
1122   lang_statement_list_type *old;
1123   lang_statement_list_type add;
1124   etree_type *address;
1125   const char *secname;
1126   const char *ps = NULL;
1127   lang_output_section_statement_type *os;
1128   lang_statement_union_type **os_tail;
1129   etree_type *load_base;
1130   int isdyn = 0;
1131
1132   secname = bfd_get_section_name (s->owner, s);
1133   if (! link_info.relocatable
1134       && link_info.combreloc
1135       && (s->flags & SEC_ALLOC)
1136       && strncmp (secname, ".rel", 4) == 0)
1137     {
1138       if (secname[4] == 'a')
1139         secname = ".rela.dyn";
1140       else
1141         secname = ".rel.dyn";
1142       isdyn = 1;
1143     }
1144
1145   if (isdyn || (!config.unique_orphan_sections && !unique_section_p (secname)))
1146     {
1147       /* Look through the script to see where to place this section.  */
1148       os = lang_output_section_find (secname);
1149
1150       if (os != NULL
1151           && (os->bfd_section == NULL
1152               || ((s->flags ^ os->bfd_section->flags)
1153                   & (SEC_LOAD | SEC_ALLOC)) == 0))
1154         {
1155           /* We already have an output section statement with this
1156              name, and its bfd section, if any, has compatible flags.  */
1157           lang_add_section (&os->children, s, os, file);
1158           return TRUE;
1159         }
1160     }
1161
1162   if (hold_text.os == NULL)
1163     hold_text.os = lang_output_section_find (".text");
1164
1165   /* If this is a final link, then always put .gnu.warning.SYMBOL
1166      sections into the .text section to get them out of the way.  */
1167   if (link_info.executable
1168       && ! link_info.relocatable
1169       && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1170       && hold_text.os != NULL)
1171     {
1172       lang_add_section (&hold_text.os->children, s, hold_text.os, file);
1173       return TRUE;
1174     }
1175
1176   /* Decide which segment the section should go in based on the
1177      section name and section flags.  We put loadable .note sections
1178      right after the .interp section, so that the PT_NOTE segment is
1179      stored right after the program headers where the OS can read it
1180      in the first page.  */
1181 #define HAVE_SECTION(hold, name) \
1182 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1183
1184   if ((s->flags & SEC_EXCLUDE) != 0 && !link_info.relocatable)
1185     {
1186       if (s->output_section == NULL)
1187         s->output_section = bfd_abs_section_ptr;
1188       return TRUE;
1189     }
1190
1191   place = NULL;
1192   if ((s->flags & SEC_ALLOC) == 0)
1193     ;
1194   else if ((s->flags & SEC_LOAD) != 0
1195            && strncmp (secname, ".note", 5) == 0
1196            && HAVE_SECTION (hold_interp, ".interp"))
1197     place = &hold_interp;
1198   else if ((s->flags & SEC_HAS_CONTENTS) == 0
1199            && HAVE_SECTION (hold_bss, ".bss"))
1200     place = &hold_bss;
1201   else if ((s->flags & SEC_SMALL_DATA) != 0
1202            && HAVE_SECTION (hold_sdata, ".sdata"))
1203     place = &hold_sdata;
1204   else if ((s->flags & SEC_READONLY) == 0
1205            && HAVE_SECTION (hold_data, ".data"))
1206     place = &hold_data;
1207   else if (strncmp (secname, ".rel", 4) == 0
1208            && (s->flags & SEC_LOAD) != 0
1209            && (hold_rel.os != NULL
1210                || (hold_rel.os = output_rel_find (s, isdyn)) != NULL))
1211     place = &hold_rel;
1212   else if ((s->flags & (SEC_CODE | SEC_READONLY)) == SEC_READONLY
1213            && HAVE_SECTION (hold_rodata, ".rodata"))
1214     place = &hold_rodata;
1215   else if ((s->flags & (SEC_CODE | SEC_READONLY)) == (SEC_CODE | SEC_READONLY)
1216            && hold_text.os != NULL)
1217     place = &hold_text;
1218
1219 #undef HAVE_SECTION
1220
1221   /* Choose a unique name for the section.  This will be needed if the
1222      same section name appears in the input file with different
1223      loadable or allocatable characteristics.  */
1224   if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1225     {
1226       secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1227       if (secname == NULL)
1228         einfo ("%F%P: place_orphan failed: %E\n");
1229     }
1230
1231   /* Start building a list of statements for this section.
1232      First save the current statement pointer.  */
1233   old = stat_ptr;
1234
1235   /* If we have found an appropriate place for the output section
1236      statements for this orphan, add them to our own private list,
1237      inserting them later into the global statement list.  */
1238   if (place != NULL)
1239     {
1240       stat_ptr = &add;
1241       lang_list_init (stat_ptr);
1242     }
1243
1244   if (config.build_constructors)
1245     {
1246       /* If the name of the section is representable in C, then create
1247          symbols to mark the start and the end of the section.  */
1248       for (ps = secname; *ps != '\0'; ps++)
1249         if (! ISALNUM (*ps) && *ps != '_')
1250           break;
1251       if (*ps == '\0')
1252         {
1253           char *symname;
1254           etree_type *e_align;
1255
1256           symname = (char *) xmalloc (ps - secname + sizeof "__start_");
1257           sprintf (symname, "__start_%s", secname);
1258           e_align = exp_unop (ALIGN_K,
1259                               exp_intop ((bfd_vma) 1 << s->alignment_power));
1260           lang_add_assignment (exp_assop ('=', symname, e_align));
1261         }
1262     }
1263
1264   address = NULL;
1265   if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1266     address = exp_intop ((bfd_vma) 0);
1267
1268   load_base = NULL;
1269   if (place != NULL && place->os->load_base != NULL)
1270     {
1271       etree_type *lma_from_vma;
1272       lma_from_vma = exp_binop ('-', place->os->load_base,
1273                                 exp_nameop (ADDR, place->os->name));
1274       load_base = exp_binop ('+', lma_from_vma,
1275                              exp_nameop (ADDR, secname));
1276     }
1277
1278   os_tail = lang_output_section_statement.tail;
1279   os = lang_enter_output_section_statement (secname, address, 0,
1280                                             (etree_type *) NULL,
1281                                             (etree_type *) NULL,
1282                                             load_base);
1283
1284   lang_add_section (&os->children, s, os, file);
1285
1286   lang_leave_output_section_statement
1287     ((bfd_vma) 0, "*default*",
1288      (struct lang_output_section_phdr_list *) NULL, NULL);
1289
1290   if (config.build_constructors && *ps == '\0')
1291     {
1292       char *symname;
1293
1294       /* lang_leave_ouput_section_statement resets stat_ptr.  Put
1295          stat_ptr back where we want it.  */
1296       if (place != NULL)
1297         stat_ptr = &add;
1298
1299       symname = (char *) xmalloc (ps - secname + sizeof "__stop_");
1300       sprintf (symname, "__stop_%s", secname);
1301       lang_add_assignment (exp_assop ('=', symname,
1302                                       exp_nameop (NAME, ".")));
1303     }
1304
1305   /* Restore the global list pointer.  */
1306   stat_ptr = old;
1307
1308   if (place != NULL && os->bfd_section != NULL)
1309     {
1310       asection *snew, **pps;
1311
1312       snew = os->bfd_section;
1313
1314       /* Shuffle the bfd section list to make the output file look
1315          neater.  This is really only cosmetic.  */
1316       if (place->section == NULL)
1317         {
1318           asection *bfd_section = place->os->bfd_section;
1319
1320           /* If the output statement hasn't been used to place
1321              any input sections (and thus doesn't have an output
1322              bfd_section), look for the closest prior output statement
1323              having an output section.  */
1324           if (bfd_section == NULL)
1325             bfd_section = output_prev_sec_find (place->os);
1326
1327           if (bfd_section != NULL && bfd_section != snew)
1328             place->section = &bfd_section->next;
1329         }
1330
1331       if (place->section != NULL)
1332         {
1333           /* Unlink the section.  */
1334           for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1335             ;
1336           bfd_section_list_remove (output_bfd, pps);
1337
1338           /* Now tack it on to the "place->os" section list.  */
1339           bfd_section_list_insert (output_bfd, place->section, snew);
1340         }
1341
1342       /* Save the end of this list.  Further ophans of this type will
1343          follow the one we've just added.  */
1344       place->section = &snew->next;
1345
1346       /* The following is non-cosmetic.  We try to put the output
1347          statements in some sort of reasonable order here, because
1348          they determine the final load addresses of the orphan
1349          sections.  In addition, placing output statements in the
1350          wrong order may require extra segments.  For instance,
1351          given a typical situation of all read-only sections placed
1352          in one segment and following that a segment containing all
1353          the read-write sections, we wouldn't want to place an orphan
1354          read/write section before or amongst the read-only ones.  */
1355       if (add.head != NULL)
1356         {
1357           lang_statement_union_type *newly_added_os;
1358
1359           if (place->stmt == NULL)
1360             {
1361               /* Put the new statement list right at the head.  */
1362               *add.tail = place->os->header.next;
1363               place->os->header.next = add.head;
1364
1365               place->os_tail = &place->os->next;
1366             }
1367           else
1368             {
1369               /* Put it after the last orphan statement we added.  */
1370               *add.tail = *place->stmt;
1371               *place->stmt = add.head;
1372             }
1373
1374           /* Fix the global list pointer if we happened to tack our
1375              new list at the tail.  */
1376           if (*old->tail == add.head)
1377             old->tail = add.tail;
1378
1379           /* Save the end of this list.  */
1380           place->stmt = add.tail;
1381
1382           /* Do the same for the list of output section statements.  */
1383           newly_added_os = *os_tail;
1384           *os_tail = NULL;
1385           newly_added_os->output_section_statement.next = *place->os_tail;
1386           *place->os_tail = newly_added_os;
1387           place->os_tail = &newly_added_os->output_section_statement.next;
1388
1389           /* Fixing the global list pointer here is a little different.
1390              We added to the list in lang_enter_output_section_statement,
1391              trimmed off the new output_section_statment above when
1392              assigning *os_tail = NULL, but possibly added it back in
1393              the same place when assigning *place->os_tail.  */
1394           if (*os_tail == NULL)
1395             lang_output_section_statement.tail = os_tail;
1396         }
1397     }
1398
1399   return TRUE;
1400 }
1401 EOF
1402 fi
1403
1404 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1405 cat >>e${EMULATION_NAME}.c <<EOF
1406
1407 static void
1408 gld${EMULATION_NAME}_finish (void)
1409 {
1410   if (bfd_elf_discard_info (output_bfd, &link_info))
1411     {
1412       lang_reset_memory_regions ();
1413
1414       /* Resize the sections.  */
1415       lang_size_sections (stat_ptr->head, abs_output_section,
1416                           &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
1417
1418       /* Redo special stuff.  */
1419       ldemul_after_allocation ();
1420
1421       /* Do the assignments again.  */
1422       lang_do_assignments (stat_ptr->head, abs_output_section,
1423                            (fill_type *) 0, (bfd_vma) 0);
1424     }
1425 }
1426 EOF
1427 fi
1428
1429 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1430 cat >>e${EMULATION_NAME}.c <<EOF
1431
1432 static char *
1433 gld${EMULATION_NAME}_get_script (int *isfile)
1434 EOF
1435
1436 if test -n "$COMPILE_IN"
1437 then
1438 # Scripts compiled in.
1439
1440 # sed commands to quote an ld script as a C string.
1441 sc="-f stringify.sed"
1442
1443 cat >>e${EMULATION_NAME}.c <<EOF
1444 {
1445   *isfile = 0;
1446
1447   if (link_info.relocatable && config.build_constructors)
1448     return
1449 EOF
1450 sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
1451 echo '  ; else if (link_info.relocatable) return'     >> e${EMULATION_NAME}.c
1452 sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
1453 echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
1454 sed $sc ldscripts/${EMULATION_NAME}.xbn                >> e${EMULATION_NAME}.c
1455 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1456 echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1457 sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
1458 fi
1459 if test -n "$GENERATE_PIE_SCRIPT" ; then
1460 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1461 echo '  ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1462 sed $sc ldscripts/${EMULATION_NAME}.xdc                >> e${EMULATION_NAME}.c
1463 fi
1464 echo '  ; else if (link_info.pie) return'              >> e${EMULATION_NAME}.c
1465 sed $sc ldscripts/${EMULATION_NAME}.xd                 >> e${EMULATION_NAME}.c
1466 fi
1467 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1468 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1469 echo '  ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1470 sed $sc ldscripts/${EMULATION_NAME}.xsc                >> e${EMULATION_NAME}.c
1471 fi
1472 echo '  ; else if (link_info.shared) return'           >> e${EMULATION_NAME}.c
1473 sed $sc ldscripts/${EMULATION_NAME}.xs                 >> e${EMULATION_NAME}.c
1474 fi
1475 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1476 echo '  ; else if (link_info.combreloc) return'        >> e${EMULATION_NAME}.c
1477 sed $sc ldscripts/${EMULATION_NAME}.xc                 >> e${EMULATION_NAME}.c
1478 fi
1479 echo '  ; else return'                                 >> e${EMULATION_NAME}.c
1480 sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
1481 echo '; }'                                             >> e${EMULATION_NAME}.c
1482
1483 else
1484 # Scripts read from the filesystem.
1485
1486 cat >>e${EMULATION_NAME}.c <<EOF
1487 {
1488   *isfile = 1;
1489
1490   if (link_info.relocatable && config.build_constructors)
1491     return "ldscripts/${EMULATION_NAME}.xu";
1492   else if (link_info.relocatable)
1493     return "ldscripts/${EMULATION_NAME}.xr";
1494   else if (!config.text_read_only)
1495     return "ldscripts/${EMULATION_NAME}.xbn";
1496 EOF
1497 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1498 else
1499 cat >>e${EMULATION_NAME}.c <<EOF
1500   else if (!config.magic_demand_paged)
1501     return "ldscripts/${EMULATION_NAME}.xn";
1502 EOF
1503 fi
1504 if test -n "$GENERATE_PIE_SCRIPT" ; then
1505 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1506 cat >>e${EMULATION_NAME}.c <<EOF
1507   else if (link_info.pie && link_info.combreloc)
1508     return "ldscripts/${EMULATION_NAME}.xdc";
1509 EOF
1510 fi
1511 cat >>e${EMULATION_NAME}.c <<EOF
1512   else if (link_info.pie)
1513     return "ldscripts/${EMULATION_NAME}.xd";
1514 EOF
1515 fi
1516 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1517 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1518 cat >>e${EMULATION_NAME}.c <<EOF
1519   else if (link_info.shared && link_info.combreloc)
1520     return "ldscripts/${EMULATION_NAME}.xsc";
1521 EOF
1522 fi
1523 cat >>e${EMULATION_NAME}.c <<EOF
1524   else if (link_info.shared)
1525     return "ldscripts/${EMULATION_NAME}.xs";
1526 EOF
1527 fi
1528 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1529 cat >>e${EMULATION_NAME}.c <<EOF
1530   else if (link_info.combreloc)
1531     return "ldscripts/${EMULATION_NAME}.xc";
1532 EOF
1533 fi
1534 cat >>e${EMULATION_NAME}.c <<EOF
1535   else
1536     return "ldscripts/${EMULATION_NAME}.x";
1537 }
1538
1539 EOF
1540 fi
1541 fi
1542
1543 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1544
1545 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1546 cat >>e${EMULATION_NAME}.c <<EOF
1547  $PARSE_AND_LIST_PROLOGUE
1548 EOF
1549 fi
1550
1551 cat >>e${EMULATION_NAME}.c <<EOF
1552
1553 #define OPTION_DISABLE_NEW_DTAGS        (400)
1554 #define OPTION_ENABLE_NEW_DTAGS         (OPTION_DISABLE_NEW_DTAGS + 1)
1555 #define OPTION_GROUP                    (OPTION_ENABLE_NEW_DTAGS + 1)
1556 #define OPTION_EH_FRAME_HDR             (OPTION_GROUP + 1)
1557
1558 static void
1559 gld${EMULATION_NAME}_add_options
1560   (int ns, char **shortopts, int nl, struct option **longopts,
1561    int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1562 {
1563   static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1564   static const struct option xtra_long[] = {
1565 EOF
1566
1567 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1568 cat >>e${EMULATION_NAME}.c <<EOF
1569     {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1570     {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1571     {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1572     {"Bgroup", no_argument, NULL, OPTION_GROUP},
1573 EOF
1574 fi
1575
1576 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1577 cat >>e${EMULATION_NAME}.c <<EOF
1578     $PARSE_AND_LIST_LONGOPTS
1579 EOF
1580 fi
1581
1582 cat >>e${EMULATION_NAME}.c <<EOF
1583     {NULL, no_argument, NULL, 0}
1584   };
1585
1586   *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1587   memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1588   *longopts = (struct option *)
1589     xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1590   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1591 }
1592
1593 static bfd_boolean
1594 gld${EMULATION_NAME}_handle_option (int optc)
1595 {
1596   switch (optc)
1597     {
1598     default:
1599       return FALSE;
1600
1601 EOF
1602
1603 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1604 cat >>e${EMULATION_NAME}.c <<EOF
1605     case OPTION_DISABLE_NEW_DTAGS:
1606       link_info.new_dtags = FALSE;
1607       break;
1608
1609     case OPTION_ENABLE_NEW_DTAGS:
1610       link_info.new_dtags = TRUE;
1611       break;
1612
1613     case OPTION_EH_FRAME_HDR:
1614       link_info.eh_frame_hdr = TRUE;
1615       break;
1616
1617     case OPTION_GROUP:
1618       link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1619       /* Groups must be self-contained.  */
1620       link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1621       link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1622       break;
1623
1624     case 'z':
1625       if (strcmp (optarg, "initfirst") == 0)
1626         link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1627       else if (strcmp (optarg, "interpose") == 0)
1628         link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1629       else if (strcmp (optarg, "loadfltr") == 0)
1630         link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1631       else if (strcmp (optarg, "nodefaultlib") == 0)
1632         link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1633       else if (strcmp (optarg, "nodelete") == 0)
1634         link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1635       else if (strcmp (optarg, "nodlopen") == 0)
1636         link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1637       else if (strcmp (optarg, "nodump") == 0)
1638         link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1639       else if (strcmp (optarg, "now") == 0)
1640         {
1641           link_info.flags |= (bfd_vma) DF_BIND_NOW;
1642           link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1643         }
1644       else if (strcmp (optarg, "origin") == 0)
1645         {
1646           link_info.flags |= (bfd_vma) DF_ORIGIN;
1647           link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1648         }
1649       else if (strcmp (optarg, "defs") == 0)
1650         link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1651       else if (strcmp (optarg, "muldefs") == 0)
1652         link_info.allow_multiple_definition = TRUE;
1653       else if (strcmp (optarg, "combreloc") == 0)
1654         link_info.combreloc = TRUE;
1655       else if (strcmp (optarg, "nocombreloc") == 0)
1656         link_info.combreloc = FALSE;
1657       else if (strcmp (optarg, "nocopyreloc") == 0)
1658         link_info.nocopyreloc = TRUE;
1659       else if (strcmp (optarg, "execstack") == 0)
1660         {
1661           link_info.execstack = TRUE;
1662           link_info.noexecstack = FALSE;
1663         }
1664       else if (strcmp (optarg, "noexecstack") == 0)
1665         {
1666           link_info.noexecstack = TRUE;
1667           link_info.execstack = FALSE;
1668         }
1669       /* What about the other Solaris -z options? FIXME.  */
1670       break;
1671 EOF
1672 fi
1673
1674 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1675 cat >>e${EMULATION_NAME}.c <<EOF
1676  $PARSE_AND_LIST_ARGS_CASES
1677 EOF
1678 fi
1679
1680 cat >>e${EMULATION_NAME}.c <<EOF
1681     }
1682
1683   return TRUE;
1684 }
1685
1686 EOF
1687
1688 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1689 cat >>e${EMULATION_NAME}.c <<EOF
1690
1691 static void
1692 gld${EMULATION_NAME}_list_options (FILE * file)
1693 {
1694 EOF
1695
1696 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1697 cat >>e${EMULATION_NAME}.c <<EOF
1698   fprintf (file, _("  -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1699   fprintf (file, _("  --disable-new-dtags\tDisable new dynamic tags\n"));
1700   fprintf (file, _("  --enable-new-dtags\tEnable new dynamic tags\n"));
1701   fprintf (file, _("  --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1702   fprintf (file, _("  -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1703   fprintf (file, _("  -z defs\t\tReport unresolved symbols in object files.\n"));
1704   fprintf (file, _("  -z execstack\t\tMark executable as requiring executable stack\n"));
1705   fprintf (file, _("  -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1706   fprintf (file, _("  -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1707   fprintf (file, _("  -z loadfltr\t\tMark object requiring immediate process\n"));
1708   fprintf (file, _("  -z muldefs\t\tAllow multiple definitions\n"));
1709   fprintf (file, _("  -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1710   fprintf (file, _("  -z nocopyreloc\tDon't create copy relocs\n"));
1711   fprintf (file, _("  -z nodefaultlib\tMark object not to use default search paths\n"));
1712   fprintf (file, _("  -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1713   fprintf (file, _("  -z nodlopen\t\tMark DSO not available to dlopen\n"));
1714   fprintf (file, _("  -z nodump\t\tMark DSO not available to dldump\n"));
1715   fprintf (file, _("  -z noexecstack\tMark executable as not requiring executable stack\n"));
1716   fprintf (file, _("  -z now\t\tMark object non-lazy runtime binding\n"));
1717   fprintf (file, _("  -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t  at runtime\n"));
1718   fprintf (file, _("  -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1719 EOF
1720 fi
1721
1722 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1723 cat >>e${EMULATION_NAME}.c <<EOF
1724  $PARSE_AND_LIST_OPTIONS
1725 EOF
1726 fi
1727
1728 cat >>e${EMULATION_NAME}.c <<EOF
1729 }
1730 EOF
1731
1732 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1733 cat >>e${EMULATION_NAME}.c <<EOF
1734  $PARSE_AND_LIST_EPILOGUE
1735 EOF
1736 fi
1737 fi
1738 else
1739 cat >>e${EMULATION_NAME}.c <<EOF
1740 #define gld${EMULATION_NAME}_add_options NULL
1741 #define gld${EMULATION_NAME}_handle_option NULL
1742 EOF
1743 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1744 cat >>e${EMULATION_NAME}.c <<EOF
1745 #define gld${EMULATION_NAME}_list_options NULL
1746 EOF
1747 fi
1748 fi
1749
1750 cat >>e${EMULATION_NAME}.c <<EOF
1751
1752 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1753 {
1754   ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1755   ${LDEMUL_SYSLIB-syslib_default},
1756   ${LDEMUL_HLL-hll_default},
1757   ${LDEMUL_AFTER_PARSE-after_parse_default},
1758   ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1759   ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1760   ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1761   ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1762   ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1763   ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1764   "${EMULATION_NAME}",
1765   "${OUTPUT_FORMAT}",
1766   ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1767   ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1768   ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1769   ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1770   ${LDEMUL_SET_SYMBOLS-NULL},
1771   ${LDEMUL_PARSE_ARGS-NULL},
1772   gld${EMULATION_NAME}_add_options,
1773   gld${EMULATION_NAME}_handle_option,
1774   ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1775   ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1776   ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
1777   ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1778   ${LDEMUL_NEW_VERS_PATTERN-NULL}
1779 };
1780 EOF