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