1 /* BFD backend for SunOS binaries.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 #define TARGETNAME "a.out-sunos-big"
22 #define MY(OP) CAT(sunos_big_,OP)
28 /* Static routines defined in this file. */
30 static boolean sunos_read_dynamic_info PARAMS ((bfd *));
31 static long sunos_get_dynamic_symtab_upper_bound PARAMS ((bfd *));
32 static boolean sunos_slurp_dynamic_symtab PARAMS ((bfd *));
33 static long sunos_canonicalize_dynamic_symtab PARAMS ((bfd *, asymbol **));
34 static long sunos_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
35 static long sunos_canonicalize_dynamic_reloc
36 PARAMS ((bfd *, arelent **, asymbol **));
37 static struct bfd_hash_entry *sunos_link_hash_newfunc
38 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
39 static struct bfd_link_hash_table *sunos_link_hash_table_create
41 static boolean sunos_create_dynamic_sections
42 PARAMS ((bfd *, struct bfd_link_info *, boolean));
43 static boolean sunos_add_dynamic_symbols
44 PARAMS ((bfd *, struct bfd_link_info *, struct external_nlist **,
45 bfd_size_type *, char **));
46 static boolean sunos_add_one_symbol
47 PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
48 bfd_vma, const char *, boolean, boolean,
49 struct bfd_link_hash_entry **));
50 static boolean sunos_scan_relocs
51 PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_size_type));
52 static boolean sunos_scan_std_relocs
53 PARAMS ((struct bfd_link_info *, bfd *, asection *,
54 const struct reloc_std_external *, bfd_size_type));
55 static boolean sunos_scan_ext_relocs
56 PARAMS ((struct bfd_link_info *, bfd *, asection *,
57 const struct reloc_ext_external *, bfd_size_type));
58 static boolean sunos_link_dynamic_object
59 PARAMS ((struct bfd_link_info *, bfd *));
60 static boolean sunos_write_dynamic_symbol
61 PARAMS ((bfd *, struct bfd_link_info *, struct aout_link_hash_entry *));
62 static boolean sunos_check_dynamic_reloc
63 PARAMS ((struct bfd_link_info *, bfd *, asection *,
64 struct aout_link_hash_entry *, PTR, bfd_byte *, boolean *,
66 static boolean sunos_finish_dynamic_link
67 PARAMS ((bfd *, struct bfd_link_info *));
69 #define MY_get_dynamic_symtab_upper_bound sunos_get_dynamic_symtab_upper_bound
70 #define MY_canonicalize_dynamic_symtab sunos_canonicalize_dynamic_symtab
71 #define MY_get_dynamic_reloc_upper_bound sunos_get_dynamic_reloc_upper_bound
72 #define MY_canonicalize_dynamic_reloc sunos_canonicalize_dynamic_reloc
73 #define MY_bfd_link_hash_table_create sunos_link_hash_table_create
74 #define MY_add_dynamic_symbols sunos_add_dynamic_symbols
75 #define MY_add_one_symbol sunos_add_one_symbol
76 #define MY_link_dynamic_object sunos_link_dynamic_object
77 #define MY_write_dynamic_symbol sunos_write_dynamic_symbol
78 #define MY_check_dynamic_reloc sunos_check_dynamic_reloc
79 #define MY_finish_dynamic_link sunos_finish_dynamic_link
81 /* Include the usual a.out support. */
84 /* SunOS shared library support. We store a pointer to this structure
85 in obj_aout_dynamic_info (abfd). */
87 struct sunos_dynamic_info
89 /* Whether we found any dynamic information. */
91 /* Dynamic information. */
92 struct internal_sun4_dynamic_link dyninfo;
93 /* Number of dynamic symbols. */
94 unsigned long dynsym_count;
95 /* Read in nlists for dynamic symbols. */
96 struct external_nlist *dynsym;
97 /* asymbol structures for dynamic symbols. */
98 aout_symbol_type *canonical_dynsym;
99 /* Read in dynamic string table. */
101 /* Number of dynamic relocs. */
102 unsigned long dynrel_count;
103 /* Read in dynamic relocs. This may be reloc_std_external or
104 reloc_ext_external. */
106 /* arelent structures for dynamic relocs. */
107 arelent *canonical_dynrel;
110 /* The hash table of dynamic symbols is composed of two word entries.
111 See include/aout/sun4.h for details. */
113 #define HASH_ENTRY_SIZE (2 * BYTES_IN_WORD)
115 /* Read in the basic dynamic information. This locates the __DYNAMIC
116 structure and uses it to find the dynamic_link structure. It
117 creates and saves a sunos_dynamic_info structure. If it can't find
118 __DYNAMIC, it sets the valid field of the sunos_dynamic_info
119 structure to false to avoid doing this work again. */
122 sunos_read_dynamic_info (abfd)
125 struct sunos_dynamic_info *info;
128 struct external_sun4_dynamic dyninfo;
129 unsigned long dynver;
130 struct external_sun4_dynamic_link linkinfo;
132 if (obj_aout_dynamic_info (abfd) != (PTR) NULL)
135 if ((abfd->flags & DYNAMIC) == 0)
137 bfd_set_error (bfd_error_invalid_operation);
141 info = ((struct sunos_dynamic_info *)
142 bfd_zalloc (abfd, sizeof (struct sunos_dynamic_info)));
148 info->canonical_dynsym = NULL;
150 info->canonical_dynrel = NULL;
151 obj_aout_dynamic_info (abfd) = (PTR) info;
153 /* This code used to look for the __DYNAMIC symbol to locate the dynamic
155 However this inhibits recovering the dynamic symbols from a
156 stripped object file, so blindly assume that the dynamic linking
157 information is located at the start of the data section.
158 We could verify this assumption later by looking through the dynamic
159 symbols for the __DYNAMIC symbol. */
160 if ((abfd->flags & DYNAMIC) == 0)
162 if (! bfd_get_section_contents (abfd, obj_datasec (abfd), (PTR) &dyninfo,
163 (file_ptr) 0, sizeof dyninfo))
166 dynver = GET_WORD (abfd, dyninfo.ld_version);
167 if (dynver != 2 && dynver != 3)
170 dynoff = GET_WORD (abfd, dyninfo.ld);
172 /* dynoff is a virtual address. It is probably always in the .data
173 section, but this code should work even if it moves. */
174 if (dynoff < bfd_get_section_vma (abfd, obj_datasec (abfd)))
175 dynsec = obj_textsec (abfd);
177 dynsec = obj_datasec (abfd);
178 dynoff -= bfd_get_section_vma (abfd, dynsec);
179 if (dynoff > bfd_section_size (abfd, dynsec))
182 /* This executable appears to be dynamically linked in a way that we
184 if (! bfd_get_section_contents (abfd, dynsec, (PTR) &linkinfo, dynoff,
185 (bfd_size_type) sizeof linkinfo))
188 /* Swap in the dynamic link information. */
189 info->dyninfo.ld_loaded = GET_WORD (abfd, linkinfo.ld_loaded);
190 info->dyninfo.ld_need = GET_WORD (abfd, linkinfo.ld_need);
191 info->dyninfo.ld_rules = GET_WORD (abfd, linkinfo.ld_rules);
192 info->dyninfo.ld_got = GET_WORD (abfd, linkinfo.ld_got);
193 info->dyninfo.ld_plt = GET_WORD (abfd, linkinfo.ld_plt);
194 info->dyninfo.ld_rel = GET_WORD (abfd, linkinfo.ld_rel);
195 info->dyninfo.ld_hash = GET_WORD (abfd, linkinfo.ld_hash);
196 info->dyninfo.ld_stab = GET_WORD (abfd, linkinfo.ld_stab);
197 info->dyninfo.ld_stab_hash = GET_WORD (abfd, linkinfo.ld_stab_hash);
198 info->dyninfo.ld_buckets = GET_WORD (abfd, linkinfo.ld_buckets);
199 info->dyninfo.ld_symbols = GET_WORD (abfd, linkinfo.ld_symbols);
200 info->dyninfo.ld_symb_size = GET_WORD (abfd, linkinfo.ld_symb_size);
201 info->dyninfo.ld_text = GET_WORD (abfd, linkinfo.ld_text);
202 info->dyninfo.ld_plt_sz = GET_WORD (abfd, linkinfo.ld_plt_sz);
204 /* Reportedly the addresses need to be offset by the size of the
205 exec header in an NMAGIC file. */
206 if (adata (abfd).magic == n_magic)
208 unsigned long exec_bytes_size = adata (abfd).exec_bytes_size;
210 info->dyninfo.ld_need += exec_bytes_size;
211 info->dyninfo.ld_rules += exec_bytes_size;
212 info->dyninfo.ld_rel += exec_bytes_size;
213 info->dyninfo.ld_hash += exec_bytes_size;
214 info->dyninfo.ld_stab += exec_bytes_size;
215 info->dyninfo.ld_symbols += exec_bytes_size;
218 /* The only way to get the size of the symbol information appears to
219 be to determine the distance between it and the string table. */
220 info->dynsym_count = ((info->dyninfo.ld_symbols - info->dyninfo.ld_stab)
221 / EXTERNAL_NLIST_SIZE);
222 BFD_ASSERT (info->dynsym_count * EXTERNAL_NLIST_SIZE
223 == (unsigned long) (info->dyninfo.ld_symbols
224 - info->dyninfo.ld_stab));
226 /* Similarly, the relocs end at the hash table. */
227 info->dynrel_count = ((info->dyninfo.ld_hash - info->dyninfo.ld_rel)
228 / obj_reloc_entry_size (abfd));
229 BFD_ASSERT (info->dynrel_count * obj_reloc_entry_size (abfd)
230 == (unsigned long) (info->dyninfo.ld_hash
231 - info->dyninfo.ld_rel));
238 /* Return the amount of memory required for the dynamic symbols. */
241 sunos_get_dynamic_symtab_upper_bound (abfd)
244 struct sunos_dynamic_info *info;
246 if (! sunos_read_dynamic_info (abfd))
249 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
252 bfd_set_error (bfd_error_no_symbols);
256 return (info->dynsym_count + 1) * sizeof (asymbol *);
259 /* Read the external dynamic symbols. */
262 sunos_slurp_dynamic_symtab (abfd)
265 struct sunos_dynamic_info *info;
267 /* Get the general dynamic information. */
268 if (obj_aout_dynamic_info (abfd) == NULL)
270 if (! sunos_read_dynamic_info (abfd))
274 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
277 bfd_set_error (bfd_error_no_symbols);
281 /* Get the dynamic nlist structures. */
282 if (info->dynsym == (struct external_nlist *) NULL)
284 info->dynsym = ((struct external_nlist *)
287 * EXTERNAL_NLIST_SIZE)));
288 if (info->dynsym == NULL && info->dynsym_count != 0)
290 if (bfd_seek (abfd, info->dyninfo.ld_stab, SEEK_SET) != 0
291 || (bfd_read ((PTR) info->dynsym, info->dynsym_count,
292 EXTERNAL_NLIST_SIZE, abfd)
293 != info->dynsym_count * EXTERNAL_NLIST_SIZE))
295 if (info->dynsym != NULL)
297 bfd_release (abfd, info->dynsym);
304 /* Get the dynamic strings. */
305 if (info->dynstr == (char *) NULL)
307 info->dynstr = (char *) bfd_alloc (abfd, info->dyninfo.ld_symb_size);
308 if (info->dynstr == NULL && info->dyninfo.ld_symb_size != 0)
310 if (bfd_seek (abfd, info->dyninfo.ld_symbols, SEEK_SET) != 0
311 || (bfd_read ((PTR) info->dynstr, 1, info->dyninfo.ld_symb_size,
313 != info->dyninfo.ld_symb_size))
315 if (info->dynstr != NULL)
317 bfd_release (abfd, info->dynstr);
327 /* Read in the dynamic symbols. */
330 sunos_canonicalize_dynamic_symtab (abfd, storage)
334 struct sunos_dynamic_info *info;
337 if (! sunos_slurp_dynamic_symtab (abfd))
340 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
342 #ifdef CHECK_DYNAMIC_HASH
343 /* Check my understanding of the dynamic hash table by making sure
344 that each symbol can be located in the hash table. */
346 bfd_size_type table_size;
350 if (info->dyninfo.ld_buckets > info->dynsym_count)
352 table_size = info->dyninfo.ld_stab - info->dyninfo.ld_hash;
353 table = (bfd_byte *) bfd_malloc (table_size);
354 if (table == NULL && table_size != 0)
356 if (bfd_seek (abfd, info->dyninfo.ld_hash, SEEK_SET) != 0
357 || bfd_read ((PTR) table, 1, table_size, abfd) != table_size)
359 for (i = 0; i < info->dynsym_count; i++)
364 name = ((unsigned char *) info->dynstr
365 + GET_WORD (abfd, info->dynsym[i].e_strx));
367 while (*name != '\0')
368 hash = (hash << 1) + *name++;
370 hash %= info->dyninfo.ld_buckets;
371 while (GET_WORD (abfd, table + hash * HASH_ENTRY_SIZE) != i)
373 hash = GET_WORD (abfd,
374 table + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD);
375 if (hash == 0 || hash >= table_size / HASH_ENTRY_SIZE)
381 #endif /* CHECK_DYNAMIC_HASH */
383 /* Get the asymbol structures corresponding to the dynamic nlist
385 if (info->canonical_dynsym == (aout_symbol_type *) NULL)
387 info->canonical_dynsym = ((aout_symbol_type *)
390 * sizeof (aout_symbol_type))));
391 if (info->canonical_dynsym == NULL && info->dynsym_count != 0)
394 if (! aout_32_translate_symbol_table (abfd, info->canonical_dynsym,
395 info->dynsym, info->dynsym_count,
397 info->dyninfo.ld_symb_size,
400 if (info->canonical_dynsym != NULL)
402 bfd_release (abfd, info->canonical_dynsym);
403 info->canonical_dynsym = NULL;
409 /* Return pointers to the dynamic asymbol structures. */
410 for (i = 0; i < info->dynsym_count; i++)
411 *storage++ = (asymbol *) (info->canonical_dynsym + i);
414 return info->dynsym_count;
417 /* Return the amount of memory required for the dynamic relocs. */
420 sunos_get_dynamic_reloc_upper_bound (abfd)
423 struct sunos_dynamic_info *info;
425 if (! sunos_read_dynamic_info (abfd))
428 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
431 bfd_set_error (bfd_error_no_symbols);
435 return (info->dynrel_count + 1) * sizeof (arelent *);
438 /* Read in the dynamic relocs. */
441 sunos_canonicalize_dynamic_reloc (abfd, storage, syms)
446 struct sunos_dynamic_info *info;
449 /* Get the general dynamic information. */
450 if (obj_aout_dynamic_info (abfd) == (PTR) NULL)
452 if (! sunos_read_dynamic_info (abfd))
456 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
459 bfd_set_error (bfd_error_no_symbols);
463 /* Get the dynamic reloc information. */
464 if (info->dynrel == NULL)
466 info->dynrel = (PTR) bfd_alloc (abfd,
468 * obj_reloc_entry_size (abfd)));
469 if (info->dynrel == NULL && info->dynrel_count != 0)
471 if (bfd_seek (abfd, info->dyninfo.ld_rel, SEEK_SET) != 0
472 || (bfd_read ((PTR) info->dynrel, info->dynrel_count,
473 obj_reloc_entry_size (abfd), abfd)
474 != info->dynrel_count * obj_reloc_entry_size (abfd)))
476 if (info->dynrel != NULL)
478 bfd_release (abfd, info->dynrel);
485 /* Get the arelent structures corresponding to the dynamic reloc
487 if (info->canonical_dynrel == (arelent *) NULL)
491 info->canonical_dynrel = ((arelent *)
494 * sizeof (arelent))));
495 if (info->canonical_dynrel == NULL && info->dynrel_count != 0)
498 to = info->canonical_dynrel;
500 if (obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE)
502 register struct reloc_ext_external *p;
503 struct reloc_ext_external *pend;
505 p = (struct reloc_ext_external *) info->dynrel;
506 pend = p + info->dynrel_count;
507 for (; p < pend; p++, to++)
508 NAME(aout,swap_ext_reloc_in) (abfd, p, to, syms,
513 register struct reloc_std_external *p;
514 struct reloc_std_external *pend;
516 p = (struct reloc_std_external *) info->dynrel;
517 pend = p + info->dynrel_count;
518 for (; p < pend; p++, to++)
519 NAME(aout,swap_std_reloc_in) (abfd, p, to, syms,
524 /* Return pointers to the dynamic arelent structures. */
525 for (i = 0; i < info->dynrel_count; i++)
526 *storage++ = info->canonical_dynrel + i;
529 return info->dynrel_count;
532 /* Code to handle linking of SunOS shared libraries. */
534 /* A SPARC procedure linkage table entry is 12 bytes. The first entry
535 in the table is a jump which is filled in by the runtime linker.
536 The remaining entries are branches back to the first entry,
537 followed by an index into the relocation table encoded to look like
540 #define SPARC_PLT_ENTRY_SIZE (12)
542 static const bfd_byte sparc_plt_first_entry[SPARC_PLT_ENTRY_SIZE] =
544 /* sethi %hi(0),%g1; address filled in by runtime linker. */
546 /* jmp %g1; offset filled in by runtime linker. */
552 /* save %sp, -96, %sp */
553 #define SPARC_PLT_ENTRY_WORD0 0x9de3bfa0
554 /* call; address filled in later. */
555 #define SPARC_PLT_ENTRY_WORD1 0x40000000
556 /* sethi; reloc index filled in later. */
557 #define SPARC_PLT_ENTRY_WORD2 0x01000000
559 /* This sequence is used when for the jump table entry to a defined
560 symbol in a complete executable. It is used when linking PIC
561 compiled code which is not being put into a shared library. */
562 /* sethi <address to be filled in later>, %g1 */
563 #define SPARC_PLT_PIC_WORD0 0x03000000
564 /* jmp %g1 + <address to be filled in later> */
565 #define SPARC_PLT_PIC_WORD1 0x81c06000
567 #define SPARC_PLT_PIC_WORD2 0x01000000
569 /* An m68k procedure linkage table entry is 8 bytes. The first entry
570 in the table is a jump which is filled in the by the runtime
571 linker. The remaining entries are branches back to the first
572 entry, followed by a two byte index into the relocation table. */
574 #define M68K_PLT_ENTRY_SIZE (8)
576 static const bfd_byte m68k_plt_first_entry[M68K_PLT_ENTRY_SIZE] =
580 /* Filled in by runtime linker with a magic address. */
587 #define M68K_PLT_ENTRY_WORD0 (0x61ff)
588 /* Remaining words filled in later. */
590 /* An entry in the SunOS linker hash table. */
592 struct sunos_link_hash_entry
594 struct aout_link_hash_entry root;
596 /* If this is a dynamic symbol, this is its index into the dynamic
597 symbol table. This is initialized to -1. As the linker looks at
598 the input files, it changes this to -2 if it will be added to the
599 dynamic symbol table. After all the input files have been seen,
600 the linker will know whether to build a dynamic symbol table; if
601 it does build one, this becomes the index into the table. */
604 /* If this is a dynamic symbol, this is the index of the name in the
605 dynamic symbol string table. */
608 /* The offset into the global offset table used for this symbol. If
609 the symbol does not require a GOT entry, this is 0. */
612 /* The offset into the procedure linkage table used for this symbol.
613 If the symbol does not require a PLT entry, this is 0. */
616 /* Some linker flags. */
618 /* Symbol is referenced by a regular object. */
619 #define SUNOS_REF_REGULAR 01
620 /* Symbol is defined by a regular object. */
621 #define SUNOS_DEF_REGULAR 02
622 /* Symbol is referenced by a dynamic object. */
623 #define SUNOS_REF_DYNAMIC 04
624 /* Symbol is defined by a dynamic object. */
625 #define SUNOS_DEF_DYNAMIC 010
626 /* Symbol is a constructor symbol in a regular object. */
627 #define SUNOS_CONSTRUCTOR 020
630 /* The SunOS linker hash table. */
632 struct sunos_link_hash_table
634 struct aout_link_hash_table root;
636 /* The object which holds the dynamic sections. */
639 /* Whether we have created the dynamic sections. */
640 boolean dynamic_sections_created;
642 /* Whether we need the dynamic sections. */
643 boolean dynamic_sections_needed;
645 /* The number of dynamic symbols. */
648 /* The number of buckets in the hash table. */
651 /* The list of dynamic objects needed by dynamic objects included in
653 struct bfd_link_needed_list *needed;
656 /* Routine to create an entry in an SunOS link hash table. */
658 static struct bfd_hash_entry *
659 sunos_link_hash_newfunc (entry, table, string)
660 struct bfd_hash_entry *entry;
661 struct bfd_hash_table *table;
664 struct sunos_link_hash_entry *ret = (struct sunos_link_hash_entry *) entry;
666 /* Allocate the structure if it has not already been allocated by a
668 if (ret == (struct sunos_link_hash_entry *) NULL)
669 ret = ((struct sunos_link_hash_entry *)
670 bfd_hash_allocate (table, sizeof (struct sunos_link_hash_entry)));
671 if (ret == (struct sunos_link_hash_entry *) NULL)
672 return (struct bfd_hash_entry *) ret;
674 /* Call the allocation method of the superclass. */
675 ret = ((struct sunos_link_hash_entry *)
676 NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
680 /* Set local fields. */
682 ret->dynstr_index = -1;
688 return (struct bfd_hash_entry *) ret;
691 /* Create a SunOS link hash table. */
693 static struct bfd_link_hash_table *
694 sunos_link_hash_table_create (abfd)
697 struct sunos_link_hash_table *ret;
699 ret = ((struct sunos_link_hash_table *)
700 bfd_alloc (abfd, sizeof (struct sunos_link_hash_table)));
701 if (ret == (struct sunos_link_hash_table *) NULL)
702 return (struct bfd_link_hash_table *) NULL;
703 if (! NAME(aout,link_hash_table_init) (&ret->root, abfd,
704 sunos_link_hash_newfunc))
706 bfd_release (abfd, ret);
707 return (struct bfd_link_hash_table *) NULL;
711 ret->dynamic_sections_created = false;
712 ret->dynamic_sections_needed = false;
713 ret->dynsymcount = 0;
714 ret->bucketcount = 0;
717 return &ret->root.root;
720 /* Look up an entry in an SunOS link hash table. */
722 #define sunos_link_hash_lookup(table, string, create, copy, follow) \
723 ((struct sunos_link_hash_entry *) \
724 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
727 /* Traverse a SunOS link hash table. */
729 #define sunos_link_hash_traverse(table, func, info) \
730 (aout_link_hash_traverse \
732 (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
735 /* Get the SunOS link hash table from the info structure. This is
738 #define sunos_hash_table(p) ((struct sunos_link_hash_table *) ((p)->hash))
740 static boolean sunos_scan_dynamic_symbol
741 PARAMS ((struct sunos_link_hash_entry *, PTR));
743 /* Create the dynamic sections needed if we are linking against a
744 dynamic object, or if we are linking PIC compiled code. ABFD is a
745 bfd we can attach the dynamic sections to. The linker script will
746 look for these special sections names and put them in the right
747 place in the output file. See include/aout/sun4.h for more details
748 of the dynamic linking information. */
751 sunos_create_dynamic_sections (abfd, info, needed)
753 struct bfd_link_info *info;
758 if (! sunos_hash_table (info)->dynamic_sections_created)
762 sunos_hash_table (info)->dynobj = abfd;
764 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
766 /* The .dynamic section holds the basic dynamic information: the
767 sun4_dynamic structure, the dynamic debugger information, and
768 the sun4_dynamic_link structure. */
769 s = bfd_make_section (abfd, ".dynamic");
771 || ! bfd_set_section_flags (abfd, s, flags)
772 || ! bfd_set_section_alignment (abfd, s, 2))
775 /* The .got section holds the global offset table. The address
776 is put in the ld_got field. */
777 s = bfd_make_section (abfd, ".got");
779 || ! bfd_set_section_flags (abfd, s, flags)
780 || ! bfd_set_section_alignment (abfd, s, 2))
783 /* The .plt section holds the procedure linkage table. The
784 address is put in the ld_plt field. */
785 s = bfd_make_section (abfd, ".plt");
787 || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
788 || ! bfd_set_section_alignment (abfd, s, 2))
791 /* The .dynrel section holds the dynamic relocs. The address is
792 put in the ld_rel field. */
793 s = bfd_make_section (abfd, ".dynrel");
795 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
796 || ! bfd_set_section_alignment (abfd, s, 2))
799 /* The .hash section holds the dynamic hash table. The address
800 is put in the ld_hash field. */
801 s = bfd_make_section (abfd, ".hash");
803 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
804 || ! bfd_set_section_alignment (abfd, s, 2))
807 /* The .dynsym section holds the dynamic symbols. The address
808 is put in the ld_stab field. */
809 s = bfd_make_section (abfd, ".dynsym");
811 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
812 || ! bfd_set_section_alignment (abfd, s, 2))
815 /* The .dynstr section holds the dynamic symbol string table.
816 The address is put in the ld_symbols field. */
817 s = bfd_make_section (abfd, ".dynstr");
819 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
820 || ! bfd_set_section_alignment (abfd, s, 2))
823 sunos_hash_table (info)->dynamic_sections_created = true;
826 if (needed && ! sunos_hash_table (info)->dynamic_sections_needed)
830 dynobj = sunos_hash_table (info)->dynobj;
832 s = bfd_get_section_by_name (dynobj, ".got");
833 s->_raw_size = BYTES_IN_WORD;
835 sunos_hash_table (info)->dynamic_sections_needed = true;
841 /* Add dynamic symbols during a link. This is called by the a.out
842 backend linker when it encounters an object with the DYNAMIC flag
846 sunos_add_dynamic_symbols (abfd, info, symsp, sym_countp, stringsp)
848 struct bfd_link_info *info;
849 struct external_nlist **symsp;
850 bfd_size_type *sym_countp;
855 struct sunos_dynamic_info *dinfo;
858 /* We do not want to include the sections in a dynamic object in the
859 output file. We hack by simply clobbering the list of sections
860 in the BFD. This could be handled more cleanly by, say, a new
861 section flag; the existing SEC_NEVER_LOAD flag is not the one we
862 want, because that one still implies that the section takes up
863 space in the output file. */
864 abfd->sections = NULL;
866 /* The native linker seems to just ignore dynamic objects when -r is
868 if (info->relocateable)
871 /* There's no hope of using a dynamic object which does not exactly
872 match the format of the output file. */
873 if (info->hash->creator != abfd->xvec)
875 bfd_set_error (bfd_error_invalid_operation);
879 /* Make sure we have all the required information. */
880 if (! sunos_create_dynamic_sections (abfd, info, true))
883 /* Make sure we have a .need and a .rules sections. These are only
884 needed if there really is a dynamic object in the link, so they
885 are not added by sunos_create_dynamic_sections. */
886 dynobj = sunos_hash_table (info)->dynobj;
887 if (bfd_get_section_by_name (dynobj, ".need") == NULL)
889 /* The .need section holds the list of names of shared objets
890 which must be included at runtime. The address of this
891 section is put in the ld_need field. */
892 s = bfd_make_section (dynobj, ".need");
894 || ! bfd_set_section_flags (dynobj, s,
900 || ! bfd_set_section_alignment (dynobj, s, 2))
904 if (bfd_get_section_by_name (dynobj, ".rules") == NULL)
906 /* The .rules section holds the path to search for shared
907 objects. The address of this section is put in the ld_rules
909 s = bfd_make_section (dynobj, ".rules");
911 || ! bfd_set_section_flags (dynobj, s,
917 || ! bfd_set_section_alignment (dynobj, s, 2))
921 /* Pick up the dynamic symbols and return them to the caller. */
922 if (! sunos_slurp_dynamic_symtab (abfd))
925 dinfo = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
926 *symsp = dinfo->dynsym;
927 *sym_countp = dinfo->dynsym_count;
928 *stringsp = dinfo->dynstr;
930 /* Record information about any other objects needed by this one. */
931 need = dinfo->dyninfo.ld_need;
935 unsigned long name, flags;
936 unsigned short major_vno, minor_vno;
937 struct bfd_link_needed_list *needed, **pp;
940 if (bfd_seek (abfd, need, SEEK_SET) != 0
941 || bfd_read (buf, 1, 16, abfd) != 16)
944 /* For the format of an ld_need entry, see aout/sun4.h. We
945 should probably define structs for this manipulation. */
947 name = bfd_get_32 (abfd, buf);
948 flags = bfd_get_32 (abfd, buf + 4);
949 major_vno = bfd_get_16 (abfd, buf + 8);
950 minor_vno = bfd_get_16 (abfd, buf + 10);
951 need = bfd_get_32 (abfd, buf + 12);
953 needed = (struct bfd_link_needed_list *) bfd_alloc (abfd, sizeof (struct bfd_link_needed_list));
958 /* We return the name as [-l]name[.maj][.min]. */
960 if ((flags & 0x80000000) != 0)
961 bfd_alloc_grow (abfd, "-l", 2);
962 if (bfd_seek (abfd, name, SEEK_SET) != 0)
966 if (bfd_read (&b, 1, 1, abfd) != 1)
968 bfd_alloc_grow (abfd, &b, 1);
975 sprintf (verbuf, ".%d", major_vno);
976 bfd_alloc_grow (abfd, verbuf, strlen (verbuf));
979 sprintf (verbuf, ".%d", minor_vno);
980 bfd_alloc_grow (abfd, verbuf, strlen (verbuf));
983 needed->name = bfd_alloc_finish (abfd);
984 if (needed->name == NULL)
989 for (pp = &sunos_hash_table (info)->needed;
999 /* Function to add a single symbol to the linker hash table. This is
1000 a wrapper around _bfd_generic_link_add_one_symbol which handles the
1001 tweaking needed for dynamic linking support. */
1004 sunos_add_one_symbol (info, abfd, name, flags, section, value, string,
1005 copy, collect, hashp)
1006 struct bfd_link_info *info;
1015 struct bfd_link_hash_entry **hashp;
1017 struct sunos_link_hash_entry *h;
1020 if (! sunos_hash_table (info)->dynamic_sections_created)
1022 /* We must create the dynamic sections while reading the input
1023 files, even though at this point we don't know if any of the
1024 sections will be needed. This will ensure that the dynamic
1025 sections are mapped to the right output section. It does no
1026 harm to create these sections if they are not needed. */
1027 if (! sunos_create_dynamic_sections (abfd, info, false))
1031 h = sunos_link_hash_lookup (sunos_hash_table (info), name, true, copy,
1037 *hashp = (struct bfd_link_hash_entry *) h;
1039 /* Treat a common symbol in a dynamic object as defined in the .bss
1040 section of the dynamic object. We don't want to allocate space
1041 for it in our process image. */
1042 if ((abfd->flags & DYNAMIC) != 0
1043 && bfd_is_com_section (section))
1044 section = obj_bsssec (abfd);
1046 if (! bfd_is_und_section (section)
1047 && h->root.root.type != bfd_link_hash_new
1048 && h->root.root.type != bfd_link_hash_undefined
1049 && h->root.root.type != bfd_link_hash_defweak)
1051 /* We are defining the symbol, and it is already defined. This
1052 is a potential multiple definition error. */
1053 if ((abfd->flags & DYNAMIC) != 0)
1055 /* The definition we are adding is from a dynamic object.
1056 We do not want this new definition to override the
1057 existing definition, so we pretend it is just a
1059 section = bfd_und_section_ptr;
1061 else if (h->root.root.type == bfd_link_hash_defined
1062 && h->root.root.u.def.section->owner != NULL
1063 && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
1065 /* The existing definition is from a dynamic object. We
1066 want to override it with the definition we just found.
1067 Clobber the existing definition. */
1068 h->root.root.type = bfd_link_hash_new;
1070 else if (h->root.root.type == bfd_link_hash_common
1071 && (h->root.root.u.c.p->section->owner->flags & DYNAMIC) != 0)
1073 /* The existing definition is from a dynamic object. We
1074 want to override it with the definition we just found.
1075 Clobber the existing definition. We can't set it to new,
1076 because it is on the undefined list. */
1077 h->root.root.type = bfd_link_hash_undefined;
1078 h->root.root.u.undef.abfd = h->root.root.u.c.p->section->owner;
1082 if ((abfd->flags & DYNAMIC) != 0
1083 && abfd->xvec == info->hash->creator
1084 && (h->flags & SUNOS_CONSTRUCTOR) != 0)
1086 /* The existing symbol is a constructor symbol, and this symbol
1087 is from a dynamic object. A constructor symbol is actually a
1088 definition, although the type will be bfd_link_hash_undefined
1089 at this point. We want to ignore the definition from the
1091 section = bfd_und_section_ptr;
1093 else if ((flags & BSF_CONSTRUCTOR) != 0
1094 && (abfd->flags & DYNAMIC) == 0
1095 && h->root.root.type == bfd_link_hash_defined
1096 && h->root.root.u.def.section->owner != NULL
1097 && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
1099 /* The existing symbol is defined by a dynamic object, and this
1100 is a constructor symbol. As above, we want to force the use
1101 of the constructor symbol from the regular object. */
1102 h->root.root.type = bfd_link_hash_new;
1105 /* Do the usual procedure for adding a symbol. */
1106 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
1107 value, string, copy, collect,
1111 if (abfd->xvec == info->hash->creator)
1113 /* Set a flag in the hash table entry indicating the type of
1114 reference or definition we just found. Keep a count of the
1115 number of dynamic symbols we find. A dynamic symbol is one
1116 which is referenced or defined by both a regular object and a
1118 if ((abfd->flags & DYNAMIC) == 0)
1120 if (bfd_is_und_section (section))
1121 new_flag = SUNOS_REF_REGULAR;
1123 new_flag = SUNOS_DEF_REGULAR;
1127 if (bfd_is_und_section (section))
1128 new_flag = SUNOS_REF_DYNAMIC;
1130 new_flag = SUNOS_DEF_DYNAMIC;
1132 h->flags |= new_flag;
1134 if (h->dynindx == -1
1135 && (h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
1137 ++sunos_hash_table (info)->dynsymcount;
1141 if ((flags & BSF_CONSTRUCTOR) != 0
1142 && (abfd->flags & DYNAMIC) == 0)
1143 h->flags |= SUNOS_CONSTRUCTOR;
1149 /* Return the list of objects needed by BFD. */
1152 struct bfd_link_needed_list *
1153 bfd_sunos_get_needed_list (abfd, info)
1155 struct bfd_link_info *info;
1157 if (info->hash->creator != &MY(vec))
1159 return sunos_hash_table (info)->needed;
1162 /* Record an assignment made to a symbol by a linker script. We need
1163 this in case some dynamic object refers to this symbol. */
1166 bfd_sunos_record_link_assignment (output_bfd, info, name)
1168 struct bfd_link_info *info;
1171 struct sunos_link_hash_entry *h;
1173 if (output_bfd->xvec != &MY(vec))
1176 /* This is called after we have examined all the input objects. If
1177 the symbol does not exist, it merely means that no object refers
1178 to it, and we can just ignore it at this point. */
1179 h = sunos_link_hash_lookup (sunos_hash_table (info), name,
1180 false, false, false);
1184 /* In a shared library, the __DYNAMIC symbol does not appear in the
1185 dynamic symbol table. */
1186 if (! info->shared || strcmp (name, "__DYNAMIC") != 0)
1188 h->flags |= SUNOS_DEF_REGULAR;
1190 if (h->dynindx == -1)
1192 ++sunos_hash_table (info)->dynsymcount;
1200 /* Set up the sizes and contents of the dynamic sections created in
1201 sunos_add_dynamic_symbols. This is called by the SunOS linker
1202 emulation before_allocation routine. We must set the sizes of the
1203 sections before the linker sets the addresses of the various
1204 sections. This unfortunately requires reading all the relocs so
1205 that we can work out which ones need to become dynamic relocs. If
1206 info->keep_memory is true, we keep the relocs in memory; otherwise,
1207 we discard them, and will read them again later. */
1210 bfd_sunos_size_dynamic_sections (output_bfd, info, sdynptr, sneedptr,
1213 struct bfd_link_info *info;
1215 asection **sneedptr;
1216 asection **srulesptr;
1220 struct sunos_link_hash_entry *h;
1231 if (output_bfd->xvec != &MY(vec))
1234 /* Look through all the input BFD's and read their relocs. It would
1235 be better if we didn't have to do this, but there is no other way
1236 to determine the number of dynamic relocs we need, and, more
1237 importantly, there is no other way to know which symbols should
1238 get an entry in the procedure linkage table. */
1239 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
1241 if ((sub->flags & DYNAMIC) == 0
1242 && sub->xvec == output_bfd->xvec)
1244 if (! sunos_scan_relocs (info, sub, obj_textsec (sub),
1245 exec_hdr (sub)->a_trsize)
1246 || ! sunos_scan_relocs (info, sub, obj_datasec (sub),
1247 exec_hdr (sub)->a_drsize))
1252 dynobj = sunos_hash_table (info)->dynobj;
1253 dynsymcount = sunos_hash_table (info)->dynsymcount;
1255 /* If there were no dynamic objects in the link, and we don't need
1256 to build a global offset table, there is nothing to do here. */
1257 if (! sunos_hash_table (info)->dynamic_sections_needed)
1260 /* If __GLOBAL_OFFSET_TABLE_ was mentioned, define it. */
1261 h = sunos_link_hash_lookup (sunos_hash_table (info),
1262 "__GLOBAL_OFFSET_TABLE_", false, false, false);
1263 if (h != NULL && (h->flags & SUNOS_REF_REGULAR) != 0)
1265 h->flags |= SUNOS_DEF_REGULAR;
1266 if (h->dynindx == -1)
1268 ++sunos_hash_table (info)->dynsymcount;
1271 h->root.root.type = bfd_link_hash_defined;
1272 h->root.root.u.def.section = bfd_get_section_by_name (dynobj, ".got");
1273 h->root.root.u.def.value = 0;
1276 /* The .dynamic section is always the same size. */
1277 s = bfd_get_section_by_name (dynobj, ".dynamic");
1278 BFD_ASSERT (s != NULL);
1279 s->_raw_size = (sizeof (struct external_sun4_dynamic)
1280 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
1281 + sizeof (struct external_sun4_dynamic_link));
1283 /* Set the size of the .dynsym and .hash sections. We counted the
1284 number of dynamic symbols as we read the input files. We will
1285 build the dynamic symbol table (.dynsym) and the hash table
1286 (.hash) when we build the final symbol table, because until then
1287 we do not know the correct value to give the symbols. We build
1288 the dynamic symbol string table (.dynstr) in a traversal of the
1289 symbol table using sunos_scan_dynamic_symbol. */
1290 s = bfd_get_section_by_name (dynobj, ".dynsym");
1291 BFD_ASSERT (s != NULL);
1292 s->_raw_size = dynsymcount * sizeof (struct external_nlist);
1293 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1294 if (s->contents == NULL && s->_raw_size != 0)
1297 /* The number of buckets is just the number of symbols divided by
1298 four. To compute the final size of the hash table, we must
1299 actually compute the hash table. Normally we need exactly as
1300 many entries in the hash table as there are dynamic symbols, but
1301 if some of the buckets are not used we will need additional
1302 entries. In the worst case, every symbol will hash to the same
1303 bucket, and we will need BUCKETCOUNT - 1 extra entries. */
1304 if (dynsymcount >= 4)
1305 bucketcount = dynsymcount / 4;
1306 else if (dynsymcount > 0)
1307 bucketcount = dynsymcount;
1310 s = bfd_get_section_by_name (dynobj, ".hash");
1311 BFD_ASSERT (s != NULL);
1312 hashalloc = (dynsymcount + bucketcount - 1) * HASH_ENTRY_SIZE;
1313 s->contents = (bfd_byte *) bfd_alloc (dynobj, hashalloc);
1314 if (s->contents == NULL && dynsymcount > 0)
1316 memset (s->contents, 0, hashalloc);
1317 for (i = 0; i < bucketcount; i++)
1318 PUT_WORD (output_bfd, (bfd_vma) -1, s->contents + i * HASH_ENTRY_SIZE);
1319 s->_raw_size = bucketcount * HASH_ENTRY_SIZE;
1321 sunos_hash_table (info)->bucketcount = bucketcount;
1323 /* Scan all the symbols, place them in the dynamic symbol table, and
1324 build the dynamic hash table. We reuse dynsymcount as a counter
1325 for the number of symbols we have added so far. */
1326 sunos_hash_table (info)->dynsymcount = 0;
1327 sunos_link_hash_traverse (sunos_hash_table (info),
1328 sunos_scan_dynamic_symbol,
1330 BFD_ASSERT (sunos_hash_table (info)->dynsymcount == dynsymcount);
1332 /* The SunOS native linker seems to align the total size of the
1333 symbol strings to a multiple of 8. I don't know if this is
1334 important, but it can't hurt much. */
1335 s = bfd_get_section_by_name (dynobj, ".dynstr");
1336 BFD_ASSERT (s != NULL);
1337 if ((s->_raw_size & 7) != 0)
1342 add = 8 - (s->_raw_size & 7);
1343 contents = (bfd_byte *) bfd_realloc (s->contents,
1344 (size_t) (s->_raw_size + add));
1345 if (contents == NULL)
1347 memset (contents + s->_raw_size, 0, (size_t) add);
1348 s->contents = contents;
1349 s->_raw_size += add;
1352 /* Now that we have worked out the sizes of the procedure linkage
1353 table and the dynamic relocs, allocate storage for them. */
1354 s = bfd_get_section_by_name (dynobj, ".plt");
1355 BFD_ASSERT (s != NULL);
1356 if (s->_raw_size != 0)
1358 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1359 if (s->contents == NULL)
1362 /* Fill in the first entry in the table. */
1363 switch (bfd_get_arch (dynobj))
1365 case bfd_arch_sparc:
1366 memcpy (s->contents, sparc_plt_first_entry, SPARC_PLT_ENTRY_SIZE);
1370 memcpy (s->contents, m68k_plt_first_entry, M68K_PLT_ENTRY_SIZE);
1378 s = bfd_get_section_by_name (dynobj, ".dynrel");
1379 if (s->_raw_size != 0)
1381 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1382 if (s->contents == NULL)
1385 /* We use the reloc_count field to keep track of how many of the
1386 relocs we have output so far. */
1389 /* Make space for the global offset table. */
1390 s = bfd_get_section_by_name (dynobj, ".got");
1391 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1392 if (s->contents == NULL)
1395 *sdynptr = bfd_get_section_by_name (dynobj, ".dynamic");
1396 *sneedptr = bfd_get_section_by_name (dynobj, ".need");
1397 *srulesptr = bfd_get_section_by_name (dynobj, ".rules");
1402 /* Scan the relocs for an input section. */
1405 sunos_scan_relocs (info, abfd, sec, rel_size)
1406 struct bfd_link_info *info;
1409 bfd_size_type rel_size;
1412 PTR free_relocs = NULL;
1417 if (! info->keep_memory)
1418 relocs = free_relocs = bfd_malloc ((size_t) rel_size);
1421 struct aout_section_data_struct *n;
1423 n = ((struct aout_section_data_struct *)
1424 bfd_alloc (abfd, sizeof (struct aout_section_data_struct)));
1429 set_aout_section_data (sec, n);
1430 relocs = bfd_malloc ((size_t) rel_size);
1431 aout_section_data (sec)->relocs = relocs;
1437 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
1438 || bfd_read (relocs, 1, rel_size, abfd) != rel_size)
1441 if (obj_reloc_entry_size (abfd) == RELOC_STD_SIZE)
1443 if (! sunos_scan_std_relocs (info, abfd, sec,
1444 (struct reloc_std_external *) relocs,
1450 if (! sunos_scan_ext_relocs (info, abfd, sec,
1451 (struct reloc_ext_external *) relocs,
1456 if (free_relocs != NULL)
1462 if (free_relocs != NULL)
1467 /* Scan the relocs for an input section using standard relocs. We
1468 need to figure out what to do for each reloc against a dynamic
1469 symbol. If the symbol is in the .text section, an entry is made in
1470 the procedure linkage table. Note that this will do the wrong
1471 thing if the symbol is actually data; I don't think the Sun 3
1472 native linker handles this case correctly either. If the symbol is
1473 not in the .text section, we must preserve the reloc as a dynamic
1474 reloc. FIXME: We should also handle the PIC relocs here by
1475 building global offset table entries. */
1478 sunos_scan_std_relocs (info, abfd, sec, relocs, rel_size)
1479 struct bfd_link_info *info;
1482 const struct reloc_std_external *relocs;
1483 bfd_size_type rel_size;
1486 asection *splt = NULL;
1487 asection *srel = NULL;
1488 struct sunos_link_hash_entry **sym_hashes;
1489 const struct reloc_std_external *rel, *relend;
1491 /* We only know how to handle m68k plt entries. */
1492 if (bfd_get_arch (abfd) != bfd_arch_m68k)
1494 bfd_set_error (bfd_error_invalid_target);
1500 sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
1502 relend = relocs + rel_size / RELOC_STD_SIZE;
1503 for (rel = relocs; rel < relend; rel++)
1506 struct sunos_link_hash_entry *h;
1508 /* We only want relocs against external symbols. */
1509 if (bfd_header_big_endian (abfd))
1511 if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG) == 0)
1516 if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE) == 0)
1520 /* Get the symbol index. */
1521 if (bfd_header_big_endian (abfd))
1522 r_index = ((rel->r_index[0] << 16)
1523 | (rel->r_index[1] << 8)
1526 r_index = ((rel->r_index[2] << 16)
1527 | (rel->r_index[1] << 8)
1530 /* Get the hash table entry. */
1531 h = sym_hashes[r_index];
1534 /* This should not normally happen, but it will in any case
1535 be caught in the relocation phase. */
1539 /* At this point common symbols have already been allocated, so
1540 we don't have to worry about them. We need to consider that
1541 we may have already seen this symbol and marked it undefined;
1542 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1544 if (h->root.root.type != bfd_link_hash_defined
1545 && h->root.root.type != bfd_link_hash_defweak
1546 && h->root.root.type != bfd_link_hash_undefined)
1549 if ((h->flags & SUNOS_DEF_DYNAMIC) == 0
1550 || (h->flags & SUNOS_DEF_REGULAR) != 0)
1555 if (! sunos_create_dynamic_sections (abfd, info, true))
1557 dynobj = sunos_hash_table (info)->dynobj;
1558 splt = bfd_get_section_by_name (dynobj, ".plt");
1559 srel = bfd_get_section_by_name (dynobj, ".dynrel");
1560 BFD_ASSERT (splt != NULL && srel != NULL);
1563 BFD_ASSERT ((h->flags & SUNOS_REF_REGULAR) != 0);
1564 BFD_ASSERT (h->plt_offset != 0
1565 || ((h->root.root.type == bfd_link_hash_defined
1566 || h->root.root.type == bfd_link_hash_defweak)
1567 ? (h->root.root.u.def.section->owner->flags
1569 : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0));
1571 /* This reloc is against a symbol defined only by a dynamic
1574 if (h->root.root.type == bfd_link_hash_undefined)
1576 /* Presumably this symbol was marked as being undefined by
1577 an earlier reloc. */
1578 srel->_raw_size += RELOC_STD_SIZE;
1580 else if ((h->root.root.u.def.section->flags & SEC_CODE) == 0)
1584 /* This reloc is not in the .text section. It must be
1585 copied into the dynamic relocs. We mark the symbol as
1587 srel->_raw_size += RELOC_STD_SIZE;
1588 sub = h->root.root.u.def.section->owner;
1589 h->root.root.type = bfd_link_hash_undefined;
1590 h->root.root.u.undef.abfd = sub;
1594 /* This symbol is in the .text section. We must give it an
1595 entry in the procedure linkage table, if we have not
1596 already done so. We change the definition of the symbol
1597 to the .plt section; this will cause relocs against it to
1598 be handled correctly. */
1599 if (h->plt_offset == 0)
1601 if (splt->_raw_size == 0)
1602 splt->_raw_size = M68K_PLT_ENTRY_SIZE;
1603 h->plt_offset = splt->_raw_size;
1605 if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1607 h->root.root.u.def.section = splt;
1608 h->root.root.u.def.value = splt->_raw_size;
1611 splt->_raw_size += M68K_PLT_ENTRY_SIZE;
1613 /* We may also need a dynamic reloc entry. */
1614 if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1615 srel->_raw_size += RELOC_STD_SIZE;
1623 /* Scan the relocs for an input section using extended relocs. We
1624 need to figure out what to do for each reloc against a dynamic
1625 symbol. If the reloc is a WDISP30, and the symbol is in the .text
1626 section, an entry is made in the procedure linkage table.
1627 Otherwise, we must preserve the reloc as a dynamic reloc. */
1630 sunos_scan_ext_relocs (info, abfd, sec, relocs, rel_size)
1631 struct bfd_link_info *info;
1634 const struct reloc_ext_external *relocs;
1635 bfd_size_type rel_size;
1638 struct sunos_link_hash_entry **sym_hashes;
1639 const struct reloc_ext_external *rel, *relend;
1640 asection *splt = NULL;
1641 asection *sgot = NULL;
1642 asection *srel = NULL;
1644 /* We only know how to handle SPARC plt entries. */
1645 if (bfd_get_arch (abfd) != bfd_arch_sparc)
1647 bfd_set_error (bfd_error_invalid_target);
1653 sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
1655 relend = relocs + rel_size / RELOC_EXT_SIZE;
1656 for (rel = relocs; rel < relend; rel++)
1658 unsigned int r_index;
1661 struct sunos_link_hash_entry *h = NULL;
1663 /* Swap in the reloc information. */
1664 if (bfd_header_big_endian (abfd))
1666 r_index = ((rel->r_index[0] << 16)
1667 | (rel->r_index[1] << 8)
1669 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
1670 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
1671 >> RELOC_EXT_BITS_TYPE_SH_BIG);
1675 r_index = ((rel->r_index[2] << 16)
1676 | (rel->r_index[1] << 8)
1678 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
1679 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
1680 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
1685 h = sym_hashes[r_index];
1688 /* This should not normally happen, but it will in any
1689 case be caught in the relocation phase. */
1694 /* If this is a base relative reloc, we need to make an entry in
1695 the .got section. */
1696 if (r_type == RELOC_BASE10
1697 || r_type == RELOC_BASE13
1698 || r_type == RELOC_BASE22)
1702 if (! sunos_create_dynamic_sections (abfd, info, true))
1704 dynobj = sunos_hash_table (info)->dynobj;
1705 splt = bfd_get_section_by_name (dynobj, ".plt");
1706 sgot = bfd_get_section_by_name (dynobj, ".got");
1707 srel = bfd_get_section_by_name (dynobj, ".dynrel");
1708 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1713 if (h->got_offset != 0)
1716 h->got_offset = sgot->_raw_size;
1720 if (r_index >= bfd_get_symcount (abfd))
1722 /* This is abnormal, but should be caught in the
1723 relocation phase. */
1727 if (adata (abfd).local_got_offsets == NULL)
1729 adata (abfd).local_got_offsets =
1730 (bfd_vma *) bfd_zalloc (abfd,
1731 (bfd_get_symcount (abfd)
1732 * sizeof (bfd_vma)));
1733 if (adata (abfd).local_got_offsets == NULL)
1737 if (adata (abfd).local_got_offsets[r_index] != 0)
1740 adata (abfd).local_got_offsets[r_index] = sgot->_raw_size;
1743 sgot->_raw_size += BYTES_IN_WORD;
1745 /* If we are making a shared library, or if the symbol is
1746 defined by a dynamic object, we will need a dynamic reloc
1750 && (h->flags & SUNOS_DEF_DYNAMIC) != 0
1751 && (h->flags & SUNOS_DEF_REGULAR) == 0))
1752 srel->_raw_size += RELOC_EXT_SIZE;
1757 /* Otherwise, we are only interested in relocs against symbols
1758 defined in dynamic objects but not in regular objects. We
1759 only need to consider relocs against external symbols. */
1762 /* But, if we are creating a shared library, we need to
1763 generate an absolute reloc. */
1768 if (! sunos_create_dynamic_sections (abfd, info, true))
1770 dynobj = sunos_hash_table (info)->dynobj;
1771 splt = bfd_get_section_by_name (dynobj, ".plt");
1772 sgot = bfd_get_section_by_name (dynobj, ".got");
1773 srel = bfd_get_section_by_name (dynobj, ".dynrel");
1774 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1777 srel->_raw_size += RELOC_EXT_SIZE;
1783 /* At this point common symbols have already been allocated, so
1784 we don't have to worry about them. We need to consider that
1785 we may have already seen this symbol and marked it undefined;
1786 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1788 if (h->root.root.type != bfd_link_hash_defined
1789 && h->root.root.type != bfd_link_hash_defweak
1790 && h->root.root.type != bfd_link_hash_undefined)
1793 if (r_type != RELOC_JMP_TBL
1795 && ((h->flags & SUNOS_DEF_DYNAMIC) == 0
1796 || (h->flags & SUNOS_DEF_REGULAR) != 0))
1799 if (strcmp (h->root.root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
1804 if (! sunos_create_dynamic_sections (abfd, info, true))
1806 dynobj = sunos_hash_table (info)->dynobj;
1807 splt = bfd_get_section_by_name (dynobj, ".plt");
1808 sgot = bfd_get_section_by_name (dynobj, ".got");
1809 srel = bfd_get_section_by_name (dynobj, ".dynrel");
1810 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1813 BFD_ASSERT (r_type == RELOC_JMP_TBL
1815 || (h->flags & SUNOS_REF_REGULAR) != 0);
1816 BFD_ASSERT (r_type == RELOC_JMP_TBL
1818 || h->plt_offset != 0
1819 || ((h->root.root.type == bfd_link_hash_defined
1820 || h->root.root.type == bfd_link_hash_defweak)
1821 ? (h->root.root.u.def.section->owner->flags
1823 : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0));
1825 /* This reloc is against a symbol defined only by a dynamic
1826 object, or it is a jump table reloc from PIC compiled code. */
1828 if (r_type != RELOC_JMP_TBL
1829 && h->root.root.type == bfd_link_hash_undefined)
1831 /* Presumably this symbol was marked as being undefined by
1832 an earlier reloc. */
1833 srel->_raw_size += RELOC_EXT_SIZE;
1835 else if (r_type != RELOC_JMP_TBL
1836 && (h->root.root.u.def.section->flags & SEC_CODE) == 0)
1840 /* This reloc is not in the .text section. It must be
1841 copied into the dynamic relocs. We mark the symbol as
1843 srel->_raw_size += RELOC_EXT_SIZE;
1844 if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1846 sub = h->root.root.u.def.section->owner;
1847 h->root.root.type = bfd_link_hash_undefined;
1848 h->root.root.u.undef.abfd = sub;
1853 /* This symbol is in the .text section. We must give it an
1854 entry in the procedure linkage table, if we have not
1855 already done so. We change the definition of the symbol
1856 to the .plt section; this will cause relocs against it to
1857 be handled correctly. */
1858 if (h->plt_offset == 0)
1860 if (splt->_raw_size == 0)
1861 splt->_raw_size = SPARC_PLT_ENTRY_SIZE;
1862 h->plt_offset = splt->_raw_size;
1864 if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1866 if (h->root.root.type == bfd_link_hash_undefined)
1867 h->root.root.type = bfd_link_hash_defined;
1868 h->root.root.u.def.section = splt;
1869 h->root.root.u.def.value = splt->_raw_size;
1872 splt->_raw_size += SPARC_PLT_ENTRY_SIZE;
1874 /* We will also need a dynamic reloc entry, unless this
1875 is a JMP_TBL reloc produced by linking PIC compiled
1876 code, and we are not making a shared library. */
1877 if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
1878 srel->_raw_size += RELOC_EXT_SIZE;
1881 /* If we are creating a shared library, we need to copy over
1882 any reloc other than a jump table reloc. */
1883 if (info->shared && r_type != RELOC_JMP_TBL)
1884 srel->_raw_size += RELOC_EXT_SIZE;
1891 /* Build the hash table of dynamic symbols, and to mark as written all
1892 symbols from dynamic objects which we do not plan to write out. */
1895 sunos_scan_dynamic_symbol (h, data)
1896 struct sunos_link_hash_entry *h;
1899 struct bfd_link_info *info = (struct bfd_link_info *) data;
1901 /* Set the written flag for symbols we do not want to write out as
1902 part of the regular symbol table. This is all symbols which are
1903 not defined in a regular object file. For some reason symbols
1904 which are referenced by a regular object and defined by a dynamic
1905 object do not seem to show up in the regular symbol table. It is
1906 possible for a symbol to have only SUNOS_REF_REGULAR set here, it
1907 is an undefined symbol which was turned into a common symbol
1908 because it was found in an archive object which was not included
1910 if ((h->flags & SUNOS_DEF_REGULAR) == 0
1911 && (h->flags & SUNOS_DEF_DYNAMIC) != 0
1912 && strcmp (h->root.root.root.string, "__DYNAMIC") != 0)
1913 h->root.written = true;
1915 /* If this symbol is defined by a dynamic object and referenced by a
1916 regular object, see whether we gave it a reasonable value while
1917 scanning the relocs. */
1919 if ((h->flags & SUNOS_DEF_REGULAR) == 0
1920 && (h->flags & SUNOS_DEF_DYNAMIC) != 0
1921 && (h->flags & SUNOS_REF_REGULAR) != 0)
1923 if ((h->root.root.type == bfd_link_hash_defined
1924 || h->root.root.type == bfd_link_hash_defweak)
1925 && ((h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
1926 && h->root.root.u.def.section->output_section == NULL)
1930 /* This symbol is currently defined in a dynamic section
1931 which is not being put into the output file. This
1932 implies that there is no reloc against the symbol. I'm
1933 not sure why this case would ever occur. In any case, we
1934 change the symbol to be undefined. */
1935 sub = h->root.root.u.def.section->owner;
1936 h->root.root.type = bfd_link_hash_undefined;
1937 h->root.root.u.undef.abfd = sub;
1941 /* If this symbol is defined or referenced by a regular file, add it
1942 to the dynamic symbols. */
1943 if ((h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
1948 unsigned char *name;
1952 BFD_ASSERT (h->dynindx == -2);
1954 dynobj = sunos_hash_table (info)->dynobj;
1956 h->dynindx = sunos_hash_table (info)->dynsymcount;
1957 ++sunos_hash_table (info)->dynsymcount;
1959 len = strlen (h->root.root.root.string);
1961 /* We don't bother to construct a BFD hash table for the strings
1962 which are the names of the dynamic symbols. Using a hash
1963 table for the regular symbols is beneficial, because the
1964 regular symbols includes the debugging symbols, which have
1965 long names and are often duplicated in several object files.
1966 There are no debugging symbols in the dynamic symbols. */
1967 s = bfd_get_section_by_name (dynobj, ".dynstr");
1968 BFD_ASSERT (s != NULL);
1969 contents = (bfd_byte *) bfd_realloc (s->contents,
1970 s->_raw_size + len + 1);
1971 if (contents == NULL)
1973 s->contents = contents;
1975 h->dynstr_index = s->_raw_size;
1976 strcpy (contents + s->_raw_size, h->root.root.root.string);
1977 s->_raw_size += len + 1;
1979 /* Add it to the dynamic hash table. */
1980 name = (unsigned char *) h->root.root.root.string;
1982 while (*name != '\0')
1983 hash = (hash << 1) + *name++;
1985 hash %= sunos_hash_table (info)->bucketcount;
1987 s = bfd_get_section_by_name (dynobj, ".hash");
1988 BFD_ASSERT (s != NULL);
1990 if (GET_SWORD (dynobj, s->contents + hash * HASH_ENTRY_SIZE) == -1)
1991 PUT_WORD (dynobj, h->dynindx, s->contents + hash * HASH_ENTRY_SIZE);
1996 next = GET_WORD (dynobj,
1998 + hash * HASH_ENTRY_SIZE
2000 PUT_WORD (dynobj, s->_raw_size / HASH_ENTRY_SIZE,
2001 s->contents + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD);
2002 PUT_WORD (dynobj, h->dynindx, s->contents + s->_raw_size);
2003 PUT_WORD (dynobj, next, s->contents + s->_raw_size + BYTES_IN_WORD);
2004 s->_raw_size += HASH_ENTRY_SIZE;
2011 /* Link a dynamic object. We actually don't have anything to do at
2012 this point. This entry point exists to prevent the regular linker
2013 code from doing anything with the object. */
2017 sunos_link_dynamic_object (info, abfd)
2018 struct bfd_link_info *info;
2024 /* Write out a dynamic symbol. This is called by the final traversal
2025 over the symbol table. */
2028 sunos_write_dynamic_symbol (output_bfd, info, harg)
2030 struct bfd_link_info *info;
2031 struct aout_link_hash_entry *harg;
2033 struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
2037 struct external_nlist *outsym;
2042 switch (h->root.root.type)
2045 case bfd_link_hash_new:
2047 /* Avoid variable not initialized warnings. */
2049 case bfd_link_hash_undefined:
2050 type = N_UNDF | N_EXT;
2053 case bfd_link_hash_defined:
2054 case bfd_link_hash_defweak:
2057 asection *output_section;
2059 sec = h->root.root.u.def.section;
2060 output_section = sec->output_section;
2061 BFD_ASSERT (bfd_is_abs_section (output_section)
2062 || output_section->owner == output_bfd);
2063 if (h->plt_offset != 0
2064 && (h->flags & SUNOS_DEF_REGULAR) == 0)
2066 type = N_UNDF | N_EXT;
2071 if (output_section == obj_textsec (output_bfd))
2072 type = (h->root.root.type == bfd_link_hash_defined
2075 else if (output_section == obj_datasec (output_bfd))
2076 type = (h->root.root.type == bfd_link_hash_defined
2079 else if (output_section == obj_bsssec (output_bfd))
2080 type = (h->root.root.type == bfd_link_hash_defined
2084 type = (h->root.root.type == bfd_link_hash_defined
2088 val = (h->root.root.u.def.value
2089 + output_section->vma
2090 + sec->output_offset);
2094 case bfd_link_hash_common:
2095 type = N_UNDF | N_EXT;
2096 val = h->root.root.u.c.size;
2098 case bfd_link_hash_undefweak:
2102 case bfd_link_hash_indirect:
2103 case bfd_link_hash_warning:
2104 /* FIXME: Ignore these for now. The circumstances under which
2105 they should be written out are not clear to me. */
2109 s = bfd_get_section_by_name (sunos_hash_table (info)->dynobj, ".dynsym");
2110 BFD_ASSERT (s != NULL);
2111 outsym = ((struct external_nlist *)
2112 (s->contents + h->dynindx * EXTERNAL_NLIST_SIZE));
2114 bfd_h_put_8 (output_bfd, type, outsym->e_type);
2115 bfd_h_put_8 (output_bfd, 0, outsym->e_other);
2117 /* FIXME: The native linker doesn't use 0 for desc. It seems to use
2118 one less than the desc value in the shared library, although that
2120 bfd_h_put_16 (output_bfd, 0, outsym->e_desc);
2122 PUT_WORD (output_bfd, h->dynstr_index, outsym->e_strx);
2123 PUT_WORD (output_bfd, val, outsym->e_value);
2125 /* If this symbol is in the procedure linkage table, fill in the
2127 if (h->plt_offset != 0)
2135 dynobj = sunos_hash_table (info)->dynobj;
2136 splt = bfd_get_section_by_name (dynobj, ".plt");
2137 p = splt->contents + h->plt_offset;
2139 s = bfd_get_section_by_name (dynobj, ".dynrel");
2141 r_address = (splt->output_section->vma
2142 + splt->output_offset
2145 switch (bfd_get_arch (output_bfd))
2147 case bfd_arch_sparc:
2148 if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
2150 bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD0, p);
2151 bfd_put_32 (output_bfd,
2152 (SPARC_PLT_ENTRY_WORD1
2153 + (((- (h->plt_offset + 4) >> 2)
2156 bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD2 + s->reloc_count,
2163 val = (h->root.root.u.def.section->output_section->vma
2164 + h->root.root.u.def.section->output_offset
2165 + h->root.root.u.def.value);
2166 bfd_put_32 (output_bfd,
2167 SPARC_PLT_PIC_WORD0 + ((val >> 10) & 0x3fffff),
2169 bfd_put_32 (output_bfd,
2170 SPARC_PLT_PIC_WORD1 + (val & 0x3ff),
2172 bfd_put_32 (output_bfd, SPARC_PLT_PIC_WORD2, p + 8);
2177 if (! info->shared && (h->flags & SUNOS_DEF_REGULAR) != 0)
2179 bfd_put_16 (output_bfd, M68K_PLT_ENTRY_WORD0, p);
2180 bfd_put_32 (output_bfd, (- (h->plt_offset + 2)), p + 2);
2181 bfd_put_16 (output_bfd, s->reloc_count, p + 6);
2189 /* We also need to add a jump table reloc, unless this is the
2190 result of a JMP_TBL reloc from PIC compiled code. */
2191 if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
2193 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
2195 p = s->contents + s->reloc_count * obj_reloc_entry_size (output_bfd);
2196 if (obj_reloc_entry_size (output_bfd) == RELOC_STD_SIZE)
2198 struct reloc_std_external *srel;
2200 srel = (struct reloc_std_external *) p;
2201 PUT_WORD (output_bfd, r_address, srel->r_address);
2202 if (bfd_header_big_endian (output_bfd))
2204 srel->r_index[0] = h->dynindx >> 16;
2205 srel->r_index[1] = h->dynindx >> 8;
2206 srel->r_index[2] = h->dynindx;
2207 srel->r_type[0] = (RELOC_STD_BITS_EXTERN_BIG
2208 | RELOC_STD_BITS_JMPTABLE_BIG);
2212 srel->r_index[2] = h->dynindx >> 16;
2213 srel->r_index[1] = h->dynindx >> 8;
2214 srel->r_index[0] = h->dynindx;
2215 srel->r_type[0] = (RELOC_STD_BITS_EXTERN_LITTLE
2216 | RELOC_STD_BITS_JMPTABLE_LITTLE);
2221 struct reloc_ext_external *erel;
2223 erel = (struct reloc_ext_external *) p;
2224 PUT_WORD (output_bfd, r_address, erel->r_address);
2225 if (bfd_header_big_endian (output_bfd))
2227 erel->r_index[0] = h->dynindx >> 16;
2228 erel->r_index[1] = h->dynindx >> 8;
2229 erel->r_index[2] = h->dynindx;
2231 (RELOC_EXT_BITS_EXTERN_BIG
2232 | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_BIG));
2236 erel->r_index[2] = h->dynindx >> 16;
2237 erel->r_index[1] = h->dynindx >> 8;
2238 erel->r_index[0] = h->dynindx;
2240 (RELOC_EXT_BITS_EXTERN_LITTLE
2241 | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2243 PUT_WORD (output_bfd, (bfd_vma) 0, erel->r_addend);
2253 /* This is called for each reloc against an external symbol. If this
2254 is a reloc which are are going to copy as a dynamic reloc, then
2255 copy it over, and tell the caller to not bother processing this
2260 sunos_check_dynamic_reloc (info, input_bfd, input_section, harg, reloc,
2261 contents, skip, relocationp)
2262 struct bfd_link_info *info;
2264 asection *input_section;
2265 struct aout_link_hash_entry *harg;
2269 bfd_vma *relocationp;
2271 struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
2281 dynobj = sunos_hash_table (info)->dynobj;
2283 if (h != NULL && h->plt_offset != 0)
2287 /* Redirect the relocation to the PLT entry. */
2288 splt = bfd_get_section_by_name (dynobj, ".plt");
2289 *relocationp = (splt->output_section->vma
2290 + splt->output_offset
2294 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
2296 struct reloc_std_external *srel;
2298 srel = (struct reloc_std_external *) reloc;
2299 if (bfd_header_big_endian (input_bfd))
2301 baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2302 jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2306 baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2307 jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2312 struct reloc_ext_external *erel;
2315 erel = (struct reloc_ext_external *) reloc;
2316 if (bfd_header_big_endian (input_bfd))
2317 r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2318 >> RELOC_EXT_BITS_TYPE_SH_BIG);
2320 r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2321 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
2322 baserel = (r_type == RELOC_BASE10
2323 || r_type == RELOC_BASE13
2324 || r_type == RELOC_BASE22);
2325 jmptbl = r_type == RELOC_JMP_TBL;
2330 bfd_vma *got_offsetp;
2334 got_offsetp = &h->got_offset;
2335 else if (adata (input_bfd).local_got_offsets == NULL)
2339 struct reloc_std_external *srel;
2342 srel = (struct reloc_std_external *) reloc;
2343 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
2345 if (bfd_header_big_endian (input_bfd))
2346 r_index = ((srel->r_index[0] << 16)
2347 | (srel->r_index[1] << 8)
2348 | srel->r_index[2]);
2350 r_index = ((srel->r_index[2] << 16)
2351 | (srel->r_index[1] << 8)
2352 | srel->r_index[0]);
2356 struct reloc_ext_external *erel;
2358 erel = (struct reloc_ext_external *) reloc;
2359 if (bfd_header_big_endian (input_bfd))
2360 r_index = ((erel->r_index[0] << 16)
2361 | (erel->r_index[1] << 8)
2362 | erel->r_index[2]);
2364 r_index = ((erel->r_index[2] << 16)
2365 | (erel->r_index[1] << 8)
2366 | erel->r_index[0]);
2369 got_offsetp = adata (input_bfd).local_got_offsets + r_index;
2372 BFD_ASSERT (got_offsetp != NULL && *got_offsetp != 0);
2374 sgot = bfd_get_section_by_name (dynobj, ".got");
2376 /* We set the least significant bit to indicate whether we have
2377 already initialized the GOT entry. */
2378 if ((*got_offsetp & 1) == 0)
2382 && ((h->flags & SUNOS_DEF_DYNAMIC) == 0
2383 || (h->flags & SUNOS_DEF_REGULAR) != 0)))
2384 PUT_WORD (dynobj, *relocationp, sgot->contents + *got_offsetp);
2386 PUT_WORD (dynobj, 0, sgot->contents + *got_offsetp);
2390 && (h->flags & SUNOS_DEF_DYNAMIC) != 0
2391 && (h->flags & SUNOS_DEF_REGULAR) == 0))
2393 /* We need to create a GLOB_DAT or 32 reloc to tell the
2394 dynamic linker to fill in this entry in the table. */
2396 s = bfd_get_section_by_name (dynobj, ".dynrel");
2397 BFD_ASSERT (s != NULL);
2398 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
2402 + s->reloc_count * obj_reloc_entry_size (dynobj));
2409 if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE)
2411 struct reloc_std_external *srel;
2413 srel = (struct reloc_std_external *) p;
2416 + sgot->output_section->vma
2417 + sgot->output_offset),
2419 if (bfd_header_big_endian (dynobj))
2421 srel->r_index[0] = indx >> 16;
2422 srel->r_index[1] = indx >> 8;
2423 srel->r_index[2] = indx;
2425 srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_BIG;
2428 (RELOC_STD_BITS_EXTERN_BIG
2429 | RELOC_STD_BITS_BASEREL_BIG
2430 | RELOC_STD_BITS_RELATIVE_BIG
2431 | (2 << RELOC_STD_BITS_LENGTH_SH_BIG));
2435 srel->r_index[2] = indx >> 16;
2436 srel->r_index[1] = indx >> 8;
2437 srel->r_index[0] = indx;
2439 srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_LITTLE;
2442 (RELOC_STD_BITS_EXTERN_LITTLE
2443 | RELOC_STD_BITS_BASEREL_LITTLE
2444 | RELOC_STD_BITS_RELATIVE_LITTLE
2445 | (2 << RELOC_STD_BITS_LENGTH_SH_LITTLE));
2450 struct reloc_ext_external *erel;
2452 erel = (struct reloc_ext_external *) p;
2455 + sgot->output_section->vma
2456 + sgot->output_offset),
2458 if (bfd_header_big_endian (dynobj))
2460 erel->r_index[0] = indx >> 16;
2461 erel->r_index[1] = indx >> 8;
2462 erel->r_index[2] = indx;
2465 RELOC_32 << RELOC_EXT_BITS_TYPE_SH_BIG;
2468 (RELOC_EXT_BITS_EXTERN_BIG
2469 | (RELOC_GLOB_DAT << RELOC_EXT_BITS_TYPE_SH_BIG));
2473 erel->r_index[2] = indx >> 16;
2474 erel->r_index[1] = indx >> 8;
2475 erel->r_index[0] = indx;
2478 RELOC_32 << RELOC_EXT_BITS_TYPE_SH_LITTLE;
2481 (RELOC_EXT_BITS_EXTERN_LITTLE
2483 << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2485 PUT_WORD (dynobj, 0, erel->r_addend);
2494 *relocationp = sgot->vma + (*got_offsetp &~ 1);
2496 /* There is nothing else to do for a base relative reloc. */
2500 if (! sunos_hash_table (info)->dynamic_sections_needed)
2506 || h->root.root.type != bfd_link_hash_undefined
2507 || (h->flags & SUNOS_DEF_REGULAR) != 0
2508 || (h->flags & SUNOS_DEF_DYNAMIC) == 0
2509 || (h->root.root.u.undef.abfd->flags & DYNAMIC) == 0)
2515 && (h->dynindx == -1
2517 || strcmp (h->root.root.root.string,
2518 "__GLOBAL_OFFSET_TABLE_") == 0))
2522 /* It looks like this is a reloc we are supposed to copy. */
2524 s = bfd_get_section_by_name (dynobj, ".dynrel");
2525 BFD_ASSERT (s != NULL);
2526 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) < s->_raw_size);
2528 p = s->contents + s->reloc_count * obj_reloc_entry_size (dynobj);
2530 /* Copy the reloc over. */
2531 memcpy (p, reloc, obj_reloc_entry_size (dynobj));
2538 /* Adjust the address and symbol index. */
2539 if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE)
2541 struct reloc_std_external *srel;
2543 srel = (struct reloc_std_external *) p;
2545 (GET_WORD (dynobj, srel->r_address)
2546 + input_section->output_section->vma
2547 + input_section->output_offset),
2549 if (bfd_header_big_endian (dynobj))
2551 srel->r_index[0] = indx >> 16;
2552 srel->r_index[1] = indx >> 8;
2553 srel->r_index[2] = indx;
2557 srel->r_index[2] = indx >> 16;
2558 srel->r_index[1] = indx >> 8;
2559 srel->r_index[0] = indx;
2564 struct reloc_ext_external *erel;
2566 erel = (struct reloc_ext_external *) p;
2568 (GET_WORD (dynobj, erel->r_address)
2569 + input_section->output_section->vma
2570 + input_section->output_offset),
2572 if (bfd_header_big_endian (dynobj))
2574 erel->r_index[0] = indx >> 16;
2575 erel->r_index[1] = indx >> 8;
2576 erel->r_index[2] = indx;
2580 erel->r_index[2] = indx >> 16;
2581 erel->r_index[1] = indx >> 8;
2582 erel->r_index[0] = indx;
2594 /* Finish up the dynamic linking information. */
2597 sunos_finish_dynamic_link (abfd, info)
2599 struct bfd_link_info *info;
2605 struct external_sun4_dynamic esd;
2606 struct external_sun4_dynamic_link esdl;
2608 if (! sunos_hash_table (info)->dynamic_sections_needed)
2611 dynobj = sunos_hash_table (info)->dynobj;
2613 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2614 BFD_ASSERT (sdyn != NULL);
2616 /* Finish up the .need section. The linker emulation code filled it
2617 in, but with offsets from the start of the section instead of
2618 real addresses. Now that we know the section location, we can
2619 fill in the final values. */
2620 s = bfd_get_section_by_name (dynobj, ".need");
2621 if (s != NULL && s->_raw_size != 0)
2626 filepos = s->output_section->filepos + s->output_offset;
2632 PUT_WORD (dynobj, GET_WORD (dynobj, p) + filepos, p);
2633 val = GET_WORD (dynobj, p + 12);
2636 PUT_WORD (dynobj, val + filepos, p + 12);
2641 /* The first entry in the .got section is the address of the
2642 dynamic information, unless this is a shared library. */
2643 s = bfd_get_section_by_name (dynobj, ".got");
2644 BFD_ASSERT (s != NULL);
2646 PUT_WORD (dynobj, 0, s->contents);
2648 PUT_WORD (dynobj, sdyn->output_section->vma + sdyn->output_offset,
2651 for (o = dynobj->sections; o != NULL; o = o->next)
2653 if ((o->flags & SEC_HAS_CONTENTS) != 0
2654 && o->contents != NULL)
2656 BFD_ASSERT (o->output_section != NULL
2657 && o->output_section->owner == abfd);
2658 if (! bfd_set_section_contents (abfd, o->output_section,
2659 o->contents, o->output_offset,
2665 /* Finish up the dynamic link information. */
2666 PUT_WORD (dynobj, (bfd_vma) 3, esd.ld_version);
2668 sdyn->output_section->vma + sdyn->output_offset + sizeof esd,
2671 (sdyn->output_section->vma
2672 + sdyn->output_offset
2674 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE),
2677 if (! bfd_set_section_contents (abfd, sdyn->output_section, &esd,
2678 sdyn->output_offset, sizeof esd))
2682 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_loaded);
2684 s = bfd_get_section_by_name (dynobj, ".need");
2685 if (s == NULL || s->_raw_size == 0)
2686 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_need);
2688 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2691 s = bfd_get_section_by_name (dynobj, ".rules");
2692 if (s == NULL || s->_raw_size == 0)
2693 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_rules);
2695 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2698 s = bfd_get_section_by_name (dynobj, ".got");
2699 BFD_ASSERT (s != NULL);
2700 PUT_WORD (dynobj, s->output_section->vma + s->output_offset, esdl.ld_got);
2702 s = bfd_get_section_by_name (dynobj, ".plt");
2703 BFD_ASSERT (s != NULL);
2704 PUT_WORD (dynobj, s->output_section->vma + s->output_offset, esdl.ld_plt);
2705 PUT_WORD (dynobj, s->_raw_size, esdl.ld_plt_sz);
2707 s = bfd_get_section_by_name (dynobj, ".dynrel");
2708 BFD_ASSERT (s != NULL);
2709 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) == s->_raw_size);
2710 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2713 s = bfd_get_section_by_name (dynobj, ".hash");
2714 BFD_ASSERT (s != NULL);
2715 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2718 s = bfd_get_section_by_name (dynobj, ".dynsym");
2719 BFD_ASSERT (s != NULL);
2720 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2723 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_stab_hash);
2725 PUT_WORD (dynobj, (bfd_vma) sunos_hash_table (info)->bucketcount,
2728 s = bfd_get_section_by_name (dynobj, ".dynstr");
2729 BFD_ASSERT (s != NULL);
2730 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2732 PUT_WORD (dynobj, s->_raw_size, esdl.ld_symb_size);
2734 /* The size of the text area is the size of the .text section
2735 rounded up to a page boundary. FIXME: Should the page size be
2736 conditional on something? */
2738 BFD_ALIGN (obj_textsec (abfd)->_raw_size, 0x2000),
2741 if (! bfd_set_section_contents (abfd, sdyn->output_section, &esdl,
2742 (sdyn->output_offset
2744 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE),
2748 abfd->flags |= DYNAMIC;