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    2002, 2003, 2004, 2005 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 #include "getopt.h"
  43
  44 #include "bfdlink.h"
  45
  46 #include "ld.h"
  47 #include "ldmain.h"
  48 #include "ldmisc.h"
  49 #include "ldexp.h"
  50 #include "ldlang.h"
  51 #include "ldfile.h"
  52 #include "ldemul.h"
  53 #include <ldgram.h>
  54 #include "elf/common.h"
  55
  56 /* Declare functions used by various EXTRA_EM_FILEs.  */
  57 static void gld${EMULATION_NAME}_before_parse (void);
  58 static void gld${EMULATION_NAME}_after_open (void);
  59 static void gld${EMULATION_NAME}_before_allocation (void);
  60 static bfd_boolean gld${EMULATION_NAME}_place_orphan
  61   (lang_input_statement_type *file, asection *s);
  62 static void gld${EMULATION_NAME}_finish (void);
  63
  64 EOF
  65
  66 if [ "x${USE_LIBPATH}" = xyes ] ; then
  67   case ${target} in
  68     *-*-linux-gnu*)
  69   cat >>e${EMULATION_NAME}.c <<EOF
  70 #ifdef HAVE_GLOB
  71 #include <glob.h>
  72 #endif
  73 EOF
  74     ;;
  75   esac
  76 fi
  77
  78 # Import any needed special functions and/or overrides.
  79 #
  80 if test -n "$EXTRA_EM_FILE" ; then
  81 . ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
  82 fi
  83
  84 # Functions in this file can be overridden by setting the LDEMUL_* shell
  85 # variables.  If the name of the overriding function is the same as is
  86 # defined in this file, then don't output this file's version.
  87 # If a different overriding name is given then output the standard function
  88 # as presumably it is called from the overriding function.
  89 #
  90 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
  91 cat >>e${EMULATION_NAME}.c <<EOF
  92
  93 static void
  94 gld${EMULATION_NAME}_before_parse (void)
  95 {
  96   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
  97   config.dynamic_link = ${DYNAMIC_LINK-TRUE};
  98   config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
  99 }
 100
 101 EOF
 102 fi
 103
 104 if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
 105 cat >>e${EMULATION_NAME}.c <<EOF
 106 /* Handle as_needed DT_NEEDED.  */
 107
 108 static bfd_boolean
 109 gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
 110 {
 111   int class = 0;
 112
 113   /* Tell the ELF linker that we don't want the output file to have a
 114      DT_NEEDED entry for this file, unless it is used to resolve
 115      references in a regular object.  */
 116   if (entry->as_needed)
 117     class = DYN_AS_NEEDED;
 118
 119   /* Tell the ELF linker that we don't want the output file to have a
 120      DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
 121      this file at all.  */
 122   if (!entry->add_needed)
 123     class |= DYN_NO_ADD_NEEDED;
 124
 125   if (!class
 126       || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
 127     return FALSE;
 128
 129   bfd_elf_set_dyn_lib_class (entry->the_bfd, class);
 130
 131   /* Continue on with normal load_symbols processing.  */
 132   return FALSE;
 133 }
 134 EOF
 135 fi
 136
 137 cat >>e${EMULATION_NAME}.c <<EOF
 138
 139 /* These variables are required to pass information back and forth
 140    between after_open and check_needed and stat_needed and vercheck.  */
 141
 142 static struct bfd_link_needed_list *global_needed;
 143 static struct stat global_stat;
 144 static bfd_boolean global_found;
 145 static struct bfd_link_needed_list *global_vercheck_needed;
 146 static bfd_boolean global_vercheck_failed;
 147
 148
 149 /* On Linux, it's possible to have different versions of the same
 150    shared library linked against different versions of libc.  The
 151    dynamic linker somehow tags which libc version to use in
 152    /etc/ld.so.cache, and, based on the libc that it sees in the
 153    executable, chooses which version of the shared library to use.
 154
 155    We try to do a similar check here by checking whether this shared
 156    library needs any other shared libraries which may conflict with
 157    libraries we have already included in the link.  If it does, we
 158    skip it, and try to find another shared library farther on down the
 159    link path.
 160
 161    This is called via lang_for_each_input_file.
 162    GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
 163    which we are checking.  This sets GLOBAL_VERCHECK_FAILED if we find
 164    a conflicting version.  */
 165
 166 static void
 167 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
 168 {
 169   const char *soname;
 170   struct bfd_link_needed_list *l;
 171
 172   if (global_vercheck_failed)
 173     return;
 174   if (s->the_bfd == NULL
 175       || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
 176     return;
 177
 178   soname = bfd_elf_get_dt_soname (s->the_bfd);
 179   if (soname == NULL)
 180     soname = lbasename (bfd_get_filename (s->the_bfd));
 181
 182   for (l = global_vercheck_needed; l != NULL; l = l->next)
 183     {
 184       const char *suffix;
 185
 186       if (strcmp (soname, l->name) == 0)
 187         {
 188           /* Probably can't happen, but it's an easy check.  */
 189           continue;
 190         }
 191
 192       if (strchr (l->name, '/') != NULL)
 193         continue;
 194
 195       suffix = strstr (l->name, ".so.");
 196       if (suffix == NULL)
 197         continue;
 198
 199       suffix += sizeof ".so." - 1;
 200
 201       if (strncmp (soname, l->name, suffix - l->name) == 0)
 202         {
 203           /* Here we know that S is a dynamic object FOO.SO.VER1, and
 204              the object we are considering needs a dynamic object
 205              FOO.SO.VER2, and VER1 and VER2 are different.  This
 206              appears to be a version mismatch, so we tell the caller
 207              to try a different version of this library.  */
 208           global_vercheck_failed = TRUE;
 209           return;
 210         }
 211     }
 212 }
 213
 214
 215 /* See if an input file matches a DT_NEEDED entry by running stat on
 216    the file.  */
 217
 218 static void
 219 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
 220 {
 221   struct stat st;
 222   const char *suffix;
 223   const char *soname;
 224
 225   if (global_found)
 226     return;
 227   if (s->the_bfd == NULL)
 228     return;
 229
 230   if (bfd_stat (s->the_bfd, &st) != 0)
 231     {
 232       einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
 233       return;
 234     }
 235
 236   /* Some operating systems, e.g. Windows, do not provide a meaningful
 237      st_ino; they always set it to zero.  (Windows does provide a
 238      meaningful st_dev.)  Do not indicate a duplicate library in that
 239      case.  While there is no guarantee that a system that provides
 240      meaningful inode numbers will never set st_ino to zero, this is
 241      merely an optimization, so we do not need to worry about false
 242      negatives.  */
 243   if (st.st_dev == global_stat.st_dev
 244       && st.st_ino == global_stat.st_ino
 245       && st.st_ino != 0)
 246     {
 247       global_found = TRUE;
 248       return;
 249     }
 250
 251   /* We issue a warning if it looks like we are including two
 252      different versions of the same shared library.  For example,
 253      there may be a problem if -lc picks up libc.so.6 but some other
 254      shared library has a DT_NEEDED entry of libc.so.5.  This is a
 255      heuristic test, and it will only work if the name looks like
 256      NAME.so.VERSION.  FIXME: Depending on file names is error-prone.
 257      If we really want to issue warnings about mixing version numbers
 258      of shared libraries, we need to find a better way.  */
 259
 260   if (strchr (global_needed->name, '/') != NULL)
 261     return;
 262   suffix = strstr (global_needed->name, ".so.");
 263   if (suffix == NULL)
 264     return;
 265   suffix += sizeof ".so." - 1;
 266
 267   soname = bfd_elf_get_dt_soname (s->the_bfd);
 268   if (soname == NULL)
 269     soname = lbasename (s->filename);
 270
 271   if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
 272     einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
 273            global_needed->name, global_needed->by, soname);
 274 }
 275
 276 struct dt_needed
 277 {
 278   bfd *by;
 279   const char *name;
 280 };
 281
 282 /* This function is called for each possible name for a dynamic object
 283    named by a DT_NEEDED entry.  The FORCE parameter indicates whether
 284    to skip the check for a conflicting version.  */
 285
 286 static bfd_boolean
 287 gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
 288                                  int force)
 289 {
 290   bfd *abfd;
 291   const char *name = needed->name;
 292   const char *soname;
 293   int class;
 294
 295   abfd = bfd_openr (name, bfd_get_target (output_bfd));
 296   if (abfd == NULL)
 297     return FALSE;
 298   if (! bfd_check_format (abfd, bfd_object))
 299     {
 300       bfd_close (abfd);
 301       return FALSE;
 302     }
 303   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 304     {
 305       bfd_close (abfd);
 306       return FALSE;
 307     }
 308
 309   /* For DT_NEEDED, they have to match.  */
 310   if (abfd->xvec != output_bfd->xvec)
 311     {
 312       bfd_close (abfd);
 313       return FALSE;
 314     }
 315
 316   /* Check whether this object would include any conflicting library
 317      versions.  If FORCE is set, then we skip this check; we use this
 318      the second time around, if we couldn't find any compatible
 319      instance of the shared library.  */
 320
 321   if (! force)
 322     {
 323       struct bfd_link_needed_list *needed;
 324
 325       if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
 326         einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
 327
 328       if (needed != NULL)
 329         {
 330           global_vercheck_needed = needed;
 331           global_vercheck_failed = FALSE;
 332           lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
 333           if (global_vercheck_failed)
 334             {
 335               bfd_close (abfd);
 336               /* Return FALSE to force the caller to move on to try
 337                  another file on the search path.  */
 338               return FALSE;
 339             }
 340
 341           /* But wait!  It gets much worse.  On Linux, if a shared
 342              library does not use libc at all, we are supposed to skip
 343              it the first time around in case we encounter a shared
 344              library later on with the same name which does use the
 345              version of libc that we want.  This is much too horrible
 346              to use on any system other than Linux.  */
 347
 348 EOF
 349 case ${target} in
 350   *-*-linux-gnu*)
 351     cat >>e${EMULATION_NAME}.c <<EOF
 352           {
 353             struct bfd_link_needed_list *l;
 354
 355             for (l = needed; l != NULL; l = l->next)
 356               if (strncmp (l->name, "libc.so", 7) == 0)
 357                 break;
 358             if (l == NULL)
 359               {
 360                 bfd_close (abfd);
 361                 return FALSE;
 362               }
 363           }
 364
 365 EOF
 366     ;;
 367 esac
 368 cat >>e${EMULATION_NAME}.c <<EOF
 369         }
 370     }
 371
 372   /* We've found a dynamic object matching the DT_NEEDED entry.  */
 373
 374   /* We have already checked that there is no other input file of the
 375      same name.  We must now check again that we are not including the
 376      same file twice.  We need to do this because on many systems
 377      libc.so is a symlink to, e.g., libc.so.1.  The SONAME entry will
 378      reference libc.so.1.  If we have already included libc.so, we
 379      don't want to include libc.so.1 if they are the same file, and we
 380      can only check that using stat.  */
 381
 382   if (bfd_stat (abfd, &global_stat) != 0)
 383     einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
 384
 385   /* First strip off everything before the last '/'.  */
 386   soname = lbasename (abfd->filename);
 387
 388   if (trace_file_tries)
 389     info_msg (_("found %s at %s\n"), soname, name);
 390
 391   global_found = FALSE;
 392   lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
 393   if (global_found)
 394     {
 395       /* Return TRUE to indicate that we found the file, even though
 396          we aren't going to do anything with it.  */
 397       return TRUE;
 398     }
 399
 400   /* Specify the soname to use.  */
 401   bfd_elf_set_dt_needed_name (abfd, soname);
 402
 403   /* Tell the ELF linker that we don't want the output file to have a
 404      DT_NEEDED entry for this file, unless it is used to resolve
 405      references in a regular object.  */
 406   class = DYN_DT_NEEDED;
 407
 408   /* Tell the ELF linker that we don't want the output file to have a
 409      DT_NEEDED entry for this file at all if the entry is from a file
 410      with DYN_NO_ADD_NEEDED.  */
 411   if (needed->by != NULL
 412       && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
 413     class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
 414
 415   bfd_elf_set_dyn_lib_class (abfd, class);
 416
 417   /* Add this file into the symbol table.  */
 418   if (! bfd_link_add_symbols (abfd, &link_info))
 419     einfo ("%F%B: could not read symbols: %E\n", abfd);
 420
 421   return TRUE;
 422 }
 423
 424
 425 /* Search for a needed file in a path.  */
 426
 427 static bfd_boolean
 428 gld${EMULATION_NAME}_search_needed (const char *path,
 429                                     struct dt_needed *n, int force)
 430 {
 431   const char *s;
 432   const char *name = n->name;
 433   size_t len;
 434   struct dt_needed needed;
 435
 436   if (name[0] == '/')
 437     return gld${EMULATION_NAME}_try_needed (n, force);
 438
 439   if (path == NULL || *path == '\0')
 440     return FALSE;
 441
 442   needed.by = n->by;
 443   needed.name = n->name;
 444
 445   len = strlen (name);
 446   while (1)
 447     {
 448       char *filename, *sset;
 449
 450       s = strchr (path, ':');
 451       if (s == NULL)
 452         s = path + strlen (path);
 453
 454       filename = (char *) xmalloc (s - path + len + 2);
 455       if (s == path)
 456         sset = filename;
 457       else
 458         {
 459           memcpy (filename, path, s - path);
 460           filename[s - path] = '/';
 461           sset = filename + (s - path) + 1;
 462         }
 463       strcpy (sset, name);
 464
 465       needed.name = filename;
 466       if (gld${EMULATION_NAME}_try_needed (&needed, force))
 467         return TRUE;
 468
 469       free (filename);
 470
 471       if (*s == '\0')
 472         break;
 473       path = s + 1;
 474     }
 475
 476   return FALSE;
 477 }
 478
 479 EOF
 480 if [ "x${USE_LIBPATH}" = xyes ] ; then
 481   cat >>e${EMULATION_NAME}.c <<EOF
 482
 483 /* Add the sysroot to every entry in a colon-separated path.  */
 484
 485 static char *
 486 gld${EMULATION_NAME}_add_sysroot (const char *path)
 487 {
 488   int len, colons, i;
 489   char *ret, *p;
 490
 491   len = strlen (path);
 492   colons = 0;
 493   i = 0;
 494   while (path[i])
 495     if (path[i++] == ':')
 496       colons++;
 497
 498   if (path[i])
 499     colons++;
 500
 501   len = len + (colons + 1) * strlen (ld_sysroot);
 502   ret = xmalloc (len + 1);
 503   strcpy (ret, ld_sysroot);
 504   p = ret + strlen (ret);
 505   i = 0;
 506   while (path[i])
 507     if (path[i] == ':')
 508       {
 509         *p++ = path[i++];
 510         strcpy (p, ld_sysroot);
 511         p = p + strlen (p);
 512       }
 513     else
 514       *p++ = path[i++];
 515
 516   *p = 0;
 517   return ret;
 518 }
 519
 520 EOF
 521   case ${target} in
 522     *-*-linux-gnu*)
 523       cat >>e${EMULATION_NAME}.c <<EOF
 524 /* For a native linker, check the file /etc/ld.so.conf for directories
 525    in which we may find shared libraries.  /etc/ld.so.conf is really
 526    only meaningful on Linux.  */
 527
 528 struct gld${EMULATION_NAME}_ld_so_conf
 529 {
 530   char *path;
 531   size_t len, alloc;
 532 };
 533
 534 static void
 535 gld${EMULATION_NAME}_parse_ld_so_conf
 536      (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
 537
 538 static void
 539 gld${EMULATION_NAME}_parse_ld_so_conf_include
 540      (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
 541       const char *pattern)
 542 {
 543   char *newp = NULL;
 544 #ifdef HAVE_GLOB
 545   glob_t gl;
 546 #endif
 547
 548   if (pattern[0] != '/')
 549     {
 550       char *p = strrchr (filename, '/');
 551       size_t patlen = strlen (pattern) + 1;
 552
 553       newp = xmalloc (p - filename + 1 + patlen);
 554       memcpy (newp, filename, p - filename + 1);
 555       memcpy (newp + (p - filename + 1), pattern, patlen);
 556       pattern = newp;
 557     }
 558
 559 #ifdef HAVE_GLOB
 560   if (glob (pattern, 0, NULL, &gl) == 0)
 561     {
 562       size_t i;
 563
 564       for (i = 0; i < gl.gl_pathc; ++i)
 565         gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
 566       globfree (&gl);
 567     }
 568 #else
 569   /* If we do not have glob, treat the pattern as a literal filename.  */
 570   gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
 571 #endif
 572
 573   if (newp)
 574     free (newp);
 575 }
 576
 577 static void
 578 gld${EMULATION_NAME}_parse_ld_so_conf
 579      (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
 580 {
 581   FILE *f = fopen (filename, FOPEN_RT);
 582   char *line;
 583   size_t linelen;
 584
 585   if (f == NULL)
 586     return;
 587
 588   linelen = 256;
 589   line = xmalloc (linelen);
 590   do
 591     {
 592       char *p = line, *q;
 593
 594       /* Normally this would use getline(3), but we need to be portable.  */
 595       while ((q = fgets (p, linelen - (p - line), f)) != NULL
 596              && strlen (q) == linelen - (p - line) - 1
 597              && line[linelen - 2] != '\n')
 598         {
 599           line = xrealloc (line, 2 * linelen);
 600           p = line + linelen - 1;
 601           linelen += linelen;
 602         }
 603
 604       if (q == NULL && p == line)
 605         break;
 606
 607       p = strchr (line, '\n');
 608       if (p)
 609         *p = '\0';
 610
 611       /* Because the file format does not know any form of quoting we
 612          can search forward for the next '#' character and if found
 613          make it terminating the line.  */
 614       p = strchr (line, '#');
 615       if (p)
 616         *p = '\0';
 617
 618       /* Remove leading whitespace.  NUL is no whitespace character.  */
 619       p = line;
 620       while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
 621         ++p;
 622
 623       /* If the line is blank it is ignored.  */
 624       if (p[0] == '\0')
 625         continue;
 626
 627       if (!strncmp (p, "include", 7) && (p[7] == ' ' || p[7] == '\t'))
 628         {
 629           char *dir, c;
 630           p += 8;
 631           do
 632             {
 633               while (*p == ' ' || *p == '\t')
 634                 ++p;
 635
 636               if (*p == '\0')
 637                 break;
 638
 639               dir = p;
 640
 641               while (*p != ' ' && *p != '\t' && *p)
 642                 ++p;
 643
 644               c = *p;
 645               *p++ = '\0';
 646               if (dir[0] != '\0')
 647                 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
 648                                                                dir);
 649             }
 650           while (c != '\0');
 651         }
 652       else
 653         {
 654           char *dir = p;
 655           while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
 656                  && *p != '\r' && *p != '\v')
 657             ++p;
 658
 659           while (p != dir && p[-1] == '/')
 660             --p;
 661           if (info->path == NULL)
 662             {
 663               info->alloc = p - dir + 1 + 256;
 664               info->path = xmalloc (info->alloc);
 665               info->len = 0;
 666             }
 667           else
 668             {
 669               if (info->len + 1 + (p - dir) >= info->alloc)
 670                 {
 671                   info->alloc += p - dir + 256;
 672                   info->path = xrealloc (info->path, info->alloc);
 673                 }
 674               info->path[info->len++] = ':';
 675             }
 676           memcpy (info->path + info->len, dir, p - dir);
 677           info->len += p - dir;
 678           info->path[info->len] = '\0';
 679         }
 680     }
 681   while (! feof (f));
 682   free (line);
 683   fclose (f);
 684 }
 685
 686 static bfd_boolean
 687 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
 688 {
 689   static bfd_boolean initialized;
 690   static char *ld_so_conf;
 691   struct dt_needed needed;
 692
 693   if (! initialized)
 694     {
 695       char *tmppath;
 696       struct gld${EMULATION_NAME}_ld_so_conf info;
 697
 698       tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL);
 699       info.path = NULL;
 700       info.len = info.alloc = 0;
 701       gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
 702       free (tmppath);
 703       if (info.path)
 704         {
 705           char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
 706           free (info.path);
 707           ld_so_conf = d;
 708         }
 709       initialized = TRUE;
 710     }
 711
 712   if (ld_so_conf == NULL)
 713     return FALSE;
 714
 715
 716   needed.by = NULL;
 717   needed.name = name;
 718   return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
 719 }
 720
 721 EOF
 722     # Linux
 723     ;;
 724   esac
 725 fi
 726 cat >>e${EMULATION_NAME}.c <<EOF
 727
 728 /* See if an input file matches a DT_NEEDED entry by name.  */
 729
 730 static void
 731 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
 732 {
 733   if (global_found)
 734     return;
 735
 736   if (s->filename != NULL)
 737     {
 738       const char *f;
 739
 740       if (strcmp (s->filename, global_needed->name) == 0)
 741         {
 742           global_found = TRUE;
 743           return;
 744         }
 745
 746       if (s->search_dirs_flag)
 747         {
 748           f = strrchr (s->filename, '/');
 749           if (f != NULL
 750               && strcmp (f + 1, global_needed->name) == 0)
 751             {
 752               global_found = TRUE;
 753               return;
 754             }
 755         }
 756     }
 757
 758   if (s->the_bfd != NULL)
 759     {
 760       const char *soname;
 761
 762       soname = bfd_elf_get_dt_soname (s->the_bfd);
 763       if (soname != NULL
 764           && strcmp (soname, global_needed->name) == 0)
 765         {
 766           global_found = TRUE;
 767           return;
 768         }
 769     }
 770 }
 771
 772 EOF
 773
 774 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
 775 cat >>e${EMULATION_NAME}.c <<EOF
 776
 777 /* This is called after all the input files have been opened.  */
 778
 779 static void
 780 gld${EMULATION_NAME}_after_open (void)
 781 {
 782   struct bfd_link_needed_list *needed, *l;
 783
 784   /* We only need to worry about this when doing a final link.  */
 785   if (link_info.relocatable || !link_info.executable)
 786     return;
 787
 788   /* Get the list of files which appear in DT_NEEDED entries in
 789      dynamic objects included in the link (often there will be none).
 790      For each such file, we want to track down the corresponding
 791      library, and include the symbol table in the link.  This is what
 792      the runtime dynamic linker will do.  Tracking the files down here
 793      permits one dynamic object to include another without requiring
 794      special action by the person doing the link.  Note that the
 795      needed list can actually grow while we are stepping through this
 796      loop.  */
 797   needed = bfd_elf_get_needed_list (output_bfd, &link_info);
 798   for (l = needed; l != NULL; l = l->next)
 799     {
 800       struct bfd_link_needed_list *ll;
 801       struct dt_needed n, nn;
 802       int force;
 803
 804       /* If the lib that needs this one was --as-needed and wasn't
 805          found to be needed, then this lib isn't needed either.  */
 806       if (l->by != NULL
 807           && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
 808         continue;
 809
 810       /* If we've already seen this file, skip it.  */
 811       for (ll = needed; ll != l; ll = ll->next)
 812         if ((ll->by == NULL
 813              || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
 814             && strcmp (ll->name, l->name) == 0)
 815           break;
 816       if (ll != l)
 817         continue;
 818
 819       /* See if this file was included in the link explicitly.  */
 820       global_needed = l;
 821       global_found = FALSE;
 822       lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
 823       if (global_found)
 824         continue;
 825
 826       n.by = l->by;
 827       n.name = l->name;
 828       nn.by = l->by;
 829       if (trace_file_tries)
 830         info_msg (_("%s needed by %B\n"), l->name, l->by);
 831
 832       /* We need to find this file and include the symbol table.  We
 833          want to search for the file in the same way that the dynamic
 834          linker will search.  That means that we want to use
 835          rpath_link, rpath, then the environment variable
 836          LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
 837          entries (native only), then the linker script LIB_SEARCH_DIRS.
 838          We do not search using the -L arguments.
 839
 840          We search twice.  The first time, we skip objects which may
 841          introduce version mismatches.  The second time, we force
 842          their use.  See gld${EMULATION_NAME}_vercheck comment.  */
 843       for (force = 0; force < 2; force++)
 844         {
 845           size_t len;
 846           search_dirs_type *search;
 847 EOF
 848 if [ "x${NATIVE}" = xyes ] ; then
 849 cat >>e${EMULATION_NAME}.c <<EOF
 850           const char *lib_path;
 851 EOF
 852 fi
 853 if [ "x${USE_LIBPATH}" = xyes ] ; then
 854 cat >>e${EMULATION_NAME}.c <<EOF
 855           struct bfd_link_needed_list *rp;
 856           int found;
 857 EOF
 858 fi
 859 cat >>e${EMULATION_NAME}.c <<EOF
 860
 861           if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
 862                                                   &n, force))
 863             break;
 864 EOF
 865 if [ "x${USE_LIBPATH}" = xyes ] ; then
 866 cat >>e${EMULATION_NAME}.c <<EOF
 867           if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
 868                                                   &n, force))
 869             break;
 870 EOF
 871 fi
 872 if [ "x${NATIVE}" = xyes ] ; then
 873 cat >>e${EMULATION_NAME}.c <<EOF
 874           if (command_line.rpath_link == NULL
 875               && command_line.rpath == NULL)
 876             {
 877               lib_path = (const char *) getenv ("LD_RUN_PATH");
 878               if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
 879                                                       force))
 880                 break;
 881             }
 882           lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
 883           if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
 884             break;
 885 EOF
 886 fi
 887 if [ "x${USE_LIBPATH}" = xyes ] ; then
 888 cat >>e${EMULATION_NAME}.c <<EOF
 889           found = 0;
 890           rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
 891           for (; !found && rp != NULL; rp = rp->next)
 892             {
 893               char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
 894               found = (rp->by == l->by
 895                        && gld${EMULATION_NAME}_search_needed (tmpname,
 896                                                               &n,
 897                                                               force));
 898               free (tmpname);
 899             }
 900           if (found)
 901             break;
 902
 903 EOF
 904 fi
 905 cat >>e${EMULATION_NAME}.c <<EOF
 906           len = strlen (l->name);
 907           for (search = search_head; search != NULL; search = search->next)
 908             {
 909               char *filename;
 910
 911               if (search->cmdline)
 912                 continue;
 913               filename = (char *) xmalloc (strlen (search->name) + len + 2);
 914               sprintf (filename, "%s/%s", search->name, l->name);
 915               nn.name = filename;
 916               if (gld${EMULATION_NAME}_try_needed (&nn, force))
 917                 break;
 918               free (filename);
 919             }
 920           if (search != NULL)
 921             break;
 922 EOF
 923 if [ "x${USE_LIBPATH}" = xyes ] ; then
 924   case ${target} in
 925     *-*-linux-gnu*)
 926       cat >>e${EMULATION_NAME}.c <<EOF
 927           if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
 928             break;
 929 EOF
 930     # Linux
 931     ;;
 932   esac
 933 fi
 934 cat >>e${EMULATION_NAME}.c <<EOF
 935         }
 936
 937       if (force < 2)
 938         continue;
 939
 940       einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
 941              l->name, l->by);
 942     }
 943 }
 944
 945 EOF
 946 fi
 947
 948 cat >>e${EMULATION_NAME}.c <<EOF
 949
 950 /* Look through an expression for an assignment statement.  */
 951
 952 static void
 953 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
 954 {
 955   bfd_boolean provide = FALSE;
 956
 957   switch (exp->type.node_class)
 958     {
 959     case etree_provide:
 960       provide = TRUE;
 961       /* Fall thru */
 962     case etree_assign:
 963       /* We call record_link_assignment even if the symbol is defined.
 964          This is because if it is defined by a dynamic object, we
 965          actually want to use the value defined by the linker script,
 966          not the value from the dynamic object (because we are setting
 967          symbols like etext).  If the symbol is defined by a regular
 968          object, then, as it happens, calling record_link_assignment
 969          will do no harm.  */
 970       if (strcmp (exp->assign.dst, ".") != 0)
 971         {
 972           if (!bfd_elf_record_link_assignment (output_bfd, &link_info,
 973                                                exp->assign.dst, provide))
 974             einfo ("%P%F: failed to record assignment to %s: %E\n",
 975                    exp->assign.dst);
 976         }
 977       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
 978       break;
 979
 980     case etree_binary:
 981       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
 982       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
 983       break;
 984
 985     case etree_trinary:
 986       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
 987       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 988       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
 989       break;
 990
 991     case etree_unary:
 992       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
 993       break;
 994
 995     default:
 996       break;
 997     }
 998 }
 999
