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