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