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