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