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 cat >e${EMULATION_NAME}.c <<EOF
   9 /* This file is is generated by a shell script.  DO NOT EDIT! */
  10
  11 /* SunOS emulation code for ${EMULATION_NAME}
  12    Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
  13    2002, 2003, 2004, 2005 Free Software Foundation, Inc.
  14    Written by Steve Chamberlain <sac@cygnus.com>
  15    SunOS shared library support by Ian Lance Taylor <ian@cygnus.com>
  16
  17 This file is part of GLD, the Gnu Linker.
  18
  19 This program is free software; you can redistribute it and/or modify
  20 it under the terms of the GNU General Public License as published by
  21 the Free Software Foundation; either version 2 of the License, or
  22 (at your option) any later version.
  23
  24 This program is distributed in the hope that it will be useful,
  25 but WITHOUT ANY WARRANTY; without even the implied warranty of
  26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27 GNU General Public License for more details.
  28
  29 You should have received a copy of the GNU General Public License
  30 along with this program; if not, write to the Free Software
  31 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  32
  33 #define TARGET_IS_${EMULATION_NAME}
  34
  35 #include "bfd.h"
  36 #include "sysdep.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   config.dynamic_link = 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 cat >>e${EMULATION_NAME}.c <<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 cat >>e${EMULATION_NAME}.c <<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->search_dirs_flag
 159       || ! inp->is_archive
 160       || ! inp->dynamic)
 161     return;
 162
 163   ASSERT (strncmp (inp->local_sym_name, "-l", 2) == 0);
 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->search_dirs_flag = 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 (strncmp (entry->d_name, "lib", 3) != 0
 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 (strncmp (entry->d_name + 3 + len, ".so", 3) != 0)
 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   /* We only need to worry about this when doing a final link.  */
 369   if (link_info.relocatable || link_info.shared)
 370     return;
 371
 372   /* Get the list of files which appear in ld_need entries in dynamic
 373      objects included in the link.  For each such file, we want to
 374      track down the corresponding library, and include the symbol
 375      table in the link.  This is what the runtime dynamic linker will
 376      do.  Tracking the files down here permits one dynamic object to
 377      include another without requiring special action by the person
 378      doing the link.  Note that the needed list can actually grow
 379      while we are stepping through this loop.  */
 380   needed = bfd_sunos_get_needed_list (output_bfd, &link_info);
 381   for (l = needed; l != NULL; l = l->next)
 382     {
 383       struct bfd_link_needed_list *ll;
 384       const char *lname;
 385       search_dirs_type *search;
 386
 387       lname = l->name;
 388
 389       /* If we've already seen this file, skip it.  */
 390       for (ll = needed; ll != l; ll = ll->next)
 391         if (strcmp (ll->name, lname) == 0)
 392           break;
 393       if (ll != l)
 394         continue;
 395
 396       /* See if this file was included in the link explicitly.  */
 397       global_needed = l;
 398       global_found = FALSE;
 399       lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
 400       if (global_found)
 401         continue;
 402
 403       if (strncmp (lname, "-l", 2) != 0)
 404         {
 405           bfd *abfd;
 406
 407           abfd = bfd_openr (lname, bfd_get_target (output_bfd));
 408           if (abfd != NULL)
 409             {
 410               if (! bfd_check_format (abfd, bfd_object))
 411                 {
 412                   (void) bfd_close (abfd);
 413                   abfd = NULL;
 414                 }
 415             }
 416           if (abfd != NULL)
 417             {
 418               if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 419                 {
 420                   (void) bfd_close (abfd);
 421                   abfd = NULL;
 422                 }
 423             }
 424           if (abfd != NULL)
 425             {
 426               /* We've found the needed dynamic object.  */
 427               if (! bfd_link_add_symbols (abfd, &link_info))
 428                 einfo ("%F%B: could not read symbols: %E\n", abfd);
 429             }
 430           else
 431             {
 432               einfo ("%P: warning: %s, needed by %B, not found\n",
 433                      lname, l->by);
 434             }
 435
 436           continue;
 437         }
 438
 439       lname += 2;
 440
 441       /* We want to search for the file in the same way that the
 442          dynamic linker will search.  That means that we want to use
 443          rpath_link, rpath or -L, then the environment variable
 444          LD_LIBRARY_PATH (native only), then (if rpath was used) the
 445          linker script LIB_SEARCH_DIRS.  */
 446       if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
 447                                               lname))
 448         continue;
 449       if (command_line.rpath != NULL)
 450         {
 451           if (gld${EMULATION_NAME}_search_needed (command_line.rpath, lname))
 452             continue;
 453         }
 454       else
 455         {
 456           for (search = search_head; search != NULL; search = search->next)
 457             if (gld${EMULATION_NAME}_try_needed (search->name, lname))
 458               break;
 459           if (search != NULL)
 460             continue;
 461         }
 462 EOF
 463 if [ "x${host}" = "x${target}" ] ; then
 464   case " ${EMULATION_LIBPATH} " in
 465   *" ${EMULATION_NAME} "*)
 466 cat >>e${EMULATION_NAME}.c <<EOF
 467       {
 468         const char *lib_path;
 469
 470         lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
 471         if (gld${EMULATION_NAME}_search_needed (lib_path, lname))
 472           continue;
 473       }
 474 EOF
 475   ;;
 476   esac
 477 fi
 478 cat >>e${EMULATION_NAME}.c <<EOF
 479       if (command_line.rpath != NULL)
 480         {
 481           for (search = search_head; search != NULL; search = search->next)
 482             {
 483               if (search->cmdline)
 484                 continue;
 485               if (gld${EMULATION_NAME}_try_needed (search->name, lname))
 486                 break;
 487             }
 488           if (search != NULL)
 489             continue;
 490         }
 491
 492       einfo ("%P: warning: %s, needed by %B, not found\n",
 493              l->name, l->by);
 494     }
 495 }
 496
 497 /* Search for a needed file in a path.  */
 498
 499 static bfd_boolean
 500 gld${EMULATION_NAME}_search_needed (const char *path, const char *name)
 501 {
 502   const char *s;
 503
 504   if (path == NULL || *path == '\0')
 505     return FALSE;
 506   while (1)
 507     {
 508       const char *dir;
 509       char *dircopy;
 510
 511       s = strchr (path, ':');
 512       if (s == NULL)
 513         {
 514           dircopy = NULL;
 515           dir = path;
 516         }
 517       else
 518         {
 519           dircopy = (char *) xmalloc (s - path + 1);
 520           memcpy (dircopy, path, s - path);
 521           dircopy[s - path] = '\0';
 522           dir = dircopy;
 523         }
 524
 525       if (gld${EMULATION_NAME}_try_needed (dir, name))
 526         return TRUE;
 527
 528       if (dircopy != NULL)
 529         free (dircopy);
 530
 531       if (s == NULL)
 532         break;
 533       path = s + 1;
 534     }
 535
 536   return FALSE;
 537 }
 538
 539 /* This function is called for each possible directory for a needed
 540    dynamic object.  */
 541
 542 static bfd_boolean
 543 gld${EMULATION_NAME}_try_needed (const char *dir, const char *name)
 544 {
 545   char *file;
 546   char *alc;
 547   bfd_boolean ignore;
 548   bfd *abfd;
 549
 550   file = gld${EMULATION_NAME}_search_dir (dir, name, &ignore);
 551   if (file == NULL)
 552     return FALSE;
 553
 554   alc = (char *) xmalloc (strlen (dir) + strlen (file) + 2);
 555   sprintf (alc, "%s/%s", dir, file);
 556   free (file);
 557   abfd = bfd_openr (alc, bfd_get_target (output_bfd));
 558   if (abfd == NULL)
 559     return FALSE;
 560   if (! bfd_check_format (abfd, bfd_object))
 561     {
 562       (void) bfd_close (abfd);
 563       return FALSE;
 564     }
 565   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 566     {
 567       (void) bfd_close (abfd);
 568       return FALSE;
 569     }
 570
 571   /* We've found the needed dynamic object.  */
 572
 573   /* Add this file into the symbol table.  */
 574   if (! bfd_link_add_symbols (abfd, &link_info))
 575     einfo ("%F%B: could not read symbols: %E\n", abfd);
 576
 577   return TRUE;
 578 }
 579
 580 /* See if we have already included a needed object in the link.  This
 581    does not have to be precise, as it does no harm to include a
 582    dynamic object more than once.  */
 583
 584 static void
 585 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
 586 {
 587   if (s->filename == NULL)
 588     return;
 589   if (strncmp (global_needed->name, "-l", 2) != 0)
 590     {
 591       if (strcmp (s->filename, global_needed->name) == 0)
 592         global_found = TRUE;
 593     }
 594   else
 595     {
 596       const char *sname, *lname;
 597       const char *sdot, *ldot;
 598       int lmaj, lmin, smaj, smin;
 599
 600       lname = global_needed->name + 2;
 601
 602       sname = strrchr (s->filename, '/');
 603       if (sname == NULL)
 604         sname = s->filename;
 605       else
 606         ++sname;
 607
 608       if (strncmp (sname, "lib", 3) != 0)
 609         return;
 610       sname += 3;
 611
 612       ldot = strchr (lname, '.');
 613       if (ldot == NULL)
 614         ldot = lname + strlen (lname);
 615
 616       sdot = strstr (sname, ".so.");
 617       if (sdot == NULL)
 618         return;
 619
 620       if (sdot - sname != ldot - lname
 621           || strncmp (lname, sname, sdot - sname) != 0)
 622         return;
 623
 624       lmaj = lmin = -1;
 625       sscanf (ldot, ".%d.%d", &lmaj, &lmin);
 626       smaj = smin = -1;
 627       sscanf (sdot, ".so.%d.%d", &smaj, &smin);
 628       if ((smaj != lmaj && smaj != -1 && lmaj != -1)
 629           || (smin != lmin && smin != -1 && lmin != -1))
 630         return;
 631
 632       global_found = TRUE;
 633     }
 634 }
 635
 636 /* We need to use static variables to pass information around the call
 637    to lang_for_each_statement.  Ick.  */
 638
 639 static const char *find_assign;
 640 static bfd_boolean found_assign;
 641
 642 /* We need to use static variables to pass information around the call
 643    to lang_for_each_input_file.  Ick.  */
 644
 645 static bfd_size_type need_size;
 646 static bfd_size_type need_entries;
 647 static bfd_byte *need_contents;
 648 static bfd_byte *need_pinfo;
 649 static bfd_byte *need_pnames;
 650
 651 /* The size of one entry in the .need section, not including the file
 652    name.  */
 653
 654 #define NEED_ENTRY_SIZE (16)
 655
 656 /* This is called after the sections have been attached to output
 657    sections, but before any sizes or addresses have been set.  */
 658
 659 static void
 660 gld${EMULATION_NAME}_before_allocation (void)
 661 {
 662   struct bfd_link_hash_entry *hdyn = NULL;
 663   asection *sneed;
 664   asection *srules;
 665   asection *sdyn;
 666
 667   /* The SunOS native linker creates a shared library whenever there
 668      are any undefined symbols in a link, unless -e is used.  This is
 669      pretty weird, but we are compatible.  */
 670   if (! link_info.shared && ! link_info.relocatable && ! entry_from_cmdline)
 671     {
 672       struct bfd_link_hash_entry *h;
 673
 674       for (h = link_info.hash->undefs; h != NULL; h = h->u.undef.next)
 675         {
 676           if (h->type == bfd_link_hash_undefined
 677               && h->u.undef.abfd != NULL
 678               && (h->u.undef.abfd->flags & DYNAMIC) == 0
 679               && strcmp (h->root.string, "__DYNAMIC") != 0
 680               && strcmp (h->root.string, "__GLOBAL_OFFSET_TABLE_") != 0)
 681             {
 682               find_assign = h->root.string;
 683               found_assign = FALSE;
 684               lang_for_each_statement (gld${EMULATION_NAME}_find_assignment);
 685               if (! found_assign)
 686                 {
 687                   link_info.shared = TRUE;
 688                   break;
 689                 }
 690             }
 691         }
 692     }
 693
 694   if (link_info.shared)
 695     {
 696       lang_output_section_statement_type *os;
 697
 698       /* Set the .text section to start at 0x20, not 0x2020.  FIXME:
 699          This is too magical.  */
 700       os = lang_output_section_statement_lookup (".text");
 701       if (os->addr_tree == NULL)
 702         os->addr_tree = exp_intop (0x20);
 703     }
 704
 705   /* We need to create a __DYNAMIC symbol.  We don't do this in the
 706      linker script because we want to set the value to the start of
 707      the dynamic section if there is one, or to zero if there isn't
 708      one.  We need to create the symbol before calling
 709      size_dynamic_sections, although we can't set the value until
 710      afterward.  */
 711   if (! link_info.relocatable)
 712     {
 713       hdyn = bfd_link_hash_lookup (link_info.hash, "__DYNAMIC", TRUE, FALSE,
 714                                    FALSE);
 715       if (hdyn == NULL)
 716         einfo ("%P%F: bfd_link_hash_lookup: %E\n");
 717       if (! bfd_sunos_record_link_assignment (output_bfd, &link_info,
 718                                               "__DYNAMIC"))
 719         einfo ("%P%F: failed to record assignment to __DYNAMIC: %E\n");
 720     }
 721
 722   /* If we are going to make any variable assignments, we need to let
 723      the backend linker know about them in case the variables are
 724      referred to by dynamic objects.  */
 725   lang_for_each_statement (gld${EMULATION_NAME}_find_assignment);
 726
 727   /* Let the backend linker work out the sizes of any sections
 728      required by dynamic linking.  */
 729   if (! bfd_sunos_size_dynamic_sections (output_bfd, &link_info, &sdyn,
 730                                          &sneed, &srules))
 731     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
 732
 733   if (sneed != NULL)
 734     {
 735       /* Set up the .need section.  See the description of the ld_need
 736          field in include/aout/sun4.h.  */
 737
 738       need_entries = 0;
 739       need_size = 0;
 740
 741       lang_for_each_input_file (gld${EMULATION_NAME}_count_need);
 742
 743       /* We should only have a .need section if we have at least one
 744          dynamic object.  */
 745       ASSERT (need_entries != 0);
 746
 747       sneed->size = need_size;
 748       sneed->contents = (bfd_byte *) xmalloc (need_size);
 749
 750       need_contents = sneed->contents;
 751       need_pinfo = sneed->contents;
 752       need_pnames = sneed->contents + need_entries * 16;
 753
 754       lang_for_each_input_file (gld${EMULATION_NAME}_set_need);
 755
 756       ASSERT ((bfd_size_type) (need_pnames - sneed->contents) == need_size);
 757     }
 758
 759   if (srules != NULL)
 760     {
 761       /* Set up the .rules section.  This is just a PATH like string
 762          of the -L arguments given on the command line.  We permit the
 763          user to specify the directories using the -rpath command line
 764          option.  */
 765       if (command_line.rpath)
 766         {
 767           srules->size = strlen (command_line.rpath);
 768           srules->contents = (bfd_byte *) command_line.rpath;
 769         }
 770       else
 771         {
 772           unsigned int size;
 773           search_dirs_type *search;
 774
 775           size = 0;
 776           for (search = search_head; search != NULL; search = search->next)
 777             if (search->cmdline)
 778               size += strlen (search->name) + 1;
 779           srules->size = size;
 780           if (size > 0)
 781             {
 782               char *p;
 783
 784               srules->contents = (bfd_byte *) xmalloc (size);
 785               p = (char *) srules->contents;
 786               *p = '\0';
 787               for (search = search_head; search != NULL; search = search->next)
 788                 {
 789                   if (search->cmdline)
 790                     {
 791                       if (p != (char *) srules->contents)
 792                         *p++ = ':';
 793                       strcpy (p, search->name);
 794                       p += strlen (p);
 795                     }
 796                 }
 797             }
 798         }
 799     }
 800
 801   /* We must assign a value to __DYNAMIC.  It should be zero if we are
 802      not doing a dynamic link, or the start of the .dynamic section if
 803      we are doing one.  */
 804   if (! link_info.relocatable)
 805     {
 806       hdyn->type = bfd_link_hash_defined;
 807       hdyn->u.def.value = 0;
 808       if (sdyn != NULL)
 809         hdyn->u.def.section = sdyn;
 810       else
 811         hdyn->u.def.section = bfd_abs_section_ptr;
 812     }
 813
 814   before_allocation_default ();
 815 }
 816
 817 /* This is called by the before_allocation routine via
 818    lang_for_each_statement.  It does one of two things: if the
 819    variable find_assign is set, it sets found_assign if it finds an
 820    assignment to that variable; otherwise it tells the backend linker
 821    about all assignment statements, in case they are assignments to
 822    symbols which are referred to by dynamic objects.  */
 823
 824 static void
 825 gld${EMULATION_NAME}_find_assignment (lang_statement_union_type *s)
 826 {
 827   if (s->header.type == lang_assignment_statement_enum
 828       && (find_assign == NULL || ! found_assign))
 829     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
 830 }
 831
 832 /* Look through an expression for an assignment statement.  */
 833
 834 static void
 835 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
 836 {
 837   switch (exp->type.node_class)
 838     {
 839     case etree_assign:
 840       if (find_assign != NULL)
 841         {
 842           if (strcmp (find_assign, exp->assign.dst) == 0)
 843             found_assign = TRUE;
 844           return;
 845         }
 846
 847       if (strcmp (exp->assign.dst, ".") != 0)
 848         {
 849           if (! bfd_sunos_record_link_assignment (output_bfd, &link_info,
 850                                                   exp->assign.dst))
 851             einfo ("%P%F: failed to record assignment to %s: %E\n",
 852                    exp->assign.dst);
 853         }
 854       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
 855       break;
 856
 857     case etree_binary:
 858       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
 859       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
 860       break;
 861
 862     case etree_trinary:
 863       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
 864       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 865       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
 866       break;
 867
 868     case etree_unary:
 869       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
 870       break;
 871
 872     default:
 873       break;
 874     }
 875 }
 876
 877 /* Work out the size of the .need section, and the number of entries.
 878    The backend will set the ld_need field of the dynamic linking
 879    information to point to the .need section.  See include/aout/sun4.h
 880    for more information.  */
 881
 882 static void
 883 gld${EMULATION_NAME}_count_need (lang_input_statement_type *inp)
 884 {
 885   if (inp->the_bfd != NULL
 886       && (inp->the_bfd->flags & DYNAMIC) != 0)
 887     {
 888       ++need_entries;
 889       need_size += NEED_ENTRY_SIZE;
 890       if (! inp->is_archive)
 891         need_size += strlen (inp->filename) + 1;
 892       else
 893         {
 894           ASSERT (inp->local_sym_name[0] == '-'
 895                   && inp->local_sym_name[1] == 'l');
 896           need_size += strlen (inp->local_sym_name + 2) + 1;
 897         }
 898     }
 899 }
 900
 901 /* Fill in the contents of the .need section.  */
 902
 903 static void
 904 gld${EMULATION_NAME}_set_need (lang_input_statement_type *inp)
 905 {
 906   if (inp->the_bfd != NULL
 907       && (inp->the_bfd->flags & DYNAMIC) != 0)
 908     {
 909       bfd_size_type c;
 910
 911       /* To really fill in the .need section contents, we need to know
 912          the final file position of the section, but we don't.
 913          Instead, we use offsets, and rely on the BFD backend to
 914          finish the section up correctly.  FIXME: Talk about lack of
 915          referential locality.  */
 916       bfd_put_32 (output_bfd, need_pnames - need_contents, need_pinfo);
 917       if (! inp->is_archive)
 918         {
 919           bfd_put_32 (output_bfd, (bfd_vma) 0, need_pinfo + 4);
 920           bfd_put_16 (output_bfd, (bfd_vma) 0, need_pinfo + 8);
 921           bfd_put_16 (output_bfd, (bfd_vma) 0, need_pinfo + 10);
 922           strcpy ((char *) need_pnames, inp->filename);
 923         }
 924       else
 925         {
 926           char *verstr;
 927           int maj, min;
 928
 929           bfd_put_32 (output_bfd, (bfd_vma) 0x80000000, need_pinfo + 4);
 930           maj = 0;
 931           min = 0;
 932           verstr = strstr (inp->filename, ".so.");
 933           if (verstr != NULL)
 934             sscanf (verstr, ".so.%d.%d", &maj, &min);
 935           bfd_put_16 (output_bfd, (bfd_vma) maj, need_pinfo + 8);
 936           bfd_put_16 (output_bfd, (bfd_vma) min, need_pinfo + 10);
 937           strcpy ((char *) need_pnames, inp->local_sym_name + 2);
 938         }
 939
 940       c = (need_pinfo - need_contents) / NEED_ENTRY_SIZE;
 941       if (c + 1 >= need_entries)
 942         bfd_put_32 (output_bfd, (bfd_vma) 0, need_pinfo + 12);
 943       else
 944         bfd_put_32 (output_bfd, (bfd_vma) (c + 1) * NEED_ENTRY_SIZE,
 945                     need_pinfo + 12);
 946
 947       need_pinfo += NEED_ENTRY_SIZE;
 948       need_pnames += strlen ((char *) need_pnames) + 1;
 949     }
 950 }
 951
 952 static char *
 953 gld${EMULATION_NAME}_get_script (int *isfile)
 954 EOF
 955
 956 if test -n "$COMPILE_IN"
 957 then
 958 # Scripts compiled in.
 959
 960 # sed commands to quote an ld script as a C string.
 961 sc="-f stringify.sed"
 962
 963 cat >>e${EMULATION_NAME}.c <<EOF
 964 {
 965   *isfile = 0;
 966
 967   if (link_info.relocatable && config.build_constructors)
 968     return
 969 EOF
 970 sed $sc ldscripts/${EMULATION_NAME}.xu                     >> e${EMULATION_NAME}.c
 971 echo '  ; else if (link_info.relocatable) return'         >> e${EMULATION_NAME}.c
 972 sed $sc ldscripts/${EMULATION_NAME}.xr                     >> e${EMULATION_NAME}.c
 973 echo '  ; else if (!config.text_read_only) return'         >> e${EMULATION_NAME}.c
 974 sed $sc ldscripts/${EMULATION_NAME}.xbn                    >> e${EMULATION_NAME}.c
 975 echo '  ; else if (!config.magic_demand_paged) return'     >> e${EMULATION_NAME}.c
 976 sed $sc ldscripts/${EMULATION_NAME}.xn                     >> e${EMULATION_NAME}.c
 977 echo '  ; else return'                                     >> e${EMULATION_NAME}.c
 978 sed $sc ldscripts/${EMULATION_NAME}.x                      >> e${EMULATION_NAME}.c
 979 echo '; }'                                                 >> e${EMULATION_NAME}.c
 980
 981 else
 982 # Scripts read from the filesystem.
 983
 984 cat >>e${EMULATION_NAME}.c <<EOF
 985 {
 986   *isfile = 1;
 987
 988   if (link_info.relocatable && config.build_constructors)
 989     return "ldscripts/${EMULATION_NAME}.xu";
 990   else if (link_info.relocatable)
 991     return "ldscripts/${EMULATION_NAME}.xr";
 992   else if (!config.text_read_only)
 993     return "ldscripts/${EMULATION_NAME}.xbn";
 994   else if (!config.magic_demand_paged)
 995     return "ldscripts/${EMULATION_NAME}.xn";
 996   else
 997     return "ldscripts/${EMULATION_NAME}.x";
 998 }
 999 EOF
1000
1001 fi
1002
1003 cat >>e${EMULATION_NAME}.c <<EOF
1004
1005 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1006 {
1007   gld${EMULATION_NAME}_before_parse,
1008   syslib_default,
1009   hll_default,
1010   after_parse_default,
1011   gld${EMULATION_NAME}_after_open,
1012   after_allocation_default,
1013   set_output_arch_default,
1014   ldemul_default_target,
1015   gld${EMULATION_NAME}_before_allocation,
1016   gld${EMULATION_NAME}_get_script,
1017   "${EMULATION_NAME}",
1018   "${OUTPUT_FORMAT}",
1019   finish_default,
1020   gld${EMULATION_NAME}_create_output_section_statements,
1021   NULL, /* open dynamic archive */
1022   NULL, /* place orphan */
1023   gld${EMULATION_NAME}_set_symbols,
1024   NULL, /* parse args */
1025   NULL, /* add_options */
1026   NULL, /* handle_option */
1027   NULL, /* unrecognized file */
1028   NULL, /* list options */
1029   NULL, /* recognized file */
1030   NULL, /* find_potential_libraries */
1031   NULL  /* new_vers_pattern */
1032 };
1033 EOF