contrib/binutils/ld/emultempl/elf32.em

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