1000
1001 /* This is called by the before_allocation routine via
1002    lang_for_each_statement.  It locates any assignment statements, and
1003    tells the ELF backend about them, in case they are assignments to
1004    symbols which are referred to by dynamic objects.  */
1005
1006 static void
1007 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1008 {
1009   if (s->header.type == lang_assignment_statement_enum)
1010     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1011 }
1012
1013 EOF
1014
1015 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1016   if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1017     ELF_INTERPRETER_SET_DEFAULT="
1018   if (sinterp != NULL)
1019     {
1020       sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1021       sinterp->size = strlen ((char *) sinterp->contents) + 1;
1022     }
1023
1024 "
1025   else
1026     ELF_INTERPRETER_SET_DEFAULT=
1027   fi
1028 cat >>e${EMULATION_NAME}.c <<EOF
1029
1030 /* This is called after the sections have been attached to output
1031    sections, but before any sizes or addresses have been set.  */
1032
1033 static void
1034 gld${EMULATION_NAME}_before_allocation (void)
1035 {
1036   const char *rpath;
1037   asection *sinterp;
1038
1039   if (link_info.hash->type == bfd_link_elf_hash_table)
1040     _bfd_elf_tls_setup (output_bfd, &link_info);
1041
1042   /* If we are going to make any variable assignments, we need to let
1043      the ELF backend know about them in case the variables are
1044      referred to by dynamic objects.  */
1045   lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1046
1047   /* Let the ELF backend work out the sizes of any sections required
1048      by dynamic linking.  */
1049   rpath = command_line.rpath;
1050   if (rpath == NULL)
1051     rpath = (const char *) getenv ("LD_RUN_PATH");
1052   if (! (bfd_elf_size_dynamic_sections
1053          (output_bfd, command_line.soname, rpath,
1054           command_line.filter_shlib,
1055           (const char * const *) command_line.auxiliary_filters,
1056           &link_info, &sinterp, lang_elf_version_info)))
1057     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1058 ${ELF_INTERPRETER_SET_DEFAULT}
1059   /* Let the user override the dynamic linker we are using.  */
1060   if (command_line.interpreter != NULL
1061       && sinterp != NULL)
1062     {
1063       sinterp->contents = (bfd_byte *) command_line.interpreter;
1064       sinterp->size = strlen (command_line.interpreter) + 1;
1065     }
1066
1067   /* Look for any sections named .gnu.warning.  As a GNU extensions,
1068      we treat such sections as containing warning messages.  We print
1069      out the warning message, and then zero out the section size so
1070      that it does not get copied into the output file.  */
1071
1072   {
1073     LANG_FOR_EACH_INPUT_STATEMENT (is)
1074       {
1075         asection *s;
1076         bfd_size_type sz;
1077         bfd_size_type prefix_len;
1078         char *msg;
1079         bfd_boolean ret;
1080         const char * gnu_warning_prefix = _("warning: ");
1081
1082         if (is->just_syms_flag)
1083           continue;
1084
1085         s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1086         if (s == NULL)
1087           continue;
1088
1089         sz = s->size;
1090         prefix_len = strlen (gnu_warning_prefix);
1091         msg = xmalloc ((size_t) (prefix_len + sz + 1));
1092         strcpy (msg, gnu_warning_prefix);
1093         if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len,
1094                                         (file_ptr) 0, sz))
1095           einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1096                  is->the_bfd);
1097         msg[prefix_len + sz] = '\0';
1098         ret = link_info.callbacks->warning (&link_info, msg,
1099                                             (const char *) NULL,
1100                                             is->the_bfd, (asection *) NULL,
1101                                             (bfd_vma) 0);
1102         ASSERT (ret);
1103         free (msg);
1104
1105         /* Clobber the section size, so that we don't waste copying the
1106            warning into the output file.  */
1107         s->size = 0;
1108       }
1109   }
1110 }
1111
1112 EOF
1113 fi
1114
1115 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1116 cat >>e${EMULATION_NAME}.c <<EOF
1117
1118 /* Try to open a dynamic archive.  This is where we know that ELF
1119    dynamic libraries have an extension of .so (or .sl on oddball systems
1120    like hpux).  */
1121
1122 static bfd_boolean
1123 gld${EMULATION_NAME}_open_dynamic_archive
1124   (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1125 {
1126   const char *filename;
1127   char *string;
1128
1129   if (! entry->is_archive)
1130     return FALSE;
1131
1132   filename = entry->filename;
1133
1134   /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1135      is defined, but it does not seem worth the headache to optimize
1136      away those two bytes of space.  */
1137   string = (char *) xmalloc (strlen (search->name)
1138                              + strlen (filename)
1139                              + strlen (arch)
1140 #ifdef EXTRA_SHLIB_EXTENSION
1141                              + strlen (EXTRA_SHLIB_EXTENSION)
1142 #endif
1143                              + sizeof "/lib.so");
1144
1145   sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1146
1147 #ifdef EXTRA_SHLIB_EXTENSION
1148   /* Try the .so extension first.  If that fails build a new filename
1149      using EXTRA_SHLIB_EXTENSION.  */
1150   if (! ldfile_try_open_bfd (string, entry))
1151     sprintf (string, "%s/lib%s%s%s", search->name,
1152              filename, arch, EXTRA_SHLIB_EXTENSION);
1153 #endif
1154
1155   if (! ldfile_try_open_bfd (string, entry))
1156     {
1157       free (string);
1158       return FALSE;
1159     }
1160
1161   entry->filename = string;
1162
1163   /* We have found a dynamic object to include in the link.  The ELF
1164      backend linker will create a DT_NEEDED entry in the .dynamic
1165      section naming this file.  If this file includes a DT_SONAME
1166      entry, it will be used.  Otherwise, the ELF linker will just use
1167      the name of the file.  For an archive found by searching, like
1168      this one, the DT_NEEDED entry should consist of just the name of
1169      the file, without the path information used to find it.  Note
1170      that we only need to do this if we have a dynamic object; an
1171      archive will never be referenced by a DT_NEEDED entry.
1172
1173      FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1174      very pretty.  I haven't been able to think of anything that is
1175      pretty, though.  */
1176   if (bfd_check_format (entry->the_bfd, bfd_object)
1177       && (entry->the_bfd->flags & DYNAMIC) != 0)
1178     {
1179       ASSERT (entry->is_archive && entry->search_dirs_flag);
1180
1181       /* Rather than duplicating the logic above.  Just use the
1182          filename we recorded earlier.  */
1183
1184       filename = lbasename (entry->filename);
1185       bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1186     }
1187
1188   return TRUE;
1189 }
1190
1191 EOF
1192 fi
1193
1194 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1195 cat >>e${EMULATION_NAME}.c <<EOF
1196
1197 /* A variant of lang_output_section_find used by place_orphan.  */
1198
1199 static lang_output_section_statement_type *
1200 output_rel_find (asection *sec, int isdyn)
1201 {
1202   lang_output_section_statement_type *lookup;
1203   lang_output_section_statement_type *last = NULL;
1204   lang_output_section_statement_type *last_alloc = NULL;
1205   lang_output_section_statement_type *last_rel = NULL;
1206   lang_output_section_statement_type *last_rel_alloc = NULL;
1207   int rela = sec->name[4] == 'a';
1208
1209   for (lookup = &lang_output_section_statement.head->output_section_statement;
1210        lookup != NULL;
1211        lookup = lookup->next)
1212     {
1213       if (lookup->constraint != -1
1214           && strncmp (".rel", lookup->name, 4) == 0)
1215         {
1216           int lookrela = lookup->name[4] == 'a';
1217
1218           /* .rel.dyn must come before all other reloc sections, to suit
1219              GNU ld.so.  */
1220           if (isdyn)
1221             break;
1222
1223           /* Don't place after .rel.plt as doing so results in wrong
1224              dynamic tags.  */
1225           if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1226             break;
1227
1228           if (rela == lookrela || last_rel == NULL)
1229             last_rel = lookup;
1230           if ((rela == lookrela || last_rel_alloc == NULL)
1231               && lookup->bfd_section != NULL
1232               && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1233             last_rel_alloc = lookup;
1234         }
1235
1236       last = lookup;
1237       if (lookup->bfd_section != NULL
1238           && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1239         last_alloc = lookup;
1240     }
1241
1242   if (last_rel_alloc)
1243     return last_rel_alloc;
1244
1245   if (last_rel)
1246     return last_rel;
1247
1248   if (last_alloc)
1249     return last_alloc;
1250
1251   return last;
1252 }
1253
1254 /* Place an orphan section.  We use this to put random SHF_ALLOC
1255    sections in the right segment.  */
1256
1257 static bfd_boolean
1258 gld${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1259 {
1260   static struct orphan_save hold[] =
1261     {
1262       { ".text",
1263         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1264         0, 0, 0, 0 },
1265       { ".rodata",
1266         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1267         0, 0, 0, 0 },
1268       { ".data",
1269         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1270         0, 0, 0, 0 },
1271       { ".bss",
1272         SEC_ALLOC,
1273         0, 0, 0, 0 },
1274       { 0,
1275         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1276         0, 0, 0, 0 },
1277       { ".interp",
1278         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1279         0, 0, 0, 0 },
1280       { ".sdata",
1281         SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1282         0, 0, 0, 0 }
1283     };
1284   enum orphan_save_index
1285     {
1286       orphan_text = 0,
1287       orphan_rodata,
1288       orphan_data,
1289       orphan_bss,
1290       orphan_rel,
1291       orphan_interp,
1292       orphan_sdata
1293     };
1294   static int orphan_init_done = 0;
1295   struct orphan_save *place;
1296   const char *secname;
1297   lang_output_section_statement_type *after;
1298   lang_output_section_statement_type *os;
1299   int isdyn = 0;
1300
1301   secname = bfd_get_section_name (s->owner, s);
1302
1303   if (! link_info.relocatable
1304       && link_info.combreloc
1305       && (s->flags & SEC_ALLOC)
1306       && strncmp (secname, ".rel", 4) == 0)
1307     {
1308       if (secname[4] == 'a')
1309         secname = ".rela.dyn";
1310       else
1311         secname = ".rel.dyn";
1312       isdyn = 1;
1313     }
1314
1315   if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s)))
1316     {
1317       /* Look through the script to see where to place this section.  */
1318       os = lang_output_section_find (secname);
1319
1320       if (os != NULL
1321           && (os->bfd_section == NULL
1322               || os->bfd_section->flags == 0
1323               || ((s->flags ^ os->bfd_section->flags)
1324                   & (SEC_LOAD | SEC_ALLOC)) == 0))
1325         {
1326           /* We already have an output section statement with this
1327              name, and its bfd section, if any, has compatible flags.
1328              If the section already exists but does not have any flags
1329              set, then it has been created by the linker, probably as a
1330              result of a --section-start command line switch.  */
1331           lang_add_section (&os->children, s, os, file);
1332           return TRUE;
1333         }
1334     }
1335
1336   if (!orphan_init_done)
1337     {
1338       struct orphan_save *ho;
1339       for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1340         if (ho->name != NULL)
1341           {
1342             ho->os = lang_output_section_find (ho->name);
1343             if (ho->os != NULL && ho->os->flags == 0)
1344               ho->os->flags = ho->flags;
1345           }
1346       orphan_init_done = 1;
1347     }
1348
1349   /* If this is a final link, then always put .gnu.warning.SYMBOL
1350      sections into the .text section to get them out of the way.  */
1351   if (link_info.executable
1352       && ! link_info.relocatable
1353       && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1354       && hold[orphan_text].os != NULL)
1355     {
1356       lang_add_section (&hold[orphan_text].os->children, s,
1357                         hold[orphan_text].os, file);
1358       return TRUE;
1359     }
1360
1361   /* Decide which segment the section should go in based on the
1362      section name and section flags.  We put loadable .note sections
1363      right after the .interp section, so that the PT_NOTE segment is
1364      stored right after the program headers where the OS can read it
1365      in the first page.  */
1366
1367   place = NULL;
1368   if ((s->flags & SEC_ALLOC) == 0)
1369     ;
1370   else if ((s->flags & SEC_LOAD) != 0
1371            && strncmp (secname, ".note", 5) == 0)
1372     place = &hold[orphan_interp];
1373   else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1374     place = &hold[orphan_bss];
1375   else if ((s->flags & SEC_SMALL_DATA) != 0)
1376     place = &hold[orphan_sdata];
1377   else if ((s->flags & SEC_READONLY) == 0)
1378     place = &hold[orphan_data];
1379   else if (strncmp (secname, ".rel", 4) == 0
1380            && (s->flags & SEC_LOAD) != 0)
1381     place = &hold[orphan_rel];
1382   else if ((s->flags & SEC_CODE) == 0)
1383     place = &hold[orphan_rodata];
1384   else
1385     place = &hold[orphan_text];
1386
1387   after = NULL;
1388   if (place != NULL)
1389     {
1390       if (place->os == NULL)
1391         {
1392           if (place->name != NULL)
1393             place->os = lang_output_section_find (place->name);
1394           else
1395             place->os = output_rel_find (s, isdyn);
1396         }
1397       after = place->os;
1398       if (after == NULL)
1399         after = lang_output_section_find_by_flags (s, &place->os);
1400       if (after == NULL)
1401         /* *ABS* is always the first output section statement.  */
1402         after = &lang_output_section_statement.head->output_section_statement;
1403     }
1404
1405   /* Choose a unique name for the section.  This will be needed if the
1406      same section name appears in the input file with different
1407      loadable or allocatable characteristics.  */
1408   if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1409     {
1410       static int count = 1;
1411       secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1412       if (secname == NULL)
1413         einfo ("%F%P: place_orphan failed: %E\n");
1414     }
1415
1416   lang_insert_orphan (file, s, secname, after, place, NULL, NULL);
1417
1418   return TRUE;
1419 }
1420 EOF
1421 fi
1422
1423 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1424 cat >>e${EMULATION_NAME}.c <<EOF
1425
1426 static void
1427 gld${EMULATION_NAME}_finish (void)
1428 {
1429   if (bfd_elf_discard_info (output_bfd, &link_info))
1430     {
1431       lang_reset_memory_regions ();
1432
1433       /* Resize the sections.  */
1434       lang_size_sections (stat_ptr->head, abs_output_section,
1435                           &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
1436
1437       /* Redo special stuff.  */
1438       ldemul_after_allocation ();
1439
1440       /* Do the assignments again.  */
1441       lang_do_assignments (stat_ptr->head, abs_output_section,
1442                            (fill_type *) 0, (bfd_vma) 0);
1443     }
1444
1445   if (!link_info.relocatable)
1446     {
1447       lang_output_section_statement_type *os;
1448
1449       for (os = &lang_output_section_statement.head->output_section_statement;
1450            os != NULL;
1451            os = os->next)
1452         {
1453           asection *s;
1454
1455           if (os == abs_output_section || os->constraint == -1)
1456             continue;
1457           s = os->bfd_section;
1458           if (s != NULL && s->size == 0 && (s->flags & SEC_KEEP) == 0)
1459             {
1460               asection **p;
1461
1462               for (p = &output_bfd->sections; *p; p = &(*p)->next)
1463                 if (*p == s)
1464                   {
1465                     bfd_section_list_remove (output_bfd, p);
1466                     output_bfd->section_count--;
1467                     break;
1468                   }
1469             }
1470         }
1471     }
1472 }
1473 EOF
1474 fi
1475
1476 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1477 cat >>e${EMULATION_NAME}.c <<EOF
1478
1479 static char *
1480 gld${EMULATION_NAME}_get_script (int *isfile)
1481 EOF
1482
1483 if test -n "$COMPILE_IN"
1484 then
1485 # Scripts compiled in.
1486
1487 # sed commands to quote an ld script as a C string.
1488 sc="-f stringify.sed"
1489
1490 cat >>e${EMULATION_NAME}.c <<EOF
1491 {
1492   *isfile = 0;
1493
1494   if (link_info.relocatable && config.build_constructors)
1495     return
1496 EOF
1497 sed $sc ldscripts/${EMULATION_NAME}.xu                  >> e${EMULATION_NAME}.c
1498 echo '  ; else if (link_info.relocatable) return'       >> e${EMULATION_NAME}.c
1499 sed $sc ldscripts/${EMULATION_NAME}.xr                  >> e${EMULATION_NAME}.c
1500 echo '  ; else if (!config.text_read_only) return'      >> e${EMULATION_NAME}.c
1501 sed $sc ldscripts/${EMULATION_NAME}.xbn                 >> e${EMULATION_NAME}.c
1502 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1503 echo '  ; else if (!config.magic_demand_paged) return'  >> e${EMULATION_NAME}.c
1504 sed $sc ldscripts/${EMULATION_NAME}.xn                  >> e${EMULATION_NAME}.c
1505 fi
1506 if test -n "$GENERATE_PIE_SCRIPT" ; then
1507 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1508 echo '  ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1509 echo '             && link_info.relro' >> e${EMULATION_NAME}.c
1510 echo '             && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1511 sed $sc ldscripts/${EMULATION_NAME}.xdw                 >> e${EMULATION_NAME}.c
1512 echo '  ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1513 sed $sc ldscripts/${EMULATION_NAME}.xdc                 >> e${EMULATION_NAME}.c
1514 fi
1515 echo '  ; else if (link_info.pie) return'               >> e${EMULATION_NAME}.c
1516 sed $sc ldscripts/${EMULATION_NAME}.xd                  >> e${EMULATION_NAME}.c
1517 fi
1518 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1519 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1520 echo '  ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1521 echo '             && link_info.relro' >> e${EMULATION_NAME}.c
1522 echo '             && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1523 sed $sc ldscripts/${EMULATION_NAME}.xsw                 >> e${EMULATION_NAME}.c
1524 echo '  ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1525 sed $sc ldscripts/${EMULATION_NAME}.xsc                 >> e${EMULATION_NAME}.c
1526 fi
1527 echo '  ; else if (link_info.shared) return'            >> e${EMULATION_NAME}.c
1528 sed $sc ldscripts/${EMULATION_NAME}.xs                  >> e${EMULATION_NAME}.c
1529 fi
1530 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1531 echo '  ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1532 echo '             && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1533 sed $sc ldscripts/${EMULATION_NAME}.xw                  >> e${EMULATION_NAME}.c
1534 echo '  ; else if (link_info.combreloc) return'         >> e${EMULATION_NAME}.c
1535 sed $sc ldscripts/${EMULATION_NAME}.xc                  >> e${EMULATION_NAME}.c
1536 fi
1537 echo '  ; else return'                                  >> e${EMULATION_NAME}.c
1538 sed $sc ldscripts/${EMULATION_NAME}.x                   >> e${EMULATION_NAME}.c
1539 echo '; }'                                              >> e${EMULATION_NAME}.c
1540
1541 else
1542 # Scripts read from the filesystem.
1543
1544 cat >>e${EMULATION_NAME}.c <<EOF
1545 {
1546   *isfile = 1;
1547
1548   if (link_info.relocatable && config.build_constructors)
1549     return "ldscripts/${EMULATION_NAME}.xu";
1550   else if (link_info.relocatable)
1551     return "ldscripts/${EMULATION_NAME}.xr";
1552   else if (!config.text_read_only)
1553     return "ldscripts/${EMULATION_NAME}.xbn";
1554 EOF
1555 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1556 else
1557 cat >>e${EMULATION_NAME}.c <<EOF
1558   else if (!config.magic_demand_paged)
1559     return "ldscripts/${EMULATION_NAME}.xn";
1560 EOF
1561 fi
1562 if test -n "$GENERATE_PIE_SCRIPT" ; then
1563 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1564 cat >>e${EMULATION_NAME}.c <<EOF
1565   else if (link_info.pie && link_info.combreloc
1566            && link_info.relro && (link_info.flags & DT_BIND_NOW))
1567     return "ldscripts/${EMULATION_NAME}.xdw";
1568   else if (link_info.pie && link_info.combreloc)
1569     return "ldscripts/${EMULATION_NAME}.xdc";
1570 EOF
1571 fi
1572 cat >>e${EMULATION_NAME}.c <<EOF
1573   else if (link_info.pie)
1574     return "ldscripts/${EMULATION_NAME}.xd";
1575 EOF
1576 fi
1577 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1578 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1579 cat >>e${EMULATION_NAME}.c <<EOF
1580   else if (link_info.shared && link_info.combreloc
1581            && link_info.relro && (link_info.flags & DT_BIND_NOW))
1582     return "ldscripts/${EMULATION_NAME}.xsw";
1583   else if (link_info.shared && link_info.combreloc)
1584     return "ldscripts/${EMULATION_NAME}.xsc";
1585 EOF
1586 fi
1587 cat >>e${EMULATION_NAME}.c <<EOF
1588   else if (link_info.shared)
1589     return "ldscripts/${EMULATION_NAME}.xs";
1590 EOF
1591 fi
1592 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1593 cat >>e${EMULATION_NAME}.c <<EOF
1594   else if (link_info.combreloc && link_info.relro
1595            && (link_info.flags & DT_BIND_NOW))
1596     return "ldscripts/${EMULATION_NAME}.xw";
1597   else if (link_info.combreloc)
1598     return "ldscripts/${EMULATION_NAME}.xc";
1599 EOF
1600 fi
1601 cat >>e${EMULATION_NAME}.c <<EOF
1602   else
1603     return "ldscripts/${EMULATION_NAME}.x";
1604 }
1605
1606 EOF
1607 fi
1608 fi
1609
1610 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1611
1612 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1613 cat >>e${EMULATION_NAME}.c <<EOF
1614  $PARSE_AND_LIST_PROLOGUE
1615 EOF
1616 fi
1617
1618 cat >>e${EMULATION_NAME}.c <<EOF
1619
1620 #define OPTION_DISABLE_NEW_DTAGS        (400)
1621 #define OPTION_ENABLE_NEW_DTAGS         (OPTION_DISABLE_NEW_DTAGS + 1)
1622 #define OPTION_GROUP                    (OPTION_ENABLE_NEW_DTAGS + 1)
1623 #define OPTION_EH_FRAME_HDR             (OPTION_GROUP + 1)
1624 #define OPTION_EXCLUDE_LIBS             (OPTION_EH_FRAME_HDR + 1)
1625
1626 static void
1627 gld${EMULATION_NAME}_add_options
1628   (int ns, char **shortopts, int nl, struct option **longopts,
1629    int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1630 {
1631   static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1632   static const struct option xtra_long[] = {
1633 EOF
1634
1635 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1636 cat >>e${EMULATION_NAME}.c <<EOF
1637     {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1638     {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1639     {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1640     {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
1641     {"Bgroup", no_argument, NULL, OPTION_GROUP},
1642 EOF
1643 fi
1644
1645 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1646 cat >>e${EMULATION_NAME}.c <<EOF
1647     $PARSE_AND_LIST_LONGOPTS
1648 EOF
1649 fi
1650
1651 cat >>e${EMULATION_NAME}.c <<EOF
1652     {NULL, no_argument, NULL, 0}
1653   };
1654
1655   *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1656   memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1657   *longopts = (struct option *)
1658     xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1659   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1660 }
1661
1662 static bfd_boolean
1663 gld${EMULATION_NAME}_handle_option (int optc)
1664 {
1665   switch (optc)
1666     {
1667     default:
1668       return FALSE;
1669
1670 EOF
1671
1672 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1673 cat >>e${EMULATION_NAME}.c <<EOF
1674     case OPTION_DISABLE_NEW_DTAGS:
1675       link_info.new_dtags = FALSE;
1676       break;
1677
1678     case OPTION_ENABLE_NEW_DTAGS:
1679       link_info.new_dtags = TRUE;
1680       break;
1681
1682     case OPTION_EH_FRAME_HDR:
1683       link_info.eh_frame_hdr = TRUE;
1684       break;
1685
1686     case OPTION_GROUP:
1687       link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1688       /* Groups must be self-contained.  */
1689       link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1690       link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1691       break;
1692
1693     case OPTION_EXCLUDE_LIBS:
1694       add_excluded_libs (optarg);
1695       break;
1696
1697     case 'z':
1698       if (strcmp (optarg, "initfirst") == 0)
1699         link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1700       else if (strcmp (optarg, "interpose") == 0)
1701         link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1702       else if (strcmp (optarg, "loadfltr") == 0)
1703         link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1704       else if (strcmp (optarg, "nodefaultlib") == 0)
1705         link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1706       else if (strcmp (optarg, "nodelete") == 0)
1707         link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1708       else if (strcmp (optarg, "nodlopen") == 0)
1709         link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1710       else if (strcmp (optarg, "nodump") == 0)
1711         link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1712       else if (strcmp (optarg, "now") == 0)
1713         {
1714           link_info.flags |= (bfd_vma) DF_BIND_NOW;
1715           link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1716         }
1717       else if (strcmp (optarg, "origin") == 0)
1718         {
1719           link_info.flags |= (bfd_vma) DF_ORIGIN;
1720           link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1721         }
1722       else if (strcmp (optarg, "defs") == 0)
1723         link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1724       else if (strcmp (optarg, "muldefs") == 0)
1725         link_info.allow_multiple_definition = TRUE;
1726       else if (strcmp (optarg, "combreloc") == 0)
1727         link_info.combreloc = TRUE;
1728       else if (strcmp (optarg, "nocombreloc") == 0)
1729         link_info.combreloc = FALSE;
1730       else if (strcmp (optarg, "nocopyreloc") == 0)
1731         link_info.nocopyreloc = TRUE;
1732       else if (strcmp (optarg, "execstack") == 0)
1733         {
1734           link_info.execstack = TRUE;
1735           link_info.noexecstack = FALSE;
1736         }
1737       else if (strcmp (optarg, "noexecstack") == 0)
1738         {
1739           link_info.noexecstack = TRUE;
1740           link_info.execstack = FALSE;
1741         }
1742       else if (strcmp (optarg, "relro") == 0)
1743         link_info.relro = TRUE;
1744       else if (strcmp (optarg, "norelro") == 0)
1745         link_info.relro = FALSE;
1746       /* What about the other Solaris -z options? FIXME.  */
1747       break;
1748 EOF
1749 fi
1750
1751 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1752 cat >>e${EMULATION_NAME}.c <<EOF
1753  $PARSE_AND_LIST_ARGS_CASES
1754 EOF
1755 fi
1756
1757 cat >>e${EMULATION_NAME}.c <<EOF
1758     }
1759
1760   return TRUE;
1761 }
1762
1763 EOF
1764
1765 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1766 cat >>e${EMULATION_NAME}.c <<EOF
1767
1768 static void
1769 gld${EMULATION_NAME}_list_options (FILE * file)
1770 {
1771 EOF
1772
1773 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1774 cat >>e${EMULATION_NAME}.c <<EOF
1775   fprintf (file, _("  -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1776   fprintf (file, _("  --disable-new-dtags\tDisable new dynamic tags\n"));
1777   fprintf (file, _("  --enable-new-dtags\tEnable new dynamic tags\n"));
1778   fprintf (file, _("  --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1779   fprintf (file, _("  -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1780   fprintf (file, _("  -z defs\t\tReport unresolved symbols in object files.\n"));
1781   fprintf (file, _("  -z execstack\t\tMark executable as requiring executable stack\n"));
1782   fprintf (file, _("  -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1783   fprintf (file, _("  -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1784   fprintf (file, _("  -z loadfltr\t\tMark object requiring immediate process\n"));
1785   fprintf (file, _("  -z muldefs\t\tAllow multiple definitions\n"));
1786   fprintf (file, _("  -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1787   fprintf (file, _("  -z nocopyreloc\tDon't create copy relocs\n"));
1788   fprintf (file, _("  -z nodefaultlib\tMark object not to use default search paths\n"));
1789   fprintf (file, _("  -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1790   fprintf (file, _("  -z nodlopen\t\tMark DSO not available to dlopen\n"));
1791   fprintf (file, _("  -z nodump\t\tMark DSO not available to dldump\n"));
1792   fprintf (file, _("  -z noexecstack\tMark executable as not requiring executable stack\n"));
1793   fprintf (file, _("  -z norelro\t\tDon't create RELRO program header\n"));
1794   fprintf (file, _("  -z now\t\tMark object non-lazy runtime binding\n"));
1795   fprintf (file, _("  -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t  at runtime\n"));
1796   fprintf (file, _("  -z relro\t\tCreate RELRO program header\n"));
1797   fprintf (file, _("  -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1798 EOF
1799 fi
1800
1801 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1802 cat >>e${EMULATION_NAME}.c <<EOF
1803  $PARSE_AND_LIST_OPTIONS
1804 EOF
1805 fi
1806
1807 cat >>e${EMULATION_NAME}.c <<EOF
1808 }
1809 EOF
1810
1811 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1812 cat >>e${EMULATION_NAME}.c <<EOF
1813  $PARSE_AND_LIST_EPILOGUE
1814 EOF
1815 fi
1816 fi
1817 else
1818 cat >>e${EMULATION_NAME}.c <<EOF
1819 #define gld${EMULATION_NAME}_add_options NULL
1820 #define gld${EMULATION_NAME}_handle_option NULL
1821 EOF
1822 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1823 cat >>e${EMULATION_NAME}.c <<EOF
1824 #define gld${EMULATION_NAME}_list_options NULL
1825 EOF
1826 fi
1827 fi
1828
1829 cat >>e${EMULATION_NAME}.c <<EOF
1830
1831 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1832 {
1833   ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1834   ${LDEMUL_SYSLIB-syslib_default},
1835   ${LDEMUL_HLL-hll_default},
1836   ${LDEMUL_AFTER_PARSE-after_parse_default},
1837   ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1838   ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1839   ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1840   ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1841   ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1842   ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1843   "${EMULATION_NAME}",
1844   "${OUTPUT_FORMAT}",
1845   ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1846   ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1847   ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1848   ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1849   ${LDEMUL_SET_SYMBOLS-NULL},
1850   ${LDEMUL_PARSE_ARGS-NULL},
1851   gld${EMULATION_NAME}_add_options,
1852   gld${EMULATION_NAME}_handle_option,
1853   ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1854   ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1855   ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
1856   ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1857   ${LDEMUL_NEW_VERS_PATTERN-NULL}
1858 };
1859 EOF