ld/emultempl/elf32.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 # This file is now misnamed, because it supports both 32 bit and 64 bit
   4 # ELF emulations.
   5 test -z "${ELFSIZE}" && ELFSIZE=32
   6 cat >e${EMULATION_NAME}.c <<EOF
   7 /* This file is is generated by a shell script.  DO NOT EDIT! */
   8
   9 /* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
  10    Copyright (C) 1991, 93, 94, 95, 96, 97, 98, 1999
  11    Free Software Foundation, Inc.
  12    Written by Steve Chamberlain <sac@cygnus.com>
  13    ELF support by Ian Lance Taylor <ian@cygnus.com>
  14
  15 This file is part of GLD, the Gnu Linker.
  16
  17 This program is free software; you can redistribute it and/or modify
  18 it under the terms of the GNU General Public License as published by
  19 the Free Software Foundation; either version 2 of the License, or
  20 (at your option) any later version.
  21
  22 This program is distributed in the hope that it will be useful,
  23 but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 GNU General Public License for more details.
  26
  27 You should have received a copy of the GNU General Public License
  28 along with this program; if not, write to the Free Software
  29 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  30
  31 #define TARGET_IS_${EMULATION_NAME}
  32
  33 #include "bfd.h"
  34 #include "sysdep.h"
  35
  36 #include <ctype.h>
  37
  38 #include "bfdlink.h"
  39
  40 #include "ld.h"
  41 #include "ldmain.h"
  42 #include "ldemul.h"
  43 #include "ldfile.h"
  44 #include "ldmisc.h"
  45 #include "ldexp.h"
  46 #include "ldlang.h"
  47 #include "ldgram.h"
  48
  49 static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
  50 static boolean gld${EMULATION_NAME}_open_dynamic_archive
  51   PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
  52 static void gld${EMULATION_NAME}_after_open PARAMS ((void));
  53 static void gld${EMULATION_NAME}_check_needed
  54   PARAMS ((lang_input_statement_type *));
  55 static void gld${EMULATION_NAME}_stat_needed
  56   PARAMS ((lang_input_statement_type *));
  57 static boolean gld${EMULATION_NAME}_search_needed
  58   PARAMS ((const char *, const char *, int));
  59 static boolean gld${EMULATION_NAME}_try_needed PARAMS ((const char *, int));
  60 static void gld${EMULATION_NAME}_vercheck
  61   PARAMS ((lang_input_statement_type *));
  62 static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
  63 static void gld${EMULATION_NAME}_find_statement_assignment
  64   PARAMS ((lang_statement_union_type *));
  65 static void gld${EMULATION_NAME}_find_exp_assignment PARAMS ((etree_type *));
  66 static boolean gld${EMULATION_NAME}_place_orphan
  67   PARAMS ((lang_input_statement_type *, asection *));
  68 static void gld${EMULATION_NAME}_place_section
  69   PARAMS ((lang_statement_union_type *));
  70 static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile));
  71
  72 static void
  73 gld${EMULATION_NAME}_before_parse()
  74 {
  75   ldfile_output_architecture = bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`;
  76   config.dynamic_link = ${DYNAMIC_LINK-true};
  77   config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo true ; else echo false ; fi`;
  78 }
  79
  80 /* Try to open a dynamic archive.  This is where we know that ELF
  81    dynamic libraries have an extension of .so (or .sl on oddball systems
  82    like hpux).  */
  83
  84 static boolean
  85 gld${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
  86      const char *arch;
  87      search_dirs_type *search;
  88      lang_input_statement_type *entry;
  89 {
  90   const char *filename;
  91   char *string;
  92
  93   if (! entry->is_archive)
  94     return false;
  95
  96   filename = entry->filename;
  97
  98   /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
  99      is defined, but it does not seem worth the headache to optimize
 100      away those two bytes of space.  */
 101   string = (char *) xmalloc (strlen (search->name)
 102                              + strlen (filename)
 103                              + strlen (arch)
 104 #ifdef EXTRA_SHLIB_EXTENSION
 105                              + strlen (EXTRA_SHLIB_EXTENSION)
 106 #endif
 107                              + sizeof "/lib.so");
 108
 109   sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
 110
 111 #ifdef EXTRA_SHLIB_EXTENSION
 112   /* Try the .so extension first.  If that fails build a new filename
 113      using EXTRA_SHLIB_EXTENSION.  */
 114   if (! ldfile_try_open_bfd (string, entry))
 115     sprintf (string, "%s/lib%s%s%s", search->name,
 116              filename, arch, EXTRA_SHLIB_EXTENSION);
 117 #endif
 118
 119   if (! ldfile_try_open_bfd (string, entry))
 120     {
 121       free (string);
 122       return false;
 123     }
 124
 125   entry->filename = string;
 126
 127   /* We have found a dynamic object to include in the link.  The ELF
 128      backend linker will create a DT_NEEDED entry in the .dynamic
 129      section naming this file.  If this file includes a DT_SONAME
 130      entry, it will be used.  Otherwise, the ELF linker will just use
 131      the name of the file.  For an archive found by searching, like
 132      this one, the DT_NEEDED entry should consist of just the name of
 133      the file, without the path information used to find it.  Note
 134      that we only need to do this if we have a dynamic object; an
 135      archive will never be referenced by a DT_NEEDED entry.
 136
 137      FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
 138      very pretty.  I haven't been able to think of anything that is
 139      pretty, though.  */
 140   if (bfd_check_format (entry->the_bfd, bfd_object)
 141       && (entry->the_bfd->flags & DYNAMIC) != 0)
 142     {
 143       char *needed_name;
 144
 145       ASSERT (entry->is_archive && entry->search_dirs_flag);
 146
 147       /* Rather than duplicating the logic above.  Just use the
 148          filename we recorded earlier.
 149
 150          First strip off everything before the last '/'.  */
 151       filename = strrchr (entry->filename, '/');
 152       filename++;
 153
 154       needed_name = (char *) xmalloc (strlen (filename) + 1);
 155       strcpy (needed_name, filename);
 156       bfd_elf_set_dt_needed_name (entry->the_bfd, needed_name);
 157     }
 158
 159   return true;
 160 }
 161
 162 EOF
 163 if [ "x${host}" = "x${target}" ] ; then
 164   case " ${EMULATION_LIBPATH} " in
 165   *" ${EMULATION_NAME} "*)
 166 cat >>e${EMULATION_NAME}.c <<EOF
 167
 168 /* For a native linker, check the file /etc/ld.so.conf for directories
 169    in which we may find shared libraries.  /etc/ld.so.conf is really
 170    only meaningful on Linux, but we check it on other systems anyhow.  */
 171
 172 static boolean gld${EMULATION_NAME}_check_ld_so_conf
 173   PARAMS ((const char *, int));
 174
 175 static boolean
 176 gld${EMULATION_NAME}_check_ld_so_conf (name, force)
 177      const char *name;
 178      int force;
 179 {
 180   static boolean initialized;
 181   static char *ld_so_conf;
 182
 183   if (! initialized)
 184     {
 185       FILE *f;
 186
 187       f = fopen ("/etc/ld.so.conf", FOPEN_RT);
 188       if (f != NULL)
 189         {
 190           char *b;
 191           size_t len, alloc;
 192           int c;
 193
 194           len = 0;
 195           alloc = 100;
 196           b = (char *) xmalloc (alloc);
 197
 198           while ((c = getc (f)) != EOF)
 199             {
 200               if (len + 1 >= alloc)
 201                 {
 202                   alloc *= 2;
 203                   b = (char *) xrealloc (b, alloc);
 204                 }
 205               if (c != ':'
 206                   && c != ' '
 207                   && c != '\t'
 208                   && c != '\n'
 209                   && c != ',')
 210                 {
 211                   b[len] = c;
 212                   ++len;
 213                 }
 214               else
 215                 {
 216                   if (len > 0 && b[len - 1] != ':')
 217                     {
 218                       b[len] = ':';
 219                       ++len;
 220                     }
 221                 }
 222             }
 223
 224           if (len > 0 && b[len - 1] == ':')
 225             --len;
 226
 227           if (len > 0)
 228             b[len] = '\0';
 229           else
 230             {
 231               free (b);
 232               b = NULL;
 233             }
 234
 235           fclose (f);
 236
 237           ld_so_conf = b;
 238         }
 239
 240       initialized = true;
 241     }
 242
 243   if (ld_so_conf == NULL)
 244     return false;
 245
 246   return gld${EMULATION_NAME}_search_needed (ld_so_conf, name, force);
 247 }
 248
 249 EOF
 250   ;;
 251   esac
 252 fi
 253 cat >>e${EMULATION_NAME}.c <<EOF
 254
 255 /* These variables are required to pass information back and forth
 256    between after_open and check_needed and stat_needed and vercheck.  */
 257
 258 static struct bfd_link_needed_list *global_needed;
 259 static struct stat global_stat;
 260 static boolean global_found;
 261 static struct bfd_link_needed_list *global_vercheck_needed;
 262 static boolean global_vercheck_failed;
 263
 264 /* This is called after all the input files have been opened.  */
 265
 266 static void
 267 gld${EMULATION_NAME}_after_open ()
 268 {
 269   struct bfd_link_needed_list *needed, *l;
 270
 271   /* We only need to worry about this when doing a final link.  */
 272   if (link_info.relocateable || link_info.shared)
 273     return;
 274
 275   /* Get the list of files which appear in DT_NEEDED entries in
 276      dynamic objects included in the link (often there will be none).
 277      For each such file, we want to track down the corresponding
 278      library, and include the symbol table in the link.  This is what
 279      the runtime dynamic linker will do.  Tracking the files down here
 280      permits one dynamic object to include another without requiring
 281      special action by the person doing the link.  Note that the
 282      needed list can actually grow while we are stepping through this
 283      loop.  */
 284   needed = bfd_elf_get_needed_list (output_bfd, &link_info);
 285   for (l = needed; l != NULL; l = l->next)
 286     {
 287       struct bfd_link_needed_list *ll;
 288       int force;
 289
 290       /* If we've already seen this file, skip it.  */
 291       for (ll = needed; ll != l; ll = ll->next)
 292         if (strcmp (ll->name, l->name) == 0)
 293           break;
 294       if (ll != l)
 295         continue;
 296
 297       /* See if this file was included in the link explicitly.  */
 298       global_needed = l;
 299       global_found = false;
 300       lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
 301       if (global_found)
 302         continue;
 303
 304       /* We need to find this file and include the symbol table.  We
 305          want to search for the file in the same way that the dynamic
 306          linker will search.  That means that we want to use
 307          rpath_link, rpath, then the environment variable
 308          LD_LIBRARY_PATH (native only), then the linker script
 309          LIB_SEARCH_DIRS.  We do not search using the -L arguments.
 310
 311          We search twice.  The first time, we skip objects which may
 312          introduce version mismatches.  The second time, we force
 313          their use.  See gld${EMULATION_NAME}_vercheck comment.  */
 314       for (force = 0; force < 2; force++)
 315         {
 316           const char *lib_path;
 317           size_t len;
 318           search_dirs_type *search;
 319
 320           if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
 321                                                   l->name, force))
 322             break;
 323           if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
 324                                                   l->name, force))
 325             break;
 326           if (command_line.rpath_link == NULL
 327               && command_line.rpath == NULL)
 328             {
 329               lib_path = (const char *) getenv ("LD_RUN_PATH");
 330               if (gld${EMULATION_NAME}_search_needed (lib_path, l->name,
 331                                                       force))
 332                 break;
 333             }
 334 EOF
 335 if [ "x${host}" = "x${target}" ] ; then
 336   case " ${EMULATION_LIBPATH} " in
 337   *" ${EMULATION_NAME} "*)
 338 cat >>e${EMULATION_NAME}.c <<EOF
 339           lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
 340           if (gld${EMULATION_NAME}_search_needed (lib_path, l->name, force))
 341             break;
 342 EOF
 343   ;;
 344   esac
 345 fi
 346 cat >>e${EMULATION_NAME}.c <<EOF
 347           len = strlen (l->name);
 348           for (search = search_head; search != NULL; search = search->next)
 349             {
 350               char *filename;
 351
 352               if (search->cmdline)
 353                 continue;
 354               filename = (char *) xmalloc (strlen (search->name) + len + 2);
 355               sprintf (filename, "%s/%s", search->name, l->name);
 356               if (gld${EMULATION_NAME}_try_needed (filename, force))
 357                 break;
 358               free (filename);
 359             }
 360           if (search != NULL)
 361             break;
 362 EOF
 363 if [ "x${host}" = "x${target}" ] ; then
 364   case " ${EMULATION_LIBPATH} " in
 365   *" ${EMULATION_NAME} "*)
 366 cat >>e${EMULATION_NAME}.c <<EOF
 367           if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
 368             break;
 369 EOF
 370   ;;
 371   esac
 372 fi
 373 cat >>e${EMULATION_NAME}.c <<EOF
 374         }
 375
 376       if (force < 2)
 377         continue;
 378
 379       einfo ("%P: warning: %s, needed by %B, not found (try using --rpath)\n",
 380              l->name, l->by);
 381     }
 382 }
 383
 384 /* Search for a needed file in a path.  */
 385
 386 static boolean
 387 gld${EMULATION_NAME}_search_needed (path, name, force)
 388      const char *path;
 389      const char *name;
 390      int force;
 391 {
 392   const char *s;
 393   size_t len;
 394
 395   if (path == NULL || *path == '\0')
 396     return false;
 397   len = strlen (name);
 398   while (1)
 399     {
 400       char *filename, *sset;
 401
 402       s = strchr (path, ':');
 403       if (s == NULL)
 404         s = path + strlen (path);
 405
 406       filename = (char *) xmalloc (s - path + len + 2);
 407       if (s == path)
 408         sset = filename;
 409       else
 410         {
 411           memcpy (filename, path, s - path);
 412           filename[s - path] = '/';
 413           sset = filename + (s - path) + 1;
 414         }
 415       strcpy (sset, name);
 416
 417       if (gld${EMULATION_NAME}_try_needed (filename, force))
 418         return true;
 419
 420       free (filename);
 421
 422       if (*s == '\0')
 423         break;
 424       path = s + 1;
 425     }
 426
 427   return false;
 428 }
 429
 430 /* This function is called for each possible name for a dynamic object
 431    named by a DT_NEEDED entry.  The FORCE parameter indicates whether
 432    to skip the check for a conflicting version.  */
 433
 434 static boolean
 435 gld${EMULATION_NAME}_try_needed (name, force)
 436      const char *name;
 437      int force;
 438 {
 439   bfd *abfd;
 440
 441   abfd = bfd_openr (name, bfd_get_target (output_bfd));
 442   if (abfd == NULL)
 443     return false;
 444   if (! bfd_check_format (abfd, bfd_object))
 445     {
 446       (void) bfd_close (abfd);
 447       return false;
 448     }
 449   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 450     {
 451       (void) bfd_close (abfd);
 452       return false;
 453     }
 454
 455   /* Check whether this object would include any conflicting library
 456      versions.  If FORCE is set, then we skip this check; we use this
 457      the second time around, if we couldn't find any compatible
 458      instance of the shared library.  */
 459
 460   if (! force)
 461     {
 462       struct bfd_link_needed_list *needed;
 463
 464       if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
 465         einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
 466
 467       if (needed != NULL)
 468         {
 469           global_vercheck_needed = needed;
 470           global_vercheck_failed = false;
 471           lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
 472           if (global_vercheck_failed)
 473             {
 474               (void) bfd_close (abfd);
 475               /* Return false to force the caller to move on to try
 476                  another file on the search path.  */
 477               return false;
 478             }
 479
 480           /* But wait!  It gets much worse.  On Linux, if a shared
 481              library does not use libc at all, we are supposed to skip
 482              it the first time around in case we encounter a shared
 483              library later on with the same name which does use the
 484              version of libc that we want.  This is much too horrible
 485              to use on any system other than Linux.  */
 486
 487 EOF
 488 case ${target} in
 489   *-*-linux-gnu*)
 490     cat >>e${EMULATION_NAME}.c <<EOF
 491           {
 492             struct bfd_link_needed_list *l;
 493
 494             for (l = needed; l != NULL; l = l->next)
 495               if (strncmp (l->name, "libc.so", 7) == 0)
 496                 break;
 497             if (l == NULL)
 498               {
 499                 (void) bfd_close (abfd);
 500                 return false;
 501               }
 502           }
 503
 504 EOF
 505     ;;
 506 esac
 507 cat >>e${EMULATION_NAME}.c <<EOF
 508         }
 509     }
 510
 511   /* We've found a dynamic object matching the DT_NEEDED entry.  */
 512
 513   /* We have already checked that there is no other input file of the
 514      same name.  We must now check again that we are not including the
 515      same file twice.  We need to do this because on many systems
 516      libc.so is a symlink to, e.g., libc.so.1.  The SONAME entry will
 517      reference libc.so.1.  If we have already included libc.so, we
 518      don't want to include libc.so.1 if they are the same file, and we
 519      can only check that using stat.  */
 520
 521   if (bfd_stat (abfd, &global_stat) != 0)
 522     einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
 523   global_found = false;
 524   lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
 525   if (global_found)
 526     {
 527       /* Return true to indicate that we found the file, even though
 528          we aren't going to do anything with it.  */
 529       return true;
 530     }
 531
 532   /* Tell the ELF backend that don't want the output file to have a
 533      DT_NEEDED entry for this file.  */
 534   bfd_elf_set_dt_needed_name (abfd, "");
 535
 536   /* Add this file into the symbol table.  */
 537   if (! bfd_link_add_symbols (abfd, &link_info))
 538     einfo ("%F%B: could not read symbols: %E\n", abfd);
 539
 540   return true;
 541 }
 542
 543 /* See if an input file matches a DT_NEEDED entry by name.  */
 544
 545 static void
 546 gld${EMULATION_NAME}_check_needed (s)
 547      lang_input_statement_type *s;
 548 {
 549   if (global_found)
 550     return;
 551
 552   if (s->filename != NULL
 553       && strcmp (s->filename, global_needed->name) == 0)
 554     {
 555       global_found = true;
 556       return;
 557     }
 558
 559   if (s->the_bfd != NULL)
 560     {
 561       const char *soname;
 562
 563       soname = bfd_elf_get_dt_soname (s->the_bfd);
 564       if (soname != NULL
 565           && strcmp (soname, global_needed->name) == 0)
 566         {
 567           global_found = true;
 568           return;
 569         }
 570     }
 571
 572   if (s->search_dirs_flag
 573       && s->filename != NULL
 574       && strchr (global_needed->name, '/') == NULL)
 575     {
 576       const char *f;
 577
 578       f = strrchr (s->filename, '/');
 579       if (f != NULL
 580           && strcmp (f + 1, global_needed->name) == 0)
 581         {
 582           global_found = true;
 583           return;
 584         }
 585     }
 586 }
 587
 588 /* See if an input file matches a DT_NEEDED entry by running stat on
 589    the file.  */
 590
 591 static void
 592 gld${EMULATION_NAME}_stat_needed (s)
 593      lang_input_statement_type *s;
 594 {
 595   struct stat st;
 596   const char *suffix;
 597   const char *soname;
 598   const char *f;
 599
 600   if (global_found)
 601     return;
 602   if (s->the_bfd == NULL)
 603     return;
 604
 605   if (bfd_stat (s->the_bfd, &st) != 0)
 606     {
 607       einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
 608       return;
 609     }
 610
 611   if (st.st_dev == global_stat.st_dev
 612       && st.st_ino == global_stat.st_ino)
 613     {
 614       global_found = true;
 615       return;
 616     }
 617
 618   /* We issue a warning if it looks like we are including two
 619      different versions of the same shared library.  For example,
 620      there may be a problem if -lc picks up libc.so.6 but some other
 621      shared library has a DT_NEEDED entry of libc.so.5.  This is a
 622      hueristic test, and it will only work if the name looks like
 623      NAME.so.VERSION.  FIXME: Depending on file names is error-prone.
 624      If we really want to issue warnings about mixing version numbers
 625      of shared libraries, we need to find a better way.  */
 626
 627   if (strchr (global_needed->name, '/') != NULL)
 628     return;
 629   suffix = strstr (global_needed->name, ".so.");
 630   if (suffix == NULL)
 631     return;
 632   suffix += sizeof ".so." - 1;
 633
 634   soname = bfd_elf_get_dt_soname (s->the_bfd);
 635   if (soname == NULL)
 636     soname = s->filename;
 637
 638   f = strrchr (soname, '/');
 639   if (f != NULL)
 640     ++f;
 641   else
 642     f = soname;
 643
 644   if (strncmp (f, global_needed->name, suffix - global_needed->name) == 0)
 645     einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
 646            global_needed->name, global_needed->by, f);
 647 }
 648
 649 /* On Linux, it's possible to have different versions of the same
 650    shared library linked against different versions of libc.  The
 651    dynamic linker somehow tags which libc version to use in
 652    /etc/ld.so.cache, and, based on the libc that it sees in the
 653    executable, chooses which version of the shared library to use.
 654
 655    We try to do a similar check here by checking whether this shared
 656    library needs any other shared libraries which may conflict with
 657    libraries we have already included in the link.  If it does, we
 658    skip it, and try to find another shared library farther on down the
 659    link path.
 660
 661    This is called via lang_for_each_input_file.
 662    GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
 663    which we ar checking.  This sets GLOBAL_VERCHECK_FAILED if we find
 664    a conflicting version.  */
 665
 666 static void
 667 gld${EMULATION_NAME}_vercheck (s)
 668      lang_input_statement_type *s;
 669 {
 670   const char *soname, *f;
 671   struct bfd_link_needed_list *l;
 672
 673   if (global_vercheck_failed)
 674     return;
 675   if (s->the_bfd == NULL
 676       || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
 677     return;
 678
 679   soname = bfd_elf_get_dt_soname (s->the_bfd);
 680   if (soname == NULL)
 681     soname = bfd_get_filename (s->the_bfd);
 682
 683   f = strrchr (soname, '/');
 684   if (f != NULL)
 685     ++f;
 686   else
 687     f = soname;
 688
 689   for (l = global_vercheck_needed; l != NULL; l = l->next)
 690     {
 691       const char *suffix;
 692
 693       if (strcmp (f, l->name) == 0)
 694         {
 695           /* Probably can't happen, but it's an easy check.  */
 696           continue;
 697         }
 698
 699       if (strchr (l->name, '/') != NULL)
 700         continue;
 701
 702       suffix = strstr (l->name, ".so.");
 703       if (suffix == NULL)
 704         continue;
 705
 706       suffix += sizeof ".so." - 1;
 707
 708       if (strncmp (f, l->name, suffix - l->name) == 0)
 709         {
 710           /* Here we know that S is a dynamic object FOO.SO.VER1, and
 711              the object we are considering needs a dynamic object
 712              FOO.SO.VER2, and VER1 and VER2 are different.  This
 713              appears to be a version mismatch, so we tell the caller
 714              to try a different version of this library.  */
 715           global_vercheck_failed = true;
 716           return;
 717         }
 718     }
 719 }
 720
 721 /* This is called after the sections have been attached to output
 722    sections, but before any sizes or addresses have been set.  */
 723
 724 static void
 725 gld${EMULATION_NAME}_before_allocation ()
 726 {
 727   const char *rpath;
 728   asection *sinterp;
 729
 730   /* If we are going to make any variable assignments, we need to let
 731      the ELF backend know about them in case the variables are
 732      referred to by dynamic objects.  */
 733   lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
 734
 735   /* Let the ELF backend work out the sizes of any sections required
 736      by dynamic linking.  */
 737   rpath = command_line.rpath;
 738   if (rpath == NULL)
 739     rpath = (const char *) getenv ("LD_RUN_PATH");
 740   if (! (bfd_elf${ELFSIZE}_size_dynamic_sections
 741          (output_bfd, command_line.soname, rpath,
 742           command_line.export_dynamic, command_line.filter_shlib,
 743           (const char * const *) command_line.auxiliary_filters,
 744           &link_info, &sinterp, lang_elf_version_info)))
 745     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
 746
 747   /* Let the user override the dynamic linker we are using.  */
 748   if (command_line.interpreter != NULL
 749       && sinterp != NULL)
 750     {
 751       sinterp->contents = (bfd_byte *) command_line.interpreter;
 752       sinterp->_raw_size = strlen (command_line.interpreter) + 1;
 753     }
 754
 755   /* Look for any sections named .gnu.warning.  As a GNU extensions,
 756      we treat such sections as containing warning messages.  We print
 757      out the warning message, and then zero out the section size so
 758      that it does not get copied into the output file.  */
 759
 760   {
 761     LANG_FOR_EACH_INPUT_STATEMENT (is)
 762       {
 763         asection *s;
 764         bfd_size_type sz;
 765         char *msg;
 766         boolean ret;
 767
 768         if (is->just_syms_flag)
 769           continue;
 770
 771         s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
 772         if (s == NULL)
 773           continue;
 774
 775         sz = bfd_section_size (is->the_bfd, s);
 776         msg = xmalloc ((size_t) sz + 1);
 777         if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
 778           einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
 779                  is->the_bfd);
 780         msg[sz] = '\0';
 781         ret = link_info.callbacks->warning (&link_info, msg,
 782                                             (const char *) NULL,
 783                                             is->the_bfd, (asection *) NULL,
 784                                             (bfd_vma) 0);
 785         ASSERT (ret);
 786         free (msg);
 787
 788         /* Clobber the section size, so that we don't waste copying the
 789            warning into the output file.  */
 790         s->_raw_size = 0;
 791       }
 792   }
 793 }
 794
 795 /* This is called by the before_allocation routine via
 796    lang_for_each_statement.  It locates any assignment statements, and
 797    tells the ELF backend about them, in case they are assignments to
 798    symbols which are referred to by dynamic objects.  */
 799
 800 static void
 801 gld${EMULATION_NAME}_find_statement_assignment (s)
 802      lang_statement_union_type *s;
 803 {
 804   if (s->header.type == lang_assignment_statement_enum)
 805     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
 806 }
 807
 808 /* Look through an expression for an assignment statement.  */
 809
 810 static void
 811 gld${EMULATION_NAME}_find_exp_assignment (exp)
 812      etree_type *exp;
 813 {
 814   struct bfd_link_hash_entry *h;
 815
 816   switch (exp->type.node_class)
 817     {
 818     case etree_provide:
 819       h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
 820                                 false, false, false);
 821       if (h == NULL)
 822         break;
 823
 824       /* We call record_link_assignment even if the symbol is defined.
 825          This is because if it is defined by a dynamic object, we
 826          actually want to use the value defined by the linker script,
 827          not the value from the dynamic object (because we are setting
 828          symbols like etext).  If the symbol is defined by a regular
 829          object, then, as it happens, calling record_link_assignment
 830          will do no harm.  */
 831
 832       /* Fall through.  */
 833     case etree_assign:
 834       if (strcmp (exp->assign.dst, ".") != 0)
 835         {
 836           if (! (bfd_elf${ELFSIZE}_record_link_assignment
 837                  (output_bfd, &link_info, exp->assign.dst,
 838                   exp->type.node_class == etree_provide ? true : false)))
 839             einfo ("%P%F: failed to record assignment to %s: %E\n",
 840                    exp->assign.dst);
 841         }
 842       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
 843       break;
 844
 845     case etree_binary:
 846       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
 847       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
 848       break;
 849
 850     case etree_trinary:
 851       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
 852       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 853       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
 854       break;
 855
 856     case etree_unary:
 857       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
 858       break;
 859
 860     default:
 861       break;
 862     }
 863 }
 864
 865 /* Place an orphan section.  We use this to put random SHF_ALLOC
 866    sections in the right segment.  */
 867
 868 static asection *hold_section;
 869 static lang_output_section_statement_type *hold_use;
 870
 871 struct orphan_save
 872 {
 873   lang_output_section_statement_type *os;
 874   asection **section;
 875   lang_statement_union_type **stmt;
 876 };
 877 static struct orphan_save hold_text;
 878 static struct orphan_save hold_rodata;
 879 static struct orphan_save hold_data;
 880 static struct orphan_save hold_bss;
 881 static struct orphan_save hold_rel;
 882 static struct orphan_save hold_interp;
 883
 884 /*ARGSUSED*/
 885 static boolean
 886 gld${EMULATION_NAME}_place_orphan (file, s)
 887      lang_input_statement_type *file;
 888      asection *s;
 889 {
 890   struct orphan_save *place;
 891   lang_statement_list_type *old;
 892   lang_statement_list_type add;
 893   etree_type *address;
 894   const char *secname, *ps;
 895   const char *outsecname;
 896   lang_output_section_statement_type *os;
 897
 898   /* Look through the script to see where to place this section.  */
 899   hold_section = s;
 900   hold_use = NULL;
 901   lang_for_each_statement (gld${EMULATION_NAME}_place_section);
 902
 903   if (hold_use != NULL)
 904     {
 905       /* We have already placed a section with this name.  */
 906       wild_doit (&hold_use->children, s, hold_use, file);
 907       return true;
 908     }
 909
 910   secname = bfd_get_section_name (s->owner, s);
 911
 912   /* If this is a final link, then always put .gnu.warning.SYMBOL
 913      sections into the .text section to get them out of the way.  */
 914   if (! link_info.shared
 915       && ! link_info.relocateable
 916       && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
 917       && hold_text.os != NULL)
 918     {
 919       wild_doit (&hold_text.os->children, s, hold_text.os, file);
 920       return true;
 921     }
 922
 923   /* Decide which segment the section should go in based on the
 924      section name and section flags.  We put loadable .note sections
 925      right after the .interp section, so that the PT_NOTE segment is
 926      stored right after the program headers where the OS can read it
 927      in the first page.  */
 928   if (s->flags & SEC_EXCLUDE)
 929     return false;
 930   else if ((s->flags & SEC_ALLOC) == 0)
 931     place = NULL;
 932   else if ((s->flags & SEC_LOAD) != 0
 933            && strncmp (secname, ".note", 4) == 0
 934            && hold_interp.os != NULL)
 935     place = &hold_interp;
 936   else if ((s->flags & SEC_HAS_CONTENTS) == 0
 937            && hold_bss.os != NULL)
 938     place = &hold_bss;
 939   else if ((s->flags & SEC_READONLY) == 0
 940            && hold_data.os != NULL)
 941     place = &hold_data;
 942   else if (strncmp (secname, ".rel", 4) == 0
 943            && hold_rel.os != NULL)
 944     place = &hold_rel;
 945   else if ((s->flags & SEC_CODE) == 0
 946            && (s->flags & SEC_READONLY) != 0
 947            && hold_rodata.os != NULL)
 948     place = &hold_rodata;
 949   else if ((s->flags & SEC_READONLY) != 0
 950            && hold_text.os != NULL)
 951     place = &hold_text;
 952   else
 953     place = NULL;
 954
 955   /* Choose a unique name for the section.  This will be needed if the
 956      same section name appears in the input file with different
 957      loadable or allocateable characteristics.  */
 958   outsecname = secname;
 959   if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
 960     {
 961       unsigned int len;
 962       char *newname;
 963       unsigned int i;
 964
 965       len = strlen (outsecname);
 966       newname = xmalloc (len + 5);
 967       strcpy (newname, outsecname);
 968       i = 0;
 969       do
 970         {
 971           sprintf (newname + len, "%d", i);
 972           ++i;
 973         }
 974       while (bfd_get_section_by_name (output_bfd, newname) != NULL);
 975
 976       outsecname = newname;
 977     }
 978
 979   if (place != NULL)
 980     {
 981       /* Start building a list of statements for this section.  */
 982       old = stat_ptr;
 983       stat_ptr = &add;
 984       lang_list_init (stat_ptr);
 985
 986       /* If the name of the section is representable in C, then create
 987          symbols to mark the start and the end of the section.  */
 988       for (ps = outsecname; *ps != '\0'; ps++)
 989         if (! isalnum ((unsigned char) *ps) && *ps != '_')
 990           break;
 991       if (*ps == '\0' && config.build_constructors)
 992         {
 993           char *symname;
 994           etree_type *e_align;
 995
 996           symname = (char *) xmalloc (ps - outsecname + sizeof "__start_");
 997           sprintf (symname, "__start_%s", outsecname);
 998           e_align = exp_unop (ALIGN_K,
 999                               exp_intop ((bfd_vma) 1 << s->alignment_power));
1000           lang_add_assignment (exp_assop ('=', symname, e_align));
1001         }
1002     }
1003
1004   if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1005     address = exp_intop ((bfd_vma) 0);
1006   else
1007     address = NULL;
1008
1009   lang_enter_output_section_statement (outsecname, address, 0,
1010                                        (bfd_vma) 0,
1011                                        (etree_type *) NULL,
1012                                        (etree_type *) NULL,
1013                                        (etree_type *) NULL);
1014
1015   os = lang_output_section_statement_lookup (outsecname);
1016   wild_doit (&os->children, s, os, file);
1017
1018   if (place != NULL)
1019     {
1020       asection *snew, **pps;
1021
1022       lang_leave_output_section_statement
1023         ((bfd_vma) 0, "*default*",
1024          (struct lang_output_section_phdr_list *) NULL, "*default*");
1025       stat_ptr = &add;
1026
1027       if (*ps == '\0' && config.build_constructors)
1028         {
1029           char *symname;
1030
1031           symname = (char *) xmalloc (ps - outsecname + sizeof "__stop_");
1032           sprintf (symname, "__stop_%s", outsecname);
1033           lang_add_assignment (exp_assop ('=', symname,
1034                                           exp_nameop (NAME, ".")));
1035         }
1036       stat_ptr = old;
1037
1038       snew = os->bfd_section;
1039       if (place->os->bfd_section != NULL || place->section != NULL)
1040         {
1041           /* Shuffle the section to make the output file look neater.  */
1042           if (place->section == NULL)
1043             {
1044 #if 0
1045               /* Finding the end of the list is a little tricky.  We
1046                  make a wild stab at it by comparing section flags.  */
1047               flagword first_flags = place->os->bfd_section->flags;
1048               for (pps = &place->os->bfd_section->next;
1049                    *pps != NULL && (*pps)->flags == first_flags;
1050                    pps = &(*pps)->next)
1051                 ;
1052               place->section = pps;
1053 #else
1054               /* Put orphans after the first section on the list.  */
1055               place->section = &place->os->bfd_section->next;
1056 #endif
1057             }
1058
1059           /*  Unlink the section.  */
1060           for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1061             ;
1062           *pps = snew->next;
1063
1064           /* Now tack it on to the "place->os" section list.  */
1065           snew->next = *place->section;
1066           *place->section = snew;
1067         }
1068       place->section = &snew->next;     /* Save the end of this list.  */
1069
1070       if (place->stmt == NULL)
1071         {
1072           /* Put the new statement list right at the head.  */
1073           *add.tail = place->os->header.next;
1074           place->os->header.next = add.head;
1075         }
1076       else
1077         {
1078           /* Put it after the last orphan statement we added.  */
1079           *add.tail = *place->stmt;
1080           *place->stmt = add.head;
1081         }
1082       place->stmt = add.tail;           /* Save the end of this list.  */
1083     }
1084
1085   return true;
1086 }
1087
1088 static void
1089 gld${EMULATION_NAME}_place_section (s)
1090      lang_statement_union_type *s;
1091 {
1092   lang_output_section_statement_type *os;
1093
1094   if (s->header.type != lang_output_section_statement_enum)
1095     return;
1096
1097   os = &s->output_section_statement;
1098
1099   if (strcmp (os->name, hold_section->name) == 0
1100       && os->bfd_section != NULL
1101       && ((hold_section->flags & (SEC_LOAD | SEC_ALLOC))
1102           == (os->bfd_section->flags & (SEC_LOAD | SEC_ALLOC))))
1103     hold_use = os;
1104
1105   if (strcmp (os->name, ".text") == 0)
1106     hold_text.os = os;
1107   else if (strcmp (os->name, ".rodata") == 0)
1108     hold_rodata.os = os;
1109   else if (strcmp (os->name, ".data") == 0)
1110     hold_data.os = os;
1111   else if (strcmp (os->name, ".bss") == 0)
1112     hold_bss.os = os;
1113   else if (hold_rel.os == NULL
1114            && os->bfd_section != NULL
1115            && (os->bfd_section->flags & SEC_ALLOC) != 0
1116            && strncmp (os->name, ".rel", 4) == 0)
1117     hold_rel.os = os;
1118   else if (strcmp (os->name, ".interp") == 0)
1119     hold_interp.os = os;
1120 }
1121
1122 static char *
1123 gld${EMULATION_NAME}_get_script(isfile)
1124      int *isfile;
1125 EOF
1126
1127 if test -n "$COMPILE_IN"
1128 then
1129 # Scripts compiled in.
1130
1131 # sed commands to quote an ld script as a C string.
1132 sc="-f stringify.sed"
1133
1134 cat >>e${EMULATION_NAME}.c <<EOF
1135 {
1136   *isfile = 0;
1137
1138   if (link_info.relocateable == true && config.build_constructors == true)
1139     return
1140 EOF
1141 sed $sc ldscripts/${EMULATION_NAME}.xu                     >> e${EMULATION_NAME}.c
1142 echo '  ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1143 sed $sc ldscripts/${EMULATION_NAME}.xr                     >> e${EMULATION_NAME}.c
1144 echo '  ; else if (!config.text_read_only) return'         >> e${EMULATION_NAME}.c
1145 sed $sc ldscripts/${EMULATION_NAME}.xbn                    >> e${EMULATION_NAME}.c
1146 echo '  ; else if (!config.magic_demand_paged) return'     >> e${EMULATION_NAME}.c
1147 sed $sc ldscripts/${EMULATION_NAME}.xn                     >> e${EMULATION_NAME}.c
1148
1149 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1150 echo '  ; else if (link_info.shared) return'               >> e${EMULATION_NAME}.c
1151 sed $sc ldscripts/${EMULATION_NAME}.xs                     >> e${EMULATION_NAME}.c
1152 fi
1153
1154 echo '  ; else return'                                     >> e${EMULATION_NAME}.c
1155 sed $sc ldscripts/${EMULATION_NAME}.x                      >> e${EMULATION_NAME}.c
1156 echo '; }'                                                 >> e${EMULATION_NAME}.c
1157
1158 else
1159 # Scripts read from the filesystem.
1160
1161 cat >>e${EMULATION_NAME}.c <<EOF
1162 {
1163   *isfile = 1;
1164
1165   if (link_info.relocateable == true && config.build_constructors == true)
1166     return "ldscripts/${EMULATION_NAME}.xu";
1167   else if (link_info.relocateable == true)
1168     return "ldscripts/${EMULATION_NAME}.xr";
1169   else if (!config.text_read_only)
1170     return "ldscripts/${EMULATION_NAME}.xbn";
1171   else if (!config.magic_demand_paged)
1172     return "ldscripts/${EMULATION_NAME}.xn";
1173   else if (link_info.shared)
1174     return "ldscripts/${EMULATION_NAME}.xs";
1175   else
1176     return "ldscripts/${EMULATION_NAME}.x";
1177 }
1178 EOF
1179
1180 fi
1181
1182 if test -n "$PARSE_AND_LIST_ARGS" ; then
1183 cat >>e${EMULATION_NAME}.c <<EOF
1184 static int  gld_${EMULATION_NAME}_parse_args PARAMS ((int, char **));
1185 static void gld_${EMULATION_NAME}_list_options PARAMS ((FILE * file));
1186
1187  $PARSE_AND_LIST_ARGS
1188 EOF
1189 else
1190
1191 cat >>e${EMULATION_NAME}.c <<EOF
1192 #define gld_${EMULATION_NAME}_parse_args   NULL
1193 #define gld_${EMULATION_NAME}_list_options NULL
1194 EOF
1195
1196 fi
1197
1198 cat >>e${EMULATION_NAME}.c <<EOF
1199
1200 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1201 {
1202   gld${EMULATION_NAME}_before_parse,
1203   syslib_default,
1204   hll_default,
1205   after_parse_default,
1206   gld${EMULATION_NAME}_after_open,
1207   after_allocation_default,
1208   set_output_arch_default,
1209   ldemul_default_target,
1210   gld${EMULATION_NAME}_before_allocation,
1211   gld${EMULATION_NAME}_get_script,
1212   "${EMULATION_NAME}",
1213   "${OUTPUT_FORMAT}",
1214   NULL,         /* finish */
1215   NULL,         /* create output section statements */
1216   gld${EMULATION_NAME}_open_dynamic_archive,
1217   gld${EMULATION_NAME}_place_orphan,
1218   NULL,         /* set_symbols */
1219   gld_${EMULATION_NAME}_parse_args,
1220   NULL,         /* unrecognized_file */
1221   gld_${EMULATION_NAME}_list_options,
1222   NULL,         /* recognized_file */
1223   NULL          /* find_potential_libraries */
1224 };
1225 EOF