ld/emultempl/sunos.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 if [ -z "$MACHINE" ]; then
   4   OUTPUT_ARCH=${ARCH}
   5 else
   6   OUTPUT_ARCH=${ARCH}:${MACHINE}
   7 fi
   8 fragment <<EOF
   9 /* This file is is generated by a shell script.  DO NOT EDIT! */
  10
  11 /* SunOS emulation code for ${EMULATION_NAME}
  12    Copyright (C) 1991-2016 Free Software Foundation, Inc.
  13    Written by Steve Chamberlain <sac@cygnus.com>
  14    SunOS shared library support by Ian Lance Taylor <ian@cygnus.com>
  15
  16    This file is part of the GNU Binutils.
  17
  18    This program is free software; you can redistribute it and/or modify
  19    it under the terms of the GNU General Public License as published by
  20    the Free Software Foundation; either version 3 of the License, or
  21    (at your option) any later version.
  22
  23    This program is distributed in the hope that it will be useful,
  24    but WITHOUT ANY WARRANTY; without even the implied warranty of
  25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26    GNU General Public License for more details.
  27
  28    You should have received a copy of the GNU General Public License
  29    along with this program; if not, write to the Free Software
  30    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  31    MA 02110-1301, USA.  */
  32
  33 #define TARGET_IS_${EMULATION_NAME}
  34
  35 #include "sysdep.h"
  36 #include "bfd.h"
  37 #include "bfdlink.h"
  38 #include "libiberty.h"
  39 #include "safe-ctype.h"
  40
  41 #include "ld.h"
  42 #include "ldmain.h"
  43 #include "ldmisc.h"
  44 #include "ldexp.h"
  45 #include "ldlang.h"
  46 #include "ldfile.h"
  47 #include "ldemul.h"
  48
  49 #ifdef HAVE_DIRENT_H
  50 # include <dirent.h>
  51 #else
  52 # define dirent direct
  53 # ifdef HAVE_SYS_NDIR_H
  54 #  include <sys/ndir.h>
  55 # endif
  56 # ifdef HAVE_SYS_DIR_H
  57 #  include <sys/dir.h>
  58 # endif
  59 # ifdef HAVE_NDIR_H
  60 #  include <ndir.h>
  61 # endif
  62 #endif
  63
  64 static void gld${EMULATION_NAME}_find_so
  65   (lang_input_statement_type *);
  66 static char *gld${EMULATION_NAME}_search_dir
  67   (const char *, const char *, bfd_boolean *);
  68 static void gld${EMULATION_NAME}_check_needed
  69   (lang_input_statement_type *);
  70 static bfd_boolean gld${EMULATION_NAME}_search_needed
  71   (const char *, const char *);
  72 static bfd_boolean gld${EMULATION_NAME}_try_needed
  73   (const char *, const char *);
  74 static void gld${EMULATION_NAME}_find_assignment
  75   (lang_statement_union_type *);
  76 static void gld${EMULATION_NAME}_find_exp_assignment
  77   (etree_type *);
  78 static void gld${EMULATION_NAME}_count_need
  79   (lang_input_statement_type *);
  80 static void gld${EMULATION_NAME}_set_need
  81   (lang_input_statement_type *);
  82
  83 static void
  84 gld${EMULATION_NAME}_before_parse (void)
  85 {
  86   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
  87   input_flags.dynamic = TRUE;
  88   config.has_shared = TRUE;
  89 }
  90
  91 /* This is called after the command line arguments have been parsed,
  92    but before the linker script has been read.  If this is a native
  93    linker, we add the directories in LD_LIBRARY_PATH to the search
  94    list.  */
  95
  96 static void
  97 gld${EMULATION_NAME}_set_symbols (void)
  98 {
  99 EOF
 100 if [ "x${host}" = "x${target}" ] ; then
 101   case " ${EMULATION_LIBPATH} " in
 102   *" ${EMULATION_NAME} "*)
 103 fragment <<EOF
 104   const char *env;
 105
 106   env = (const char *) getenv ("LD_LIBRARY_PATH");
 107   if (env != NULL)
 108     {
 109       char *l;
 110
 111       l = xstrdup (env);
 112       while (1)
 113         {
 114           char *c;
 115
 116           c = strchr (l, ':');
 117           if (c != NULL)
 118             *c++ = '\0';
 119           if (*l != '\0')
 120             ldfile_add_library_path (l, FALSE);
 121           if (c == NULL)
 122             break;
 123           l = c;
 124         }
 125     }
 126 EOF
 127   ;;
 128   esac
 129 fi
 130 fragment <<EOF
 131 }
 132
 133 /* Despite the name, we use this routine to search for dynamic
 134    libraries.  On SunOS this requires a directory search.  We need to
 135    find the .so file with the highest version number.  The user may
 136    restrict the major version by saying, e.g., -lc.1.  Also, if we
 137    find a .so file, we need to look for a the same file after
 138    replacing .so with .sa; if it exists, it will be an archive which
 139    provide some initializations for data symbols, and we need to
 140    search it after including the .so file.  */
 141
 142 static void
 143 gld${EMULATION_NAME}_create_output_section_statements (void)
 144 {
 145   lang_for_each_input_file (gld${EMULATION_NAME}_find_so);
 146 }
 147
 148 /* Search the directory for a .so file for each library search.  */
 149
 150 static void
 151 gld${EMULATION_NAME}_find_so (lang_input_statement_type *inp)
 152 {
 153   search_dirs_type *search;
 154   char *found = NULL;
 155   char *alc;
 156   struct stat st;
 157
 158   if (! inp->flags.search_dirs
 159       || ! inp->flags.maybe_archive
 160       || ! inp->flags.dynamic)
 161     return;
 162
 163   ASSERT (CONST_STRNEQ (inp->local_sym_name, "-l"));
 164
 165   for (search = search_head; search != NULL; search = search->next)
 166     {
 167       bfd_boolean found_static;
 168
 169       found = gld${EMULATION_NAME}_search_dir (search->name, inp->filename,
 170                                                &found_static);
 171       if (found != NULL || found_static)
 172         break;
 173     }
 174
 175   if (found == NULL)
 176     {
 177       /* We did not find a matching .so file.  This isn't an error,
 178          since there might still be a matching .a file, which will be
 179          found by the usual search.  */
 180       return;
 181     }
 182
 183   /* Replace the filename with the one we have found.  */
 184   alc = (char *) xmalloc (strlen (search->name) + strlen (found) + 2);
 185   sprintf (alc, "%s/%s", search->name, found);
 186   inp->filename = alc;
 187
 188   /* Turn off the search_dirs_flag to prevent ldfile_open_file from
 189      searching for this file again.  */
 190   inp->flags.search_dirs = FALSE;
 191
 192   free (found);
 193
 194   /* Now look for the same file name, but with .sa instead of .so.  If
 195      found, add it to the list of input files.  */
 196   alc = (char *) xmalloc (strlen (inp->filename) + 1);
 197   strcpy (alc, inp->filename);
 198   strstr (alc + strlen (search->name), ".so")[2] = 'a';
 199   if (stat (alc, &st) != 0)
 200     free (alc);
 201   else
 202     {
 203       lang_input_statement_type *sa;
 204
 205       /* Add the .sa file to the statement list just before the .so
 206          file.  This is really a hack.  */
 207       sa = ((lang_input_statement_type *)
 208             xmalloc (sizeof (lang_input_statement_type)));
 209       *sa = *inp;
 210
 211       inp->filename = alc;
 212       inp->local_sym_name = alc;
 213
 214       inp->header.next = (lang_statement_union_type *) sa;
 215       inp->next_real_file = (lang_statement_union_type *) sa;
 216     }
 217 }
 218
 219 /* Search a directory for a .so file.  */
 220
 221 static char *
 222 gld${EMULATION_NAME}_search_dir
 223   (const char *dirname, const char *filename, bfd_boolean *found_static)
 224 {
 225   int force_maj, force_min;
 226   const char *dot;
 227   unsigned int len;
 228   char *alc;
 229   char *found;
 230   int max_maj, max_min;
 231   DIR *dir;
 232   struct dirent *entry;
 233   unsigned int dirnamelen;
 234   char *full_path;
 235   int statval;
 236   struct stat st;
 237
 238   *found_static = FALSE;
 239
 240   force_maj = -1;
 241   force_min = -1;
 242   dot = strchr (filename, '.');
 243   if (dot == NULL)
 244     {
 245       len = strlen (filename);
 246       alc = NULL;
 247     }
 248   else
 249     {
 250       force_maj = atoi (dot + 1);
 251
 252       len = dot - filename;
 253       alc = (char *) xmalloc (len + 1);
 254       strncpy (alc, filename, len);
 255       alc[len] = '\0';
 256       filename = alc;
 257
 258       dot = strchr (dot + 1, '.');
 259       if (dot != NULL)
 260         force_min = atoi (dot + 1);
 261     }
 262
 263   found = NULL;
 264   max_maj = max_min = 0;
 265
 266   dir = opendir (dirname);
 267   if (dir == NULL)
 268     return NULL;
 269   dirnamelen = strlen (dirname);
 270
 271   while ((entry = readdir (dir)) != NULL)
 272     {
 273       const char *s;
 274       int found_maj, found_min;
 275
 276       if (! CONST_STRNEQ (entry->d_name, "lib")
 277           || strncmp (entry->d_name + 3, filename, len) != 0)
 278         continue;
 279
 280       if (dot == NULL
 281           && strcmp (entry->d_name + 3 + len, ".a") == 0)
 282         {
 283           *found_static = TRUE;
 284           continue;
 285         }
 286
 287       /* We accept libfoo.so without a version number, even though the
 288          native linker does not.  This is more convenient for packages
 289          which just generate .so files for shared libraries, as on ELF
 290          systems.  */
 291       if (! CONST_STRNEQ (entry->d_name + 3 + len, ".so"))
 292         continue;
 293       if (entry->d_name[6 + len] == '\0')
 294         ;
 295       else if (entry->d_name[6 + len] == '.'
 296                && ISDIGIT (entry->d_name[7 + len]))
 297         ;
 298       else
 299         continue;
 300
 301       for (s = entry->d_name + 6 + len; *s != '\0'; s++)
 302         if (*s != '.' && ! ISDIGIT (*s))
 303           break;
 304       if (*s != '\0')
 305         continue;
 306
 307       /* We've found a .so file.  Work out the major and minor
 308          version numbers.  */
 309       found_maj = 0;
 310       found_min = 0;
 311       sscanf (entry->d_name + 3 + len, ".so.%d.%d",
 312               &found_maj, &found_min);
 313
 314       if ((force_maj != -1 && force_maj != found_maj)
 315           || (force_min != -1 && force_min != found_min))
 316         continue;
 317
 318       /* Make sure the file really exists (ignore broken symlinks).  */
 319       full_path = xmalloc (dirnamelen + 1 + strlen (entry->d_name) + 1);
 320       sprintf (full_path, "%s/%s", dirname, entry->d_name);
 321       statval = stat (full_path, &st);
 322       free (full_path);
 323       if (statval != 0)
 324         continue;
 325
 326       /* We've found a match for the name we are searching for.  See
 327          if this is the version we should use.  If the major and minor
 328          versions match, we use the last entry in alphabetical order;
 329          I don't know if this is how SunOS distinguishes libc.so.1.8
 330          from libc.so.1.8.1, but it ought to suffice.  */
 331       if (found == NULL
 332           || (found_maj > max_maj)
 333           || (found_maj == max_maj
 334               && (found_min > max_min
 335                   || (found_min == max_min
 336                       && strcmp (entry->d_name, found) > 0))))
 337         {
 338           if (found != NULL)
 339             free (found);
 340           found = (char *) xmalloc (strlen (entry->d_name) + 1);
 341           strcpy (found, entry->d_name);
 342           max_maj = found_maj;
 343           max_min = found_min;
 344         }
 345     }
 346
 347   closedir (dir);
 348
 349   if (alc != NULL)
 350     free (alc);
 351
 352   return found;
 353 }
 354
 355 /* These variables are required to pass information back and forth
 356    between after_open and check_needed.  */
 357
 358 static struct bfd_link_needed_list *global_needed;
 359 static bfd_boolean global_found;
 360
 361 /* This is called after all the input files have been opened.  */
 362
 363 static void
 364 gld${EMULATION_NAME}_after_open (void)
 365 {
 366   struct bfd_link_needed_list *needed, *l;
 367
 368   after_open_default ();
 369
 370   /* We only need to worry about this when doing a final link.  */
 371   if (bfd_link_relocatable (&link_info) || bfd_link_pic (&link_info))
 372     return;
 373
 374   /* Get the list of files which appear in ld_need entries in dynamic
 375      objects included in the link.  For each such file, we want to
 376      track down the corresponding library, and include the symbol
 377      table in the link.  This is what the runtime dynamic linker will
 378      do.  Tracking the files down here permits one dynamic object to
 379      include another without requiring special action by the person
 380      doing the link.  Note that the needed list can actually grow
 381      while we are stepping through this loop.  */
 382   needed = bfd_sunos_get_needed_list (link_info.output_bfd, &link_info);
 383   for (l = needed; l != NULL; l = l->next)
 384     {
 385       struct bfd_link_needed_list *ll;
 386       const char *lname;
 387       search_dirs_type *search;
 388
 389       lname = l->name;
 390
 391       /* If we've already seen this file, skip it.  */
 392       for (ll = needed; ll != l; ll = ll->next)
 393         if (strcmp (ll->name, lname) == 0)
 394           break;
 395       if (ll != l)
 396         continue;
 397
 398       /* See if this file was included in the link explicitly.  */
 399       global_needed = l;
 400       global_found = FALSE;
 401       lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
 402       if (global_found)
 403         continue;
 404
 405       if (! CONST_STRNEQ (lname, "-l"))
 406         {
 407           bfd *abfd;
 408
 409           abfd = bfd_openr (lname, bfd_get_target (link_info.output_bfd));
 410           if (abfd != NULL)
 411             {
 412               if (! bfd_check_format (abfd, bfd_object))
 413                 {
 414                   (void) bfd_close (abfd);
 415                   abfd = NULL;
 416                 }
 417             }
 418           if (abfd != NULL)
 419             {
 420               if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 421                 {
 422                   (void) bfd_close (abfd);
 423                   abfd = NULL;
 424                 }
 425             }
 426           if (abfd != NULL)
 427             {
 428               /* We've found the needed dynamic object.  */
 429               if (! bfd_link_add_symbols (abfd, &link_info))
 430                 einfo ("%F%B: error adding symbols: %E\n", abfd);
 431             }
 432           else
 433             {
 434               einfo ("%P: warning: %s, needed by %B, not found\n",
 435                      lname, l->by);
 436             }
 437
 438           continue;
 439         }
 440
 441       lname += 2;
 442
 443       /* We want to search for the file in the same way that the
 444          dynamic linker will search.  That means that we want to use
 445          rpath_link, rpath or -L, then the environment variable
 446          LD_LIBRARY_PATH (native only), then (if rpath was used) the
 447          linker script LIB_SEARCH_DIRS.  */
 448       if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
 449                                               lname))
 450         continue;
 451       if (command_line.rpath != NULL)
 452         {
 453           if (gld${EMULATION_NAME}_search_needed (command_line.rpath, lname))
 454             continue;
 455         }
 456       else
 457         {
 458           for (search = search_head; search != NULL; search = search->next)
 459             if (gld${EMULATION_NAME}_try_needed (search->name, lname))
 460               break;
 461           if (search != NULL)
 462             continue;
 463         }
 464 EOF
 465 if [ "x${host}" = "x${target}" ] ; then
 466   case " ${EMULATION_LIBPATH} " in
 467   *" ${EMULATION_NAME} "*)
 468 fragment <<EOF
 469       {
 470         const char *lib_path;
 471
 472         lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
 473         if (gld${EMULATION_NAME}_search_needed (lib_path, lname))
 474           continue;
 475       }
 476 EOF
 477   ;;
 478   esac
 479 fi
 480 fragment <<EOF
 481       if (command_line.rpath != NULL)
 482         {
 483           for (search = search_head; search != NULL; search = search->next)
 484             {
 485               if (search->cmdline)
 486                 continue;
 487               if (gld${EMULATION_NAME}_try_needed (search->name, lname))
 488                 break;
 489             }
 490           if (search != NULL)
 491             continue;
 492         }
 493
 494       einfo ("%P: warning: %s, needed by %B, not found\n",
 495              l->name, l->by);
 496     }
 497 }
 498
 499 /* Search for a needed file in a path.  */
 500
 501 static bfd_boolean
 502 gld${EMULATION_NAME}_search_needed (const char *path, const char *name)
 503 {
 504   const char *s;
 505
 506   if (path == NULL || *path == '\0')
 507     return FALSE;
 508   while (1)
 509     {
 510       const char *dir;
 511       char *dircopy;
 512
 513       s = strchr (path, ':');
 514       if (s == NULL)
 515         {
 516           dircopy = NULL;
 517           dir = path;
 518         }
 519       else
 520         {
 521           dircopy = (char *) xmalloc (s - path + 1);
 522           memcpy (dircopy, path, s - path);
 523           dircopy[s - path] = '\0';
 524           dir = dircopy;
 525         }
 526
 527       if (gld${EMULATION_NAME}_try_needed (dir, name))
 528         return TRUE;
 529
 530       if (dircopy != NULL)
 531         free (dircopy);
 532
 533       if (s == NULL)
 534         break;
 535       path = s + 1;
 536     }
 537
 538   return FALSE;
 539 }
 540
 541 /* This function is called for each possible directory for a needed
 542    dynamic object.  */
 543
 544 static bfd_boolean
 545 gld${EMULATION_NAME}_try_needed (const char *dir, const char *name)
 546 {
 547   char *file;
 548   char *alc;
 549   bfd_boolean ignore;
 550   bfd *abfd;
 551
 552   file = gld${EMULATION_NAME}_search_dir (dir, name, &ignore);
 553   if (file == NULL)
 554     return FALSE;
 555
 556   alc = (char *) xmalloc (strlen (dir) + strlen (file) + 2);
 557   sprintf (alc, "%s/%s", dir, file);
 558   free (file);
 559   abfd = bfd_openr (alc, bfd_get_target (link_info.output_bfd));
 560   if (abfd == NULL)
 561     return FALSE;
 562   if (! bfd_check_format (abfd, bfd_object))
 563     {
 564       (void) bfd_close (abfd);
 565       return FALSE;
 566     }
 567   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 568     {
 569       (void) bfd_close (abfd);
 570       return FALSE;
 571     }
 572
 573   /* We've found the needed dynamic object.  */
 574
 575   /* Add this file into the symbol table.  */
 576   if (! bfd_link_add_symbols (abfd, &link_info))
 577     einfo ("%F%B: error adding symbols: %E\n", abfd);
 578
 579   return TRUE;
 580 }
 581
 582 /* See if we have already included a needed object in the link.  This
 583    does not have to be precise, as it does no harm to include a
 584    dynamic object more than once.  */
 585
 586 static void
 587 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
 588 {
 589   if (s->filename == NULL)
 590     return;
 591   if (! CONST_STRNEQ (global_needed->name, "-l"))
 592     {
 593       if (strcmp (s->filename, global_needed->name) == 0)
 594         global_found = TRUE;
 595     }
 596   else
 597     {
 598       const char *sname, *lname;
 599       const char *sdot, *ldot;
 600       int lmaj, lmin, smaj, smin;
 601
 602       lname = global_needed->name + 2;
 603
 604       sname = strrchr (s->filename, '/');
 605       if (sname == NULL)
 606         sname = s->filename;
 607       else
 608         ++sname;
 609
 610       if (! CONST_STRNEQ (sname, "lib"))
 611         return;
 612       sname += 3;
 613
 614       ldot = strchr (lname, '.');
 615       if (ldot == NULL)
 616         ldot = lname + strlen (lname);
 617
 618       sdot = strstr (sname, ".so.");
 619       if (sdot == NULL)
 620         return;
 621
 622       if (sdot - sname != ldot - lname
 623           || strncmp (lname, sname, sdot - sname) != 0)
 624         return;
 625
 626       lmaj = lmin = -1;
 627       sscanf (ldot, ".%d.%d", &lmaj, &lmin);
 628       smaj = smin = -1;
 629       sscanf (sdot, ".so.%d.%d", &smaj, &smin);
 630       if ((smaj != lmaj && smaj != -1 && lmaj != -1)
 631           || (smin != lmin && smin != -1 && lmin != -1))
 632         return;
 633
 634       global_found = TRUE;
 635     }
 636 }
 637
 638 /* We need to use static variables to pass information around the call
 639    to lang_for_each_statement.  Ick.  */
 640
 641 static const char *find_assign;
 642 static bfd_boolean found_assign;
 643
 644 /* We need to use static variables to pass information around the call
 645    to lang_for_each_input_file.  Ick.  */
 646
 647 static bfd_size_type need_size;
 648 static bfd_size_type need_entries;
 649 static bfd_byte *need_contents;
 650 static bfd_byte *need_pinfo;
 651 static bfd_byte *need_pnames;
 652
 653 /* The size of one entry in the .need section, not including the file
 654    name.  */
 655
 656 #define NEED_ENTRY_SIZE (16)
 657
 658 /* This is called after the sections have been attached to output
 659    sections, but before any sizes or addresses have been set.  */
 660
 661 static void
 662 gld${EMULATION_NAME}_before_allocation (void)
 663 {
 664   struct bfd_link_hash_entry *hdyn = NULL;
 665   asection *sneed;
 666   asection *srules;
 667   asection *sdyn;
 668
 669   /* The SunOS native linker creates a shared library whenever there
 670      are any undefined symbols in a link, unless -e is used.  This is
 671      pretty weird, but we are compatible.  */
 672   if (! bfd_link_pic (&link_info)
 673       && !bfd_link_relocatable (&link_info)
 674       && ! entry_from_cmdline)
 675     {
 676       struct bfd_link_hash_entry *h;
 677
 678       for (h = link_info.hash->undefs; h != NULL; h = h->u.undef.next)
 679         {
 680           if (h->type == bfd_link_hash_undefined
 681               && h->u.undef.abfd != NULL
 682               && (h->u.undef.abfd->flags & DYNAMIC) == 0
 683               && strcmp (h->root.string, "__DYNAMIC") != 0
 684               && strcmp (h->root.string, "__GLOBAL_OFFSET_TABLE_") != 0)
 685             {
 686               find_assign = h->root.string;
 687               found_assign = FALSE;
 688               lang_for_each_statement (gld${EMULATION_NAME}_find_assignment);
 689               if (! found_assign)
 690                 {
 691                   link_info.type = type_dll;
 692                   break;
 693                 }
 694             }
 695         }
 696     }
 697
 698   if (bfd_link_pic (&link_info))
 699     {
 700       lang_output_section_statement_type *os;
 701
 702       /* Set the .text section to start at 0x20, not 0x2020.  FIXME:
 703          This is too magical.  */
 704       os = lang_output_section_statement_lookup (".text", 0, TRUE);
 705       if (os->addr_tree == NULL)
 706         os->addr_tree = exp_intop (0x20);
 707     }
 708
 709   /* We need to create a __DYNAMIC symbol.  We don't do this in the
 710      linker script because we want to set the value to the start of
 711      the dynamic section if there is one, or to zero if there isn't
 712      one.  We need to create the symbol before calling
 713      size_dynamic_sections, although we can't set the value until
 714      afterward.  */
 715   if (!bfd_link_relocatable (&link_info))
 716     {
 717       hdyn = bfd_link_hash_lookup (link_info.hash, "__DYNAMIC", TRUE, FALSE,
 718                                    FALSE);
 719       if (hdyn == NULL)
 720         einfo ("%P%F: bfd_link_hash_lookup: %E\n");
 721       if (! bfd_sunos_record_link_assignment (link_info.output_bfd, &link_info,
 722                                               "__DYNAMIC"))
 723         einfo ("%P%F: failed to record assignment to __DYNAMIC: %E\n");
 724     }
 725
 726   /* If we are going to make any variable assignments, we need to let
 727      the backend linker know about them in case the variables are
 728      referred to by dynamic objects.  */
 729   lang_for_each_statement (gld${EMULATION_NAME}_find_assignment);
 730
 731   /* Let the backend linker work out the sizes of any sections
 732      required by dynamic linking.  */
 733   if (! bfd_sunos_size_dynamic_sections (link_info.output_bfd, &link_info,
 734                                          &sdyn, &sneed, &srules))
 735     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
 736
 737   if (sneed != NULL)
 738     {
 739       /* Set up the .need section.  See the description of the ld_need
 740          field in include/aout/sun4.h.  */
 741
 742       need_entries = 0;
 743       need_size = 0;
 744
 745       lang_for_each_input_file (gld${EMULATION_NAME}_count_need);
 746
 747       /* We should only have a .need section if we have at least one
 748          dynamic object.  */
 749       ASSERT (need_entries != 0);
 750
 751       sneed->size = need_size;
 752       sneed->contents = (bfd_byte *) xmalloc (need_size);
 753
 754       need_contents = sneed->contents;
 755       need_pinfo = sneed->contents;
 756       need_pnames = sneed->contents + need_entries * 16;
 757
 758       lang_for_each_input_file (gld${EMULATION_NAME}_set_need);
 759
 760       ASSERT ((bfd_size_type) (need_pnames - sneed->contents) == need_size);
 761     }
 762
 763   if (srules != NULL)
 764     {
 765       /* Set up the .rules section.  This is just a PATH like string
 766          of the -L arguments given on the command line.  We permit the
 767          user to specify the directories using the -rpath command line
 768          option.  */
 769       if (command_line.rpath)
 770         {
 771           srules->size = strlen (command_line.rpath);
 772           srules->contents = (bfd_byte *) command_line.rpath;
 773         }
 774       else
 775         {
 776           unsigned int size;
 777           search_dirs_type *search;
 778
 779           size = 0;
 780           for (search = search_head; search != NULL; search = search->next)
 781             if (search->cmdline)
 782               size += strlen (search->name) + 1;
 783           srules->size = size;
 784           if (size > 0)
 785             {
 786               char *p;
 787
 788               srules->contents = (bfd_byte *) xmalloc (size);
 789               p = (char *) srules->contents;
 790               *p = '\0';
 791               for (search = search_head; search != NULL; search = search->next)
 792                 {
 793                   if (search->cmdline)
 794                     {
 795                       if (p != (char *) srules->contents)
 796                         *p++ = ':';
 797                       strcpy (p, search->name);
 798                       p += strlen (p);
 799                     }
 800                 }
 801             }
 802         }
 803     }
 804
 805   /* We must assign a value to __DYNAMIC.  It should be zero if we are
 806      not doing a dynamic link, or the start of the .dynamic section if
 807      we are doing one.  */
 808   if (!bfd_link_relocatable (&link_info))
 809     {
 810       hdyn->type = bfd_link_hash_defined;
 811       hdyn->u.def.value = 0;
 812       if (sdyn != NULL)
 813         hdyn->u.def.section = sdyn;
 814       else
 815         hdyn->u.def.section = bfd_abs_section_ptr;
 816     }
 817
 818   before_allocation_default ();
 819 }
 820
 821 /* This is called by the before_allocation routine via
 822    lang_for_each_statement.  It does one of two things: if the
 823    variable find_assign is set, it sets found_assign if it finds an
 824    assignment to that variable; otherwise it tells the backend linker
 825    about all assignment statements, in case they are assignments to
 826    symbols which are referred to by dynamic objects.  */
 827
 828 static void
 829 gld${EMULATION_NAME}_find_assignment (lang_statement_union_type *s)
 830 {
 831   if (s->header.type == lang_assignment_statement_enum
 832       && (find_assign == NULL || ! found_assign))
 833     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
 834 }
 835
 836 /* Look through an expression for an assignment statement.  */
 837
 838 static void
 839 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
 840 {
 841   switch (exp->type.node_class)
 842     {
 843     case etree_assign:
 844       if (find_assign != NULL)
 845         {
 846           if (strcmp (find_assign, exp->assign.dst) == 0)
 847             found_assign = TRUE;
 848           return;
 849         }
 850
 851       if (strcmp (exp->assign.dst, ".") != 0)
 852         {
 853           if (! bfd_sunos_record_link_assignment (link_info.output_bfd,
 854                                                   &link_info,
 855                                                   exp->assign.dst))
 856             einfo ("%P%F: failed to record assignment to %s: %E\n",
 857                    exp->assign.dst);
 858         }
 859       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
 860       break;
 861
 862     case etree_binary:
 863       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
 864       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
 865       break;
 866
 867     case etree_trinary:
 868       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
 869       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 870       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
 871       break;
 872
 873     case etree_unary:
 874       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
 875       break;
 876
 877     default:
 878       break;
 879     }
 880 }
 881
 882 /* Work out the size of the .need section, and the number of entries.
 883    The backend will set the ld_need field of the dynamic linking
 884    information to point to the .need section.  See include/aout/sun4.h
 885    for more information.  */
 886
 887 static void
 888 gld${EMULATION_NAME}_count_need (lang_input_statement_type *inp)
 889 {
 890   if (inp->the_bfd != NULL
 891       && (inp->the_bfd->flags & DYNAMIC) != 0)
 892     {
 893       ++need_entries;
 894       need_size += NEED_ENTRY_SIZE;
 895       if (! inp->flags.maybe_archive)
 896         need_size += strlen (inp->filename) + 1;
 897       else
 898         {
 899           ASSERT (inp->local_sym_name[0] == '-'
 900                   && inp->local_sym_name[1] == 'l');
 901           need_size += strlen (inp->local_sym_name + 2) + 1;
 902         }
 903     }
 904 }
 905
 906 /* Fill in the contents of the .need section.  */
 907
 908 static void
 909 gld${EMULATION_NAME}_set_need (lang_input_statement_type *inp)
 910 {
 911   if (inp->the_bfd != NULL
 912       && (inp->the_bfd->flags & DYNAMIC) != 0)
 913     {
 914       bfd_size_type c;
 915
 916       /* To really fill in the .need section contents, we need to know
 917          the final file position of the section, but we don't.
 918          Instead, we use offsets, and rely on the BFD backend to
 919          finish the section up correctly.  FIXME: Talk about lack of
 920          referential locality.  */
 921       bfd_put_32 (link_info.output_bfd, need_pnames - need_contents,
 922                   need_pinfo);
 923       if (! inp->flags.maybe_archive)
 924         {
 925           bfd_put_32 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 4);
 926           bfd_put_16 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 8);
 927           bfd_put_16 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 10);
 928           strcpy ((char *) need_pnames, inp->filename);
 929         }
 930       else
 931         {
 932           char *verstr;
 933           int maj, min;
 934
 935           bfd_put_32 (link_info.output_bfd, (bfd_vma) 0x80000000,
 936                       need_pinfo + 4);
 937           maj = 0;
 938           min = 0;
 939           verstr = strstr (inp->filename, ".so.");
 940           if (verstr != NULL)
 941             sscanf (verstr, ".so.%d.%d", &maj, &min);
 942           bfd_put_16 (link_info.output_bfd, (bfd_vma) maj, need_pinfo + 8);
 943           bfd_put_16 (link_info.output_bfd, (bfd_vma) min, need_pinfo + 10);
 944           strcpy ((char *) need_pnames, inp->local_sym_name + 2);
 945         }
 946
 947       c = (need_pinfo - need_contents) / NEED_ENTRY_SIZE;
 948       if (c + 1 >= need_entries)
 949         bfd_put_32 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 12);
 950       else
 951         bfd_put_32 (link_info.output_bfd, (bfd_vma) (c + 1) * NEED_ENTRY_SIZE,
 952                     need_pinfo + 12);
 953
 954       need_pinfo += NEED_ENTRY_SIZE;
 955       need_pnames += strlen ((char *) need_pnames) + 1;
 956     }
 957 }
 958
 959 static char *
 960 gld${EMULATION_NAME}_get_script (int *isfile)
 961 EOF
 962
 963 if test x"$COMPILE_IN" = xyes
 964 then
 965 # Scripts compiled in.
 966
 967 # sed commands to quote an ld script as a C string.
 968 sc="-f stringify.sed"
 969
 970 fragment <<EOF
 971 {
 972   *isfile = 0;
 973
 974   if (bfd_link_relocatable (&link_info) && config.build_constructors)
 975     return
 976 EOF
 977 sed $sc ldscripts/${EMULATION_NAME}.xu                     >> e${EMULATION_NAME}.c
 978 echo '  ; else if (bfd_link_relocatable (&link_info)) return' >> e${EMULATION_NAME}.c
 979 sed $sc ldscripts/${EMULATION_NAME}.xr                     >> e${EMULATION_NAME}.c
 980 echo '  ; else if (!config.text_read_only) return'         >> e${EMULATION_NAME}.c
 981 sed $sc ldscripts/${EMULATION_NAME}.xbn                    >> e${EMULATION_NAME}.c
 982 echo '  ; else if (!config.magic_demand_paged) return'     >> e${EMULATION_NAME}.c
 983 sed $sc ldscripts/${EMULATION_NAME}.xn                     >> e${EMULATION_NAME}.c
 984 echo '  ; else return'                                     >> e${EMULATION_NAME}.c
 985 sed $sc ldscripts/${EMULATION_NAME}.x                      >> e${EMULATION_NAME}.c
 986 echo '; }'                                                 >> e${EMULATION_NAME}.c
 987
 988 else
 989 # Scripts read from the filesystem.
 990
 991 fragment <<EOF
 992 {
 993   *isfile = 1;
 994
 995   if (bfd_link_relocatable (&link_info) && config.build_constructors)
 996     return "ldscripts/${EMULATION_NAME}.xu";
 997   else if (bfd_link_relocatable (&link_info))
 998     return "ldscripts/${EMULATION_NAME}.xr";
 999   else if (!config.text_read_only)
1000     return "ldscripts/${EMULATION_NAME}.xbn";
1001   else if (!config.magic_demand_paged)
1002     return "ldscripts/${EMULATION_NAME}.xn";
1003   else
1004     return "ldscripts/${EMULATION_NAME}.x";
1005 }
1006 EOF
1007
1008 fi
1009
1010 fragment <<EOF
1011
1012 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1013 {
1014   gld${EMULATION_NAME}_before_parse,
1015   syslib_default,
1016   hll_default,
1017   after_parse_default,
1018   gld${EMULATION_NAME}_after_open,
1019   after_allocation_default,
1020   set_output_arch_default,
1021   ldemul_default_target,
1022   gld${EMULATION_NAME}_before_allocation,
1023   gld${EMULATION_NAME}_get_script,
1024   "${EMULATION_NAME}",
1025   "${OUTPUT_FORMAT}",
1026   finish_default,
1027   gld${EMULATION_NAME}_create_output_section_statements,
1028   NULL, /* open dynamic archive */
1029   NULL, /* place orphan */
1030   gld${EMULATION_NAME}_set_symbols,
1031   NULL, /* parse args */
1032   NULL, /* add_options */
1033   NULL, /* handle_option */
1034   NULL, /* unrecognized file */
1035   NULL, /* list options */
1036   NULL, /* recognized file */
1037   NULL, /* find_potential_libraries */
1038   NULL, /* new_vers_pattern */
1039   NULL  /* extra_map_file_text */
1040 };
1041 EOF