| blob | 4fbe108f760674bbfd7e7379103075c6aa37ec51 |
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! */
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 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 GLD, the Gnu Linker.
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.
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, MA 02110-1301, USA. */
33 #define TARGET_IS_${EMULATION_NAME}
35 #include "bfd.h"
36 #include "sysdep.h"
37 #include "bfdlink.h"
38 #include "libiberty.h"
39 #include "safe-ctype.h"
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"
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
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 *);
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 }
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. */
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;
106 env = (const char *) getenv ("LD_LIBRARY_PATH");
107 if (env != NULL)
108 {
109 char *l;
111 l = xstrdup (env);
112 while (1)
113 {
114 char *c;
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 }
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. */
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 }
148 /* Search the directory for a .so file for each library search. */
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;
158 if (! inp->search_dirs_flag
159 || ! inp->is_archive
160 || ! inp->dynamic)
161 return;
163 ASSERT (CONST_STRNEQ (inp->local_sym_name, "-l"));
165 for (search = search_head; search != NULL; search = search->next)
166 {
167 bfd_boolean found_static;
169 found = gld${EMULATION_NAME}_search_dir (search->name, inp->filename,
170 &found_static);
171 if (found != NULL || found_static)
172 break;
173 }
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 }
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;
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;
192 free (found);
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;
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;
211 inp->filename = alc;
212 inp->local_sym_name = alc;
214 inp->header.next = (lang_statement_union_type *) sa;
215 inp->next_real_file = (lang_statement_union_type *) sa;
216 }
217 }
219 /* Search a directory for a .so file. */
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;
238 *found_static = FALSE;
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);
252 len = dot - filename;
253 alc = (char *) xmalloc (len + 1);
254 strncpy (alc, filename, len);
255 alc[len] = '\0';
256 filename = alc;
258 dot = strchr (dot + 1, '.');
259 if (dot != NULL)
260 force_min = atoi (dot + 1);
261 }
263 found = NULL;
264 max_maj = max_min = 0;
266 dir = opendir (dirname);
267 if (dir == NULL)
268 return NULL;
269 dirnamelen = strlen (dirname);
271 while ((entry = readdir (dir)) != NULL)
272 {
273 const char *s;
274 int found_maj, found_min;
276 if (! CONST_STRNEQ (entry->d_name, "lib")
277 || strncmp (entry->d_name + 3, filename, len) != 0)
278 continue;
280 if (dot == NULL
281 && strcmp (entry->d_name + 3 + len, ".a") == 0)
282 {
283 *found_static = TRUE;
284 continue;
285 }
287 /* We accept libfoo.so without a version number, even though the
288 native linker does not. This is more convenient for packages
289 which just generate .so files for shared libraries, as on ELF
290 systems. */
291 if (! CONST_STRNEQ (entry->d_name + 3 + len, ".so"))
292 continue;
293 if (entry->d_name[6 + len] == '\0')
294 ;
295 else if (entry->d_name[6 + len] == '.'
296 && ISDIGIT (entry->d_name[7 + len]))
297 ;
298 else
299 continue;
301 for (s = entry->d_name + 6 + len; *s != '\0'; s++)
302 if (*s != '.' && ! ISDIGIT (*s))
303 break;
304 if (*s != '\0')
305 continue;
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);
314 if ((force_maj != -1 && force_maj != found_maj)
315 || (force_min != -1 && force_min != found_min))
316 continue;
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;
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 }
347 closedir (dir);
349 if (alc != NULL)
350 free (alc);
352 return found;
353 }
355 /* These variables are required to pass information back and forth
356 between after_open and check_needed. */
358 static struct bfd_link_needed_list *global_needed;
359 static bfd_boolean global_found;
361 /* This is called after all the input files have been opened. */
363 static void
364 gld${EMULATION_NAME}_after_open (void)
365 {
366 struct bfd_link_needed_list *needed, *l;
368 /* We only need to worry about this when doing a final link. */
369 if (link_info.relocatable || link_info.shared)
370 return;
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;
387 lname = l->name;
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;
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;
403 if (! CONST_STRNEQ (lname, "-l"))
404 {
405 bfd *abfd;
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 }
436 continue;
437 }
439 lname += 2;
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;
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 }
492 einfo ("%P: warning: %s, needed by %B, not found\n",
493 l->name, l->by);
494 }
495 }
497 /* Search for a needed file in a path. */
499 static bfd_boolean
500 gld${EMULATION_NAME}_search_needed (const char *path, const char *name)
501 {
502 const char *s;
504 if (path == NULL || *path == '\0')
505 return FALSE;
506 while (1)
507 {
508 const char *dir;
509 char *dircopy;
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 }
525 if (gld${EMULATION_NAME}_try_needed (dir, name))
526 return TRUE;
528 if (dircopy != NULL)
529 free (dircopy);
531 if (s == NULL)
532 break;
533 path = s + 1;
534 }
536 return FALSE;
537 }
539 /* This function is called for each possible directory for a needed
540 dynamic object. */
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;
550 file = gld${EMULATION_NAME}_search_dir (dir, name, &ignore);
551 if (file == NULL)
552 return FALSE;
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 }
571 /* We've found the needed dynamic object. */
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);
577 return TRUE;
578 }
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. */
584 static void
585 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
586 {
587 if (s->filename == NULL)
588 return;
589 if (! CONST_STRNEQ (global_needed->name, "-l"))
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;
600 lname = global_needed->name + 2;
602 sname = strrchr (s->filename, '/');
603 if (sname == NULL)
604 sname = s->filename;
605 else
606 ++sname;
608 if (! CONST_STRNEQ (sname, "lib"))
609 return;
610 sname += 3;
612 ldot = strchr (lname, '.');
613 if (ldot == NULL)
614 ldot = lname + strlen (lname);
616 sdot = strstr (sname, ".so.");
617 if (sdot == NULL)
618 return;
620 if (sdot - sname != ldot - lname
621 || strncmp (lname, sname, sdot - sname) != 0)
622 return;
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;
632 global_found = TRUE;
633 }
634 }
636 /* We need to use static variables to pass information around the call
637 to lang_for_each_statement. Ick. */
639 static const char *find_assign;
640 static bfd_boolean found_assign;
642 /* We need to use static variables to pass information around the call
643 to lang_for_each_input_file. Ick. */
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;
651 /* The size of one entry in the .need section, not including the file
652 name. */
654 #define NEED_ENTRY_SIZE (16)
656 /* This is called after the sections have been attached to output
657 sections, but before any sizes or addresses have been set. */
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;
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;
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 }
694 if (link_info.shared)
695 {
696 lang_output_section_statement_type *os;
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 }
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 }
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);
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");
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. */
738 need_entries = 0;
739 need_size = 0;
741 lang_for_each_input_file (gld${EMULATION_NAME}_count_need);
743 /* We should only have a .need section if we have at least one
744 dynamic object. */
745 ASSERT (need_entries != 0);
747 sneed->size = need_size;
748 sneed->contents = (bfd_byte *) xmalloc (need_size);
750 need_contents = sneed->contents;
751 need_pinfo = sneed->contents;
752 need_pnames = sneed->contents + need_entries * 16;
754 lang_for_each_input_file (gld${EMULATION_NAME}_set_need);
756 ASSERT ((bfd_size_type) (need_pnames - sneed->contents) == need_size);
757 }
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;
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;
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 }
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 }
814 before_allocation_default ();
815 }
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. */
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 }
832 /* Look through an expression for an assignment statement. */
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 }
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;
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;
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;
868 case etree_unary:
869 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
870 break;
872 default:
873 break;
874 }
875 }
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. */
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 }
901 /* Fill in the contents of the .need section. */
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;
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;
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 }
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);
947 need_pinfo += NEED_ENTRY_SIZE;
948 need_pnames += strlen ((char *) need_pnames) + 1;
949 }
950 }
952 static char *
953 gld${EMULATION_NAME}_get_script (int *isfile)
954 EOF
956 if test -n "$COMPILE_IN"
957 then
958 # Scripts compiled in.
960 # sed commands to quote an ld script as a C string.
961 sc="-f stringify.sed"
963 cat >>e${EMULATION_NAME}.c <<EOF
964 {
965 *isfile = 0;
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
981 else
982 # Scripts read from the filesystem.
984 cat >>e${EMULATION_NAME}.c <<EOF
985 {
986 *isfile = 1;
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
1001 fi
1003 cat >>e${EMULATION_NAME}.c <<EOF
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