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