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