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