ld/emultempl/elf32.em

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