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