1 /* BFD backend for SunOS binaries.
2 Copyright (C) 1990, 91, 92, 93, 94, 1995 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
)));
145 bfd_set_error (bfd_error_no_memory
);
151 info
->canonical_dynsym
= NULL
;
153 info
->canonical_dynrel
= NULL
;
154 obj_aout_dynamic_info (abfd
) = (PTR
) info
;
156 /* This code used to look for the __DYNAMIC symbol to locate the dynamic
158 However this inhibits recovering the dynamic symbols from a
159 stripped object file, so blindly assume that the dynamic linking
160 information is located at the start of the data section.
161 We could verify this assumption later by looking through the dynamic
162 symbols for the __DYNAMIC symbol. */
163 if ((abfd
->flags
& DYNAMIC
) == 0)
165 if (! bfd_get_section_contents (abfd
, obj_datasec (abfd
), (PTR
) &dyninfo
,
166 (file_ptr
) 0, sizeof dyninfo
))
169 dynver
= GET_WORD (abfd
, dyninfo
.ld_version
);
170 if (dynver
!= 2 && dynver
!= 3)
173 dynoff
= GET_WORD (abfd
, dyninfo
.ld
);
175 /* dynoff is a virtual address. It is probably always in the .data
176 section, but this code should work even if it moves. */
177 if (dynoff
< bfd_get_section_vma (abfd
, obj_datasec (abfd
)))
178 dynsec
= obj_textsec (abfd
);
180 dynsec
= obj_datasec (abfd
);
181 dynoff
-= bfd_get_section_vma (abfd
, dynsec
);
182 if (dynoff
> bfd_section_size (abfd
, dynsec
))
185 /* This executable appears to be dynamically linked in a way that we
187 if (! bfd_get_section_contents (abfd
, dynsec
, (PTR
) &linkinfo
, dynoff
,
188 (bfd_size_type
) sizeof linkinfo
))
191 /* Swap in the dynamic link information. */
192 info
->dyninfo
.ld_loaded
= GET_WORD (abfd
, linkinfo
.ld_loaded
);
193 info
->dyninfo
.ld_need
= GET_WORD (abfd
, linkinfo
.ld_need
);
194 info
->dyninfo
.ld_rules
= GET_WORD (abfd
, linkinfo
.ld_rules
);
195 info
->dyninfo
.ld_got
= GET_WORD (abfd
, linkinfo
.ld_got
);
196 info
->dyninfo
.ld_plt
= GET_WORD (abfd
, linkinfo
.ld_plt
);
197 info
->dyninfo
.ld_rel
= GET_WORD (abfd
, linkinfo
.ld_rel
);
198 info
->dyninfo
.ld_hash
= GET_WORD (abfd
, linkinfo
.ld_hash
);
199 info
->dyninfo
.ld_stab
= GET_WORD (abfd
, linkinfo
.ld_stab
);
200 info
->dyninfo
.ld_stab_hash
= GET_WORD (abfd
, linkinfo
.ld_stab_hash
);
201 info
->dyninfo
.ld_buckets
= GET_WORD (abfd
, linkinfo
.ld_buckets
);
202 info
->dyninfo
.ld_symbols
= GET_WORD (abfd
, linkinfo
.ld_symbols
);
203 info
->dyninfo
.ld_symb_size
= GET_WORD (abfd
, linkinfo
.ld_symb_size
);
204 info
->dyninfo
.ld_text
= GET_WORD (abfd
, linkinfo
.ld_text
);
205 info
->dyninfo
.ld_plt_sz
= GET_WORD (abfd
, linkinfo
.ld_plt_sz
);
207 /* Reportedly the addresses need to be offset by the size of the
208 exec header in an NMAGIC file. */
209 if (adata (abfd
).magic
== n_magic
)
211 unsigned long exec_bytes_size
= adata (abfd
).exec_bytes_size
;
213 info
->dyninfo
.ld_need
+= exec_bytes_size
;
214 info
->dyninfo
.ld_rules
+= exec_bytes_size
;
215 info
->dyninfo
.ld_rel
+= exec_bytes_size
;
216 info
->dyninfo
.ld_hash
+= exec_bytes_size
;
217 info
->dyninfo
.ld_stab
+= exec_bytes_size
;
218 info
->dyninfo
.ld_symbols
+= exec_bytes_size
;
221 /* The only way to get the size of the symbol information appears to
222 be to determine the distance between it and the string table. */
223 info
->dynsym_count
= ((info
->dyninfo
.ld_symbols
- info
->dyninfo
.ld_stab
)
224 / EXTERNAL_NLIST_SIZE
);
225 BFD_ASSERT (info
->dynsym_count
* EXTERNAL_NLIST_SIZE
226 == (unsigned long) (info
->dyninfo
.ld_symbols
227 - info
->dyninfo
.ld_stab
));
229 /* Similarly, the relocs end at the hash table. */
230 info
->dynrel_count
= ((info
->dyninfo
.ld_hash
- info
->dyninfo
.ld_rel
)
231 / obj_reloc_entry_size (abfd
));
232 BFD_ASSERT (info
->dynrel_count
* obj_reloc_entry_size (abfd
)
233 == (unsigned long) (info
->dyninfo
.ld_hash
234 - info
->dyninfo
.ld_rel
));
241 /* Return the amount of memory required for the dynamic symbols. */
244 sunos_get_dynamic_symtab_upper_bound (abfd
)
247 struct sunos_dynamic_info
*info
;
249 if (! sunos_read_dynamic_info (abfd
))
252 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
255 bfd_set_error (bfd_error_no_symbols
);
259 return (info
->dynsym_count
+ 1) * sizeof (asymbol
*);
262 /* Read the external dynamic symbols. */
265 sunos_slurp_dynamic_symtab (abfd
)
268 struct sunos_dynamic_info
*info
;
270 /* Get the general dynamic information. */
271 if (obj_aout_dynamic_info (abfd
) == NULL
)
273 if (! sunos_read_dynamic_info (abfd
))
277 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
280 bfd_set_error (bfd_error_no_symbols
);
284 /* Get the dynamic nlist structures. */
285 if (info
->dynsym
== (struct external_nlist
*) NULL
)
287 info
->dynsym
= ((struct external_nlist
*)
290 * EXTERNAL_NLIST_SIZE
)));
291 if (info
->dynsym
== NULL
&& info
->dynsym_count
!= 0)
293 bfd_set_error (bfd_error_no_memory
);
296 if (bfd_seek (abfd
, info
->dyninfo
.ld_stab
, SEEK_SET
) != 0
297 || (bfd_read ((PTR
) info
->dynsym
, info
->dynsym_count
,
298 EXTERNAL_NLIST_SIZE
, abfd
)
299 != info
->dynsym_count
* EXTERNAL_NLIST_SIZE
))
301 if (info
->dynsym
!= NULL
)
303 bfd_release (abfd
, info
->dynsym
);
310 /* Get the dynamic strings. */
311 if (info
->dynstr
== (char *) NULL
)
313 info
->dynstr
= (char *) bfd_alloc (abfd
, info
->dyninfo
.ld_symb_size
);
314 if (info
->dynstr
== NULL
&& info
->dyninfo
.ld_symb_size
!= 0)
316 bfd_set_error (bfd_error_no_memory
);
319 if (bfd_seek (abfd
, info
->dyninfo
.ld_symbols
, SEEK_SET
) != 0
320 || (bfd_read ((PTR
) info
->dynstr
, 1, info
->dyninfo
.ld_symb_size
,
322 != info
->dyninfo
.ld_symb_size
))
324 if (info
->dynstr
!= NULL
)
326 bfd_release (abfd
, info
->dynstr
);
336 /* Read in the dynamic symbols. */
339 sunos_canonicalize_dynamic_symtab (abfd
, storage
)
343 struct sunos_dynamic_info
*info
;
346 if (! sunos_slurp_dynamic_symtab (abfd
))
349 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
351 #ifdef CHECK_DYNAMIC_HASH
352 /* Check my understanding of the dynamic hash table by making sure
353 that each symbol can be located in the hash table. */
355 bfd_size_type table_size
;
359 if (info
->dyninfo
.ld_buckets
> info
->dynsym_count
)
361 table_size
= info
->dyninfo
.ld_stab
- info
->dyninfo
.ld_hash
;
362 table
= (bfd_byte
*) malloc (table_size
);
363 if (table
== NULL
&& table_size
!= 0)
365 if (bfd_seek (abfd
, info
->dyninfo
.ld_hash
, SEEK_SET
) != 0
366 || bfd_read ((PTR
) table
, 1, table_size
, abfd
) != table_size
)
368 for (i
= 0; i
< info
->dynsym_count
; i
++)
373 name
= ((unsigned char *) info
->dynstr
374 + GET_WORD (abfd
, info
->dynsym
[i
].e_strx
));
376 while (*name
!= '\0')
377 hash
= (hash
<< 1) + *name
++;
379 hash
%= info
->dyninfo
.ld_buckets
;
380 while (GET_WORD (abfd
, table
+ hash
* HASH_ENTRY_SIZE
) != i
)
382 hash
= GET_WORD (abfd
,
383 table
+ hash
* HASH_ENTRY_SIZE
+ BYTES_IN_WORD
);
384 if (hash
== 0 || hash
>= table_size
/ HASH_ENTRY_SIZE
)
390 #endif /* CHECK_DYNAMIC_HASH */
392 /* Get the asymbol structures corresponding to the dynamic nlist
394 if (info
->canonical_dynsym
== (aout_symbol_type
*) NULL
)
396 info
->canonical_dynsym
= ((aout_symbol_type
*)
399 * sizeof (aout_symbol_type
))));
400 if (info
->canonical_dynsym
== NULL
&& info
->dynsym_count
!= 0)
402 bfd_set_error (bfd_error_no_memory
);
406 if (! aout_32_translate_symbol_table (abfd
, info
->canonical_dynsym
,
407 info
->dynsym
, info
->dynsym_count
,
409 info
->dyninfo
.ld_symb_size
,
412 if (info
->canonical_dynsym
!= NULL
)
414 bfd_release (abfd
, info
->canonical_dynsym
);
415 info
->canonical_dynsym
= NULL
;
421 /* Return pointers to the dynamic asymbol structures. */
422 for (i
= 0; i
< info
->dynsym_count
; i
++)
423 *storage
++ = (asymbol
*) (info
->canonical_dynsym
+ i
);
426 return info
->dynsym_count
;
429 /* Return the amount of memory required for the dynamic relocs. */
432 sunos_get_dynamic_reloc_upper_bound (abfd
)
435 struct sunos_dynamic_info
*info
;
437 if (! sunos_read_dynamic_info (abfd
))
440 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
443 bfd_set_error (bfd_error_no_symbols
);
447 return (info
->dynrel_count
+ 1) * sizeof (arelent
*);
450 /* Read in the dynamic relocs. */
453 sunos_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
458 struct sunos_dynamic_info
*info
;
461 /* Get the general dynamic information. */
462 if (obj_aout_dynamic_info (abfd
) == (PTR
) NULL
)
464 if (! sunos_read_dynamic_info (abfd
))
468 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
471 bfd_set_error (bfd_error_no_symbols
);
475 /* Get the dynamic reloc information. */
476 if (info
->dynrel
== NULL
)
478 info
->dynrel
= (PTR
) bfd_alloc (abfd
,
480 * obj_reloc_entry_size (abfd
)));
481 if (info
->dynrel
== NULL
&& info
->dynrel_count
!= 0)
483 bfd_set_error (bfd_error_no_memory
);
486 if (bfd_seek (abfd
, info
->dyninfo
.ld_rel
, SEEK_SET
) != 0
487 || (bfd_read ((PTR
) info
->dynrel
, info
->dynrel_count
,
488 obj_reloc_entry_size (abfd
), abfd
)
489 != info
->dynrel_count
* obj_reloc_entry_size (abfd
)))
491 if (info
->dynrel
!= NULL
)
493 bfd_release (abfd
, info
->dynrel
);
500 /* Get the arelent structures corresponding to the dynamic reloc
502 if (info
->canonical_dynrel
== (arelent
*) NULL
)
506 info
->canonical_dynrel
= ((arelent
*)
509 * sizeof (arelent
))));
510 if (info
->canonical_dynrel
== NULL
&& info
->dynrel_count
!= 0)
512 bfd_set_error (bfd_error_no_memory
);
516 to
= info
->canonical_dynrel
;
518 if (obj_reloc_entry_size (abfd
) == RELOC_EXT_SIZE
)
520 register struct reloc_ext_external
*p
;
521 struct reloc_ext_external
*pend
;
523 p
= (struct reloc_ext_external
*) info
->dynrel
;
524 pend
= p
+ info
->dynrel_count
;
525 for (; p
< pend
; p
++, to
++)
526 NAME(aout
,swap_ext_reloc_in
) (abfd
, p
, to
, syms
,
531 register struct reloc_std_external
*p
;
532 struct reloc_std_external
*pend
;
534 p
= (struct reloc_std_external
*) info
->dynrel
;
535 pend
= p
+ info
->dynrel_count
;
536 for (; p
< pend
; p
++, to
++)
537 NAME(aout
,swap_std_reloc_in
) (abfd
, p
, to
, syms
,
542 /* Return pointers to the dynamic arelent structures. */
543 for (i
= 0; i
< info
->dynrel_count
; i
++)
544 *storage
++ = info
->canonical_dynrel
+ i
;
547 return info
->dynrel_count
;
550 /* Code to handle linking of SunOS shared libraries. */
552 /* A SPARC procedure linkage table entry is 12 bytes. The first entry
553 in the table is a jump which is filled in by the runtime linker.
554 The remaining entries are branches back to the first entry,
555 followed by an index into the relocation table encoded to look like
558 #define SPARC_PLT_ENTRY_SIZE (12)
560 static const bfd_byte sparc_plt_first_entry
[SPARC_PLT_ENTRY_SIZE
] =
562 /* sethi %hi(0),%g1; address filled in by runtime linker. */
564 /* jmp %g1; offset filled in by runtime linker. */
570 /* save %sp, -96, %sp */
571 #define SPARC_PLT_ENTRY_WORD0 0x9de3bfa0
572 /* call; address filled in later. */
573 #define SPARC_PLT_ENTRY_WORD1 0x40000000
574 /* sethi; reloc index filled in later. */
575 #define SPARC_PLT_ENTRY_WORD2 0x01000000
577 /* This sequence is used when for the jump table entry to a defined
578 symbol in a complete executable. It is used when linking PIC
579 compiled code which is not being put into a shared library. */
580 /* sethi <address to be filled in later>, %g1 */
581 #define SPARC_PLT_PIC_WORD0 0x03000000
582 /* jmp %g1 + <address to be filled in later> */
583 #define SPARC_PLT_PIC_WORD1 0x81c06000
585 #define SPARC_PLT_PIC_WORD2 0x01000000
587 /* An m68k procedure linkage table entry is 8 bytes. The first entry
588 in the table is a jump which is filled in the by the runtime
589 linker. The remaining entries are branches back to the first
590 entry, followed by a two byte index into the relocation table. */
592 #define M68K_PLT_ENTRY_SIZE (8)
594 static const bfd_byte m68k_plt_first_entry
[M68K_PLT_ENTRY_SIZE
] =
598 /* Filled in by runtime linker with a magic address. */
605 #define M68K_PLT_ENTRY_WORD0 (0x61ff)
606 /* Remaining words filled in later. */
608 /* An entry in the SunOS linker hash table. */
610 struct sunos_link_hash_entry
612 struct aout_link_hash_entry root
;
614 /* If this is a dynamic symbol, this is its index into the dynamic
615 symbol table. This is initialized to -1. As the linker looks at
616 the input files, it changes this to -2 if it will be added to the
617 dynamic symbol table. After all the input files have been seen,
618 the linker will know whether to build a dynamic symbol table; if
619 it does build one, this becomes the index into the table. */
622 /* If this is a dynamic symbol, this is the index of the name in the
623 dynamic symbol string table. */
626 /* The offset into the global offset table used for this symbol. If
627 the symbol does not require a GOT entry, this is 0. */
630 /* The offset into the procedure linkage table used for this symbol.
631 If the symbol does not require a PLT entry, this is 0. */
634 /* Some linker flags. */
636 /* Symbol is referenced by a regular object. */
637 #define SUNOS_REF_REGULAR 01
638 /* Symbol is defined by a regular object. */
639 #define SUNOS_DEF_REGULAR 02
640 /* Symbol is referenced by a dynamic object. */
641 #define SUNOS_REF_DYNAMIC 010
642 /* Symbol is defined by a dynamic object. */
643 #define SUNOS_DEF_DYNAMIC 020
646 /* The SunOS linker hash table. */
648 struct sunos_link_hash_table
650 struct aout_link_hash_table root
;
652 /* The object which holds the dynamic sections. */
655 /* Whether we have created the dynamic sections. */
656 boolean dynamic_sections_created
;
658 /* Whether we need the dynamic sections. */
659 boolean dynamic_sections_needed
;
661 /* The number of dynamic symbols. */
664 /* The number of buckets in the hash table. */
667 /* The list of dynamic objects needed by dynamic objects included in
669 struct bfd_link_needed_list
*needed
;
672 /* Routine to create an entry in an SunOS link hash table. */
674 static struct bfd_hash_entry
*
675 sunos_link_hash_newfunc (entry
, table
, string
)
676 struct bfd_hash_entry
*entry
;
677 struct bfd_hash_table
*table
;
680 struct sunos_link_hash_entry
*ret
= (struct sunos_link_hash_entry
*) entry
;
682 /* Allocate the structure if it has not already been allocated by a
684 if (ret
== (struct sunos_link_hash_entry
*) NULL
)
685 ret
= ((struct sunos_link_hash_entry
*)
686 bfd_hash_allocate (table
, sizeof (struct sunos_link_hash_entry
)));
687 if (ret
== (struct sunos_link_hash_entry
*) NULL
)
689 bfd_set_error (bfd_error_no_memory
);
690 return (struct bfd_hash_entry
*) ret
;
693 /* Call the allocation method of the superclass. */
694 ret
= ((struct sunos_link_hash_entry
*)
695 NAME(aout
,link_hash_newfunc
) ((struct bfd_hash_entry
*) ret
,
699 /* Set local fields. */
701 ret
->dynstr_index
= -1;
707 return (struct bfd_hash_entry
*) ret
;
710 /* Create a SunOS link hash table. */
712 static struct bfd_link_hash_table
*
713 sunos_link_hash_table_create (abfd
)
716 struct sunos_link_hash_table
*ret
;
718 ret
= ((struct sunos_link_hash_table
*)
719 bfd_alloc (abfd
, sizeof (struct sunos_link_hash_table
)));
720 if (ret
== (struct sunos_link_hash_table
*) NULL
)
722 bfd_set_error (bfd_error_no_memory
);
723 return (struct bfd_link_hash_table
*) NULL
;
725 if (! NAME(aout
,link_hash_table_init
) (&ret
->root
, abfd
,
726 sunos_link_hash_newfunc
))
728 bfd_release (abfd
, ret
);
729 return (struct bfd_link_hash_table
*) NULL
;
733 ret
->dynamic_sections_created
= false;
734 ret
->dynamic_sections_needed
= false;
735 ret
->dynsymcount
= 0;
736 ret
->bucketcount
= 0;
739 return &ret
->root
.root
;
742 /* Look up an entry in an SunOS link hash table. */
744 #define sunos_link_hash_lookup(table, string, create, copy, follow) \
745 ((struct sunos_link_hash_entry *) \
746 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
749 /* Traverse a SunOS link hash table. */
751 #define sunos_link_hash_traverse(table, func, info) \
752 (aout_link_hash_traverse \
754 (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
757 /* Get the SunOS link hash table from the info structure. This is
760 #define sunos_hash_table(p) ((struct sunos_link_hash_table *) ((p)->hash))
762 static boolean sunos_scan_dynamic_symbol
763 PARAMS ((struct sunos_link_hash_entry
*, PTR
));
765 /* Create the dynamic sections needed if we are linking against a
766 dynamic object, or if we are linking PIC compiled code. ABFD is a
767 bfd we can attach the dynamic sections to. The linker script will
768 look for these special sections names and put them in the right
769 place in the output file. See include/aout/sun4.h for more details
770 of the dynamic linking information. */
773 sunos_create_dynamic_sections (abfd
, info
, needed
)
775 struct bfd_link_info
*info
;
780 if (! sunos_hash_table (info
)->dynamic_sections_created
)
784 sunos_hash_table (info
)->dynobj
= abfd
;
786 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
788 /* The .dynamic section holds the basic dynamic information: the
789 sun4_dynamic structure, the dynamic debugger information, and
790 the sun4_dynamic_link structure. */
791 s
= bfd_make_section (abfd
, ".dynamic");
793 || ! bfd_set_section_flags (abfd
, s
, flags
)
794 || ! bfd_set_section_alignment (abfd
, s
, 2))
797 /* The .got section holds the global offset table. The address
798 is put in the ld_got field. */
799 s
= bfd_make_section (abfd
, ".got");
801 || ! bfd_set_section_flags (abfd
, s
, flags
)
802 || ! bfd_set_section_alignment (abfd
, s
, 2))
805 /* The .plt section holds the procedure linkage table. The
806 address is put in the ld_plt field. */
807 s
= bfd_make_section (abfd
, ".plt");
809 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
810 || ! bfd_set_section_alignment (abfd
, s
, 2))
813 /* The .dynrel section holds the dynamic relocs. The address is
814 put in the ld_rel field. */
815 s
= bfd_make_section (abfd
, ".dynrel");
817 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
818 || ! bfd_set_section_alignment (abfd
, s
, 2))
821 /* The .hash section holds the dynamic hash table. The address
822 is put in the ld_hash field. */
823 s
= bfd_make_section (abfd
, ".hash");
825 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
826 || ! bfd_set_section_alignment (abfd
, s
, 2))
829 /* The .dynsym section holds the dynamic symbols. The address
830 is put in the ld_stab field. */
831 s
= bfd_make_section (abfd
, ".dynsym");
833 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
834 || ! bfd_set_section_alignment (abfd
, s
, 2))
837 /* The .dynstr section holds the dynamic symbol string table.
838 The address is put in the ld_symbols field. */
839 s
= bfd_make_section (abfd
, ".dynstr");
841 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
842 || ! bfd_set_section_alignment (abfd
, s
, 2))
845 sunos_hash_table (info
)->dynamic_sections_created
= true;
848 if (needed
&& ! sunos_hash_table (info
)->dynamic_sections_needed
)
852 dynobj
= sunos_hash_table (info
)->dynobj
;
854 s
= bfd_get_section_by_name (dynobj
, ".got");
855 s
->_raw_size
= BYTES_IN_WORD
;
857 sunos_hash_table (info
)->dynamic_sections_needed
= true;
863 /* Add dynamic symbols during a link. This is called by the a.out
864 backend linker when it encounters an object with the DYNAMIC flag
868 sunos_add_dynamic_symbols (abfd
, info
, symsp
, sym_countp
, stringsp
)
870 struct bfd_link_info
*info
;
871 struct external_nlist
**symsp
;
872 bfd_size_type
*sym_countp
;
877 struct sunos_dynamic_info
*dinfo
;
880 /* We do not want to include the sections in a dynamic object in the
881 output file. We hack by simply clobbering the list of sections
882 in the BFD. This could be handled more cleanly by, say, a new
883 section flag; the existing SEC_NEVER_LOAD flag is not the one we
884 want, because that one still implies that the section takes up
885 space in the output file. */
886 abfd
->sections
= NULL
;
888 /* The native linker seems to just ignore dynamic objects when -r is
890 if (info
->relocateable
)
893 /* There's no hope of using a dynamic object which does not exactly
894 match the format of the output file. */
895 if (info
->hash
->creator
!= abfd
->xvec
)
897 bfd_set_error (bfd_error_invalid_operation
);
901 /* Make sure we have all the required information. */
902 if (! sunos_create_dynamic_sections (abfd
, info
, true))
905 /* Make sure we have a .need and a .rules sections. These are only
906 needed if there really is a dynamic object in the link, so they
907 are not added by sunos_create_dynamic_sections. */
908 dynobj
= sunos_hash_table (info
)->dynobj
;
909 if (bfd_get_section_by_name (dynobj
, ".need") == NULL
)
911 /* The .need section holds the list of names of shared objets
912 which must be included at runtime. The address of this
913 section is put in the ld_need field. */
914 s
= bfd_make_section (dynobj
, ".need");
916 || ! bfd_set_section_flags (dynobj
, s
,
922 || ! bfd_set_section_alignment (dynobj
, s
, 2))
926 if (bfd_get_section_by_name (dynobj
, ".rules") == NULL
)
928 /* The .rules section holds the path to search for shared
929 objects. The address of this section is put in the ld_rules
931 s
= bfd_make_section (dynobj
, ".rules");
933 || ! bfd_set_section_flags (dynobj
, s
,
939 || ! bfd_set_section_alignment (dynobj
, s
, 2))
943 /* Pick up the dynamic symbols and return them to the caller. */
944 if (! sunos_slurp_dynamic_symtab (abfd
))
947 dinfo
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
948 *symsp
= dinfo
->dynsym
;
949 *sym_countp
= dinfo
->dynsym_count
;
950 *stringsp
= dinfo
->dynstr
;
952 /* Record information about any other objects needed by this one. */
953 need
= dinfo
->dyninfo
.ld_need
;
957 unsigned long name
, flags
;
958 unsigned short major_vno
, minor_vno
;
959 struct bfd_link_needed_list
*needed
, **pp
;
962 if (bfd_seek (abfd
, need
, SEEK_SET
) != 0
963 || bfd_read (buf
, 1, 16, abfd
) != 16)
966 /* For the format of an ld_need entry, see aout/sun4.h. We
967 should probably define structs for this manipulation. */
969 name
= bfd_get_32 (abfd
, buf
);
970 flags
= bfd_get_32 (abfd
, buf
+ 4);
971 major_vno
= bfd_get_16 (abfd
, buf
+ 8);
972 minor_vno
= bfd_get_16 (abfd
, buf
+ 10);
973 need
= bfd_get_32 (abfd
, buf
+ 12);
975 needed
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, sizeof (struct bfd_link_needed_list
));
978 bfd_set_error (bfd_error_no_memory
);
983 /* We return the name as [-l]name[.maj][.min]. */
985 if ((flags
& 0x80000000) != 0)
986 bfd_alloc_grow (abfd
, "-l", 2);
987 if (bfd_seek (abfd
, name
, SEEK_SET
) != 0)
991 if (bfd_read (&b
, 1, 1, abfd
) != 1)
993 bfd_alloc_grow (abfd
, &b
, 1);
1000 sprintf (verbuf
, ".%d", major_vno
);
1001 bfd_alloc_grow (abfd
, verbuf
, strlen (verbuf
));
1004 sprintf (verbuf
, ".%d", minor_vno
);
1005 bfd_alloc_grow (abfd
, verbuf
, strlen (verbuf
));
1008 needed
->name
= bfd_alloc_finish (abfd
);
1009 if (needed
->name
== NULL
)
1011 bfd_set_error (bfd_error_no_memory
);
1015 needed
->next
= NULL
;
1017 for (pp
= &sunos_hash_table (info
)->needed
;
1027 /* Function to add a single symbol to the linker hash table. This is
1028 a wrapper around _bfd_generic_link_add_one_symbol which handles the
1029 tweaking needed for dynamic linking support. */
1032 sunos_add_one_symbol (info
, abfd
, name
, flags
, section
, value
, string
,
1033 copy
, collect
, hashp
)
1034 struct bfd_link_info
*info
;
1043 struct bfd_link_hash_entry
**hashp
;
1045 struct sunos_link_hash_entry
*h
;
1048 if (! sunos_hash_table (info
)->dynamic_sections_created
)
1050 /* We must create the dynamic sections while reading the input
1051 files, even though at this point we don't know if any of the
1052 sections will be needed. This will ensure that the dynamic
1053 sections are mapped to the right output section. It does no
1054 harm to create these sections if they are not needed. */
1055 if (! sunos_create_dynamic_sections (abfd
, info
, false))
1059 h
= sunos_link_hash_lookup (sunos_hash_table (info
), name
, true, copy
,
1065 *hashp
= (struct bfd_link_hash_entry
*) h
;
1067 /* Treat a common symbol in a dynamic object as defined in the .bss
1068 section of the dynamic object. We don't want to allocate space
1069 for it in our process image. */
1070 if ((abfd
->flags
& DYNAMIC
) != 0
1071 && bfd_is_com_section (section
))
1072 section
= obj_bsssec (abfd
);
1074 if (! bfd_is_und_section (section
)
1075 && h
->root
.root
.type
!= bfd_link_hash_new
1076 && h
->root
.root
.type
!= bfd_link_hash_undefined
1077 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1079 /* We are defining the symbol, and it is already defined. This
1080 is a potential multiple definition error. */
1081 if ((abfd
->flags
& DYNAMIC
) != 0)
1083 /* The definition we are adding is from a dynamic object.
1084 We do not want this new definition to override the
1085 existing definition, so we pretend it is just a
1087 section
= bfd_und_section_ptr
;
1089 else if (h
->root
.root
.type
== bfd_link_hash_defined
1090 && h
->root
.root
.u
.def
.section
->owner
!= NULL
1091 && (h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
) != 0)
1093 /* The existing definition is from a dynamic object. We
1094 want to override it with the definition we just found.
1095 Clobber the existing definition. */
1096 h
->root
.root
.type
= bfd_link_hash_new
;
1098 else if (h
->root
.root
.type
== bfd_link_hash_common
1099 && (h
->root
.root
.u
.c
.p
->section
->owner
->flags
& DYNAMIC
) != 0)
1101 /* The existing definition is from a dynamic object. We
1102 want to override it with the definition we just found.
1103 Clobber the existing definition. We can't set it to new,
1104 because it is on the undefined list. */
1105 h
->root
.root
.type
= bfd_link_hash_undefined
;
1106 h
->root
.root
.u
.undef
.abfd
= h
->root
.root
.u
.c
.p
->section
->owner
;
1110 /* Do the usual procedure for adding a symbol. */
1111 if (! _bfd_generic_link_add_one_symbol (info
, abfd
, name
, flags
, section
,
1112 value
, string
, copy
, collect
,
1116 if (abfd
->xvec
== info
->hash
->creator
)
1118 /* Set a flag in the hash table entry indicating the type of
1119 reference or definition we just found. Keep a count of the
1120 number of dynamic symbols we find. A dynamic symbol is one
1121 which is referenced or defined by both a regular object and a
1123 if ((abfd
->flags
& DYNAMIC
) == 0)
1125 if (bfd_is_und_section (section
))
1126 new_flag
= SUNOS_REF_REGULAR
;
1128 new_flag
= SUNOS_DEF_REGULAR
;
1132 if (bfd_is_und_section (section
))
1133 new_flag
= SUNOS_REF_DYNAMIC
;
1135 new_flag
= SUNOS_DEF_DYNAMIC
;
1137 h
->flags
|= new_flag
;
1139 if (h
->dynindx
== -1
1140 && (h
->flags
& (SUNOS_DEF_REGULAR
| SUNOS_REF_REGULAR
)) != 0)
1142 ++sunos_hash_table (info
)->dynsymcount
;
1150 /* Return the list of objects needed by BFD. */
1153 struct bfd_link_needed_list
*
1154 bfd_sunos_get_needed_list (abfd
, info
)
1156 struct bfd_link_info
*info
;
1158 if (info
->hash
->creator
!= &MY(xvec
))
1160 return sunos_hash_table (info
)->needed
;
1163 /* Record an assignment made to a symbol by a linker script. We need
1164 this in case some dynamic object refers to this symbol. */
1167 bfd_sunos_record_link_assignment (output_bfd
, info
, name
)
1169 struct bfd_link_info
*info
;
1172 struct sunos_link_hash_entry
*h
;
1174 if (output_bfd
->xvec
!= &MY(vec
))
1177 /* This is called after we have examined all the input objects. If
1178 the symbol does not exist, it merely means that no object refers
1179 to it, and we can just ignore it at this point. */
1180 h
= sunos_link_hash_lookup (sunos_hash_table (info
), name
,
1181 false, false, false);
1185 /* In a shared library, the __DYNAMIC symbol does not appear in the
1186 dynamic symbol table. */
1187 if (! info
->shared
|| strcmp (name
, "__DYNAMIC") != 0)
1189 h
->flags
|= SUNOS_DEF_REGULAR
;
1191 if (h
->dynindx
== -1)
1193 ++sunos_hash_table (info
)->dynsymcount
;
1201 /* Set up the sizes and contents of the dynamic sections created in
1202 sunos_add_dynamic_symbols. This is called by the SunOS linker
1203 emulation before_allocation routine. We must set the sizes of the
1204 sections before the linker sets the addresses of the various
1205 sections. This unfortunately requires reading all the relocs so
1206 that we can work out which ones need to become dynamic relocs. If
1207 info->keep_memory is true, we keep the relocs in memory; otherwise,
1208 we discard them, and will read them again later. */
1211 bfd_sunos_size_dynamic_sections (output_bfd
, info
, sdynptr
, sneedptr
,
1214 struct bfd_link_info
*info
;
1216 asection
**sneedptr
;
1217 asection
**srulesptr
;
1221 struct sunos_link_hash_entry
*h
;
1232 if (output_bfd
->xvec
!= &MY(vec
))
1235 /* Look through all the input BFD's and read their relocs. It would
1236 be better if we didn't have to do this, but there is no other way
1237 to determine the number of dynamic relocs we need, and, more
1238 importantly, there is no other way to know which symbols should
1239 get an entry in the procedure linkage table. */
1240 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
1242 if ((sub
->flags
& DYNAMIC
) == 0
1243 && sub
->xvec
== output_bfd
->xvec
)
1245 if (! sunos_scan_relocs (info
, sub
, obj_textsec (sub
),
1246 exec_hdr (sub
)->a_trsize
)
1247 || ! sunos_scan_relocs (info
, sub
, obj_datasec (sub
),
1248 exec_hdr (sub
)->a_drsize
))
1253 dynobj
= sunos_hash_table (info
)->dynobj
;
1254 dynsymcount
= sunos_hash_table (info
)->dynsymcount
;
1256 /* If there were no dynamic objects in the link, and we don't need
1257 to build a global offset table, there is nothing to do here. */
1258 if (! sunos_hash_table (info
)->dynamic_sections_needed
)
1261 /* If __GLOBAL_OFFSET_TABLE_ was mentioned, define it. */
1262 h
= sunos_link_hash_lookup (sunos_hash_table (info
),
1263 "__GLOBAL_OFFSET_TABLE_", false, false, false);
1264 if (h
!= NULL
&& (h
->flags
& SUNOS_REF_REGULAR
) != 0)
1266 h
->flags
|= SUNOS_DEF_REGULAR
;
1267 if (h
->dynindx
== -1)
1269 ++sunos_hash_table (info
)->dynsymcount
;
1272 h
->root
.root
.type
= bfd_link_hash_defined
;
1273 h
->root
.root
.u
.def
.section
= bfd_get_section_by_name (dynobj
, ".got");
1274 h
->root
.root
.u
.def
.value
= 0;
1277 /* The .dynamic section is always the same size. */
1278 s
= bfd_get_section_by_name (dynobj
, ".dynamic");
1279 BFD_ASSERT (s
!= NULL
);
1280 s
->_raw_size
= (sizeof (struct external_sun4_dynamic
)
1281 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
1282 + sizeof (struct external_sun4_dynamic_link
));
1284 /* Set the size of the .dynsym and .hash sections. We counted the
1285 number of dynamic symbols as we read the input files. We will
1286 build the dynamic symbol table (.dynsym) and the hash table
1287 (.hash) when we build the final symbol table, because until then
1288 we do not know the correct value to give the symbols. We build
1289 the dynamic symbol string table (.dynstr) in a traversal of the
1290 symbol table using sunos_scan_dynamic_symbol. */
1291 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1292 BFD_ASSERT (s
!= NULL
);
1293 s
->_raw_size
= dynsymcount
* sizeof (struct external_nlist
);
1294 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1295 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1297 bfd_set_error (bfd_error_no_memory
);
1301 /* The number of buckets is just the number of symbols divided by
1302 four. To compute the final size of the hash table, we must
1303 actually compute the hash table. Normally we need exactly as
1304 many entries in the hash table as there are dynamic symbols, but
1305 if some of the buckets are not used we will need additional
1306 entries. In the worst case, every symbol will hash to the same
1307 bucket, and we will need BUCKETCOUNT - 1 extra entries. */
1308 if (dynsymcount
>= 4)
1309 bucketcount
= dynsymcount
/ 4;
1310 else if (dynsymcount
> 0)
1311 bucketcount
= dynsymcount
;
1314 s
= bfd_get_section_by_name (dynobj
, ".hash");
1315 BFD_ASSERT (s
!= NULL
);
1316 hashalloc
= (dynsymcount
+ bucketcount
- 1) * HASH_ENTRY_SIZE
;
1317 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, hashalloc
);
1318 if (s
->contents
== NULL
&& dynsymcount
> 0)
1320 bfd_set_error (bfd_error_no_memory
);
1323 memset (s
->contents
, 0, hashalloc
);
1324 for (i
= 0; i
< bucketcount
; i
++)
1325 PUT_WORD (output_bfd
, (bfd_vma
) -1, s
->contents
+ i
* HASH_ENTRY_SIZE
);
1326 s
->_raw_size
= bucketcount
* HASH_ENTRY_SIZE
;
1328 sunos_hash_table (info
)->bucketcount
= bucketcount
;
1330 /* Scan all the symbols, place them in the dynamic symbol table, and
1331 build the dynamic hash table. We reuse dynsymcount as a counter
1332 for the number of symbols we have added so far. */
1333 sunos_hash_table (info
)->dynsymcount
= 0;
1334 sunos_link_hash_traverse (sunos_hash_table (info
),
1335 sunos_scan_dynamic_symbol
,
1337 BFD_ASSERT (sunos_hash_table (info
)->dynsymcount
== dynsymcount
);
1339 /* The SunOS native linker seems to align the total size of the
1340 symbol strings to a multiple of 8. I don't know if this is
1341 important, but it can't hurt much. */
1342 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1343 BFD_ASSERT (s
!= NULL
);
1344 if ((s
->_raw_size
& 7) != 0)
1349 add
= 8 - (s
->_raw_size
& 7);
1350 contents
= (bfd_byte
*) realloc (s
->contents
,
1351 (size_t) (s
->_raw_size
+ add
));
1352 if (contents
== NULL
)
1354 bfd_set_error (bfd_error_no_memory
);
1357 memset (contents
+ s
->_raw_size
, 0, (size_t) add
);
1358 s
->contents
= contents
;
1359 s
->_raw_size
+= add
;
1362 /* Now that we have worked out the sizes of the procedure linkage
1363 table and the dynamic relocs, allocate storage for them. */
1364 s
= bfd_get_section_by_name (dynobj
, ".plt");
1365 BFD_ASSERT (s
!= NULL
);
1366 if (s
->_raw_size
!= 0)
1368 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
1369 if (s
->contents
== NULL
)
1371 bfd_set_error (bfd_error_no_memory
);
1375 /* Fill in the first entry in the table. */
1376 switch (bfd_get_arch (dynobj
))
1378 case bfd_arch_sparc
:
1379 memcpy (s
->contents
, sparc_plt_first_entry
, SPARC_PLT_ENTRY_SIZE
);
1383 memcpy (s
->contents
, m68k_plt_first_entry
, M68K_PLT_ENTRY_SIZE
);
1391 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
1392 if (s
->_raw_size
!= 0)
1394 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
1395 if (s
->contents
== NULL
)
1397 bfd_set_error (bfd_error_no_memory
);
1401 /* We use the reloc_count field to keep track of how many of the
1402 relocs we have output so far. */
1405 /* Make space for the global offset table. */
1406 s
= bfd_get_section_by_name (dynobj
, ".got");
1407 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
1408 if (s
->contents
== NULL
)
1410 bfd_set_error (bfd_error_no_memory
);
1414 *sdynptr
= bfd_get_section_by_name (dynobj
, ".dynamic");
1415 *sneedptr
= bfd_get_section_by_name (dynobj
, ".need");
1416 *srulesptr
= bfd_get_section_by_name (dynobj
, ".rules");
1421 /* Scan the relocs for an input section. */
1424 sunos_scan_relocs (info
, abfd
, sec
, rel_size
)
1425 struct bfd_link_info
*info
;
1428 bfd_size_type rel_size
;
1431 PTR free_relocs
= NULL
;
1436 if (! info
->keep_memory
)
1437 relocs
= free_relocs
= malloc ((size_t) rel_size
);
1440 struct aout_section_data_struct
*n
;
1442 n
= ((struct aout_section_data_struct
*)
1443 bfd_alloc (abfd
, sizeof (struct aout_section_data_struct
)));
1448 set_aout_section_data (sec
, n
);
1449 relocs
= malloc ((size_t) rel_size
);
1450 aout_section_data (sec
)->relocs
= relocs
;
1455 bfd_set_error (bfd_error_no_memory
);
1459 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
1460 || bfd_read (relocs
, 1, rel_size
, abfd
) != rel_size
)
1463 if (obj_reloc_entry_size (abfd
) == RELOC_STD_SIZE
)
1465 if (! sunos_scan_std_relocs (info
, abfd
, sec
,
1466 (struct reloc_std_external
*) relocs
,
1472 if (! sunos_scan_ext_relocs (info
, abfd
, sec
,
1473 (struct reloc_ext_external
*) relocs
,
1478 if (free_relocs
!= NULL
)
1484 if (free_relocs
!= NULL
)
1489 /* Scan the relocs for an input section using standard relocs. We
1490 need to figure out what to do for each reloc against a dynamic
1491 symbol. If the symbol is in the .text section, an entry is made in
1492 the procedure linkage table. Note that this will do the wrong
1493 thing if the symbol is actually data; I don't think the Sun 3
1494 native linker handles this case correctly either. If the symbol is
1495 not in the .text section, we must preserve the reloc as a dynamic
1496 reloc. FIXME: We should also handle the PIC relocs here by
1497 building global offset table entries. */
1500 sunos_scan_std_relocs (info
, abfd
, sec
, relocs
, rel_size
)
1501 struct bfd_link_info
*info
;
1504 const struct reloc_std_external
*relocs
;
1505 bfd_size_type rel_size
;
1508 asection
*splt
= NULL
;
1509 asection
*srel
= NULL
;
1510 struct sunos_link_hash_entry
**sym_hashes
;
1511 const struct reloc_std_external
*rel
, *relend
;
1513 /* We only know how to handle m68k plt entries. */
1514 if (bfd_get_arch (abfd
) != bfd_arch_m68k
)
1516 bfd_set_error (bfd_error_invalid_target
);
1522 sym_hashes
= (struct sunos_link_hash_entry
**) obj_aout_sym_hashes (abfd
);
1524 relend
= relocs
+ rel_size
/ RELOC_STD_SIZE
;
1525 for (rel
= relocs
; rel
< relend
; rel
++)
1528 struct sunos_link_hash_entry
*h
;
1530 /* We only want relocs against external symbols. */
1531 if (abfd
->xvec
->header_byteorder_big_p
)
1533 if ((rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
) == 0)
1538 if ((rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
) == 0)
1542 /* Get the symbol index. */
1543 if (abfd
->xvec
->header_byteorder_big_p
)
1544 r_index
= ((rel
->r_index
[0] << 16)
1545 | (rel
->r_index
[1] << 8)
1548 r_index
= ((rel
->r_index
[2] << 16)
1549 | (rel
->r_index
[1] << 8)
1552 /* Get the hash table entry. */
1553 h
= sym_hashes
[r_index
];
1556 /* This should not normally happen, but it will in any case
1557 be caught in the relocation phase. */
1561 /* At this point common symbols have already been allocated, so
1562 we don't have to worry about them. We need to consider that
1563 we may have already seen this symbol and marked it undefined;
1564 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1566 if (h
->root
.root
.type
!= bfd_link_hash_defined
1567 && h
->root
.root
.type
!= bfd_link_hash_defweak
1568 && h
->root
.root
.type
!= bfd_link_hash_undefined
)
1571 if ((h
->flags
& SUNOS_DEF_DYNAMIC
) == 0
1572 || (h
->flags
& SUNOS_DEF_REGULAR
) != 0)
1577 if (! sunos_create_dynamic_sections (abfd
, info
, true))
1579 dynobj
= sunos_hash_table (info
)->dynobj
;
1580 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1581 srel
= bfd_get_section_by_name (dynobj
, ".dynrel");
1582 BFD_ASSERT (splt
!= NULL
&& srel
!= NULL
);
1585 BFD_ASSERT ((h
->flags
& SUNOS_REF_REGULAR
) != 0);
1586 BFD_ASSERT (h
->plt_offset
!= 0
1587 || ((h
->root
.root
.type
== bfd_link_hash_defined
1588 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1589 ? (h
->root
.root
.u
.def
.section
->owner
->flags
1591 : (h
->root
.root
.u
.undef
.abfd
->flags
& DYNAMIC
) != 0));
1593 /* This reloc is against a symbol defined only by a dynamic
1596 if (h
->root
.root
.type
== bfd_link_hash_undefined
)
1598 /* Presumably this symbol was marked as being undefined by
1599 an earlier reloc. */
1600 srel
->_raw_size
+= RELOC_STD_SIZE
;
1602 else if ((h
->root
.root
.u
.def
.section
->flags
& SEC_CODE
) == 0)
1606 /* This reloc is not in the .text section. It must be
1607 copied into the dynamic relocs. We mark the symbol as
1609 srel
->_raw_size
+= RELOC_STD_SIZE
;
1610 sub
= h
->root
.root
.u
.def
.section
->owner
;
1611 h
->root
.root
.type
= bfd_link_hash_undefined
;
1612 h
->root
.root
.u
.undef
.abfd
= sub
;
1616 /* This symbol is in the .text section. We must give it an
1617 entry in the procedure linkage table, if we have not
1618 already done so. We change the definition of the symbol
1619 to the .plt section; this will cause relocs against it to
1620 be handled correctly. */
1621 if (h
->plt_offset
== 0)
1623 if (splt
->_raw_size
== 0)
1624 splt
->_raw_size
= M68K_PLT_ENTRY_SIZE
;
1625 h
->plt_offset
= splt
->_raw_size
;
1627 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0)
1629 h
->root
.root
.u
.def
.section
= splt
;
1630 h
->root
.root
.u
.def
.value
= splt
->_raw_size
;
1633 splt
->_raw_size
+= M68K_PLT_ENTRY_SIZE
;
1635 /* We may also need a dynamic reloc entry. */
1636 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0)
1637 srel
->_raw_size
+= RELOC_STD_SIZE
;
1645 /* Scan the relocs for an input section using extended relocs. We
1646 need to figure out what to do for each reloc against a dynamic
1647 symbol. If the reloc is a WDISP30, and the symbol is in the .text
1648 section, an entry is made in the procedure linkage table.
1649 Otherwise, we must preserve the reloc as a dynamic reloc. */
1652 sunos_scan_ext_relocs (info
, abfd
, sec
, relocs
, rel_size
)
1653 struct bfd_link_info
*info
;
1656 const struct reloc_ext_external
*relocs
;
1657 bfd_size_type rel_size
;
1660 struct sunos_link_hash_entry
**sym_hashes
;
1661 const struct reloc_ext_external
*rel
, *relend
;
1662 asection
*splt
= NULL
;
1663 asection
*sgot
= NULL
;
1664 asection
*srel
= NULL
;
1666 /* We only know how to handle SPARC plt entries. */
1667 if (bfd_get_arch (abfd
) != bfd_arch_sparc
)
1669 bfd_set_error (bfd_error_invalid_target
);
1675 sym_hashes
= (struct sunos_link_hash_entry
**) obj_aout_sym_hashes (abfd
);
1677 relend
= relocs
+ rel_size
/ RELOC_EXT_SIZE
;
1678 for (rel
= relocs
; rel
< relend
; rel
++)
1680 unsigned int r_index
;
1683 struct sunos_link_hash_entry
*h
= NULL
;
1685 /* Swap in the reloc information. */
1686 if (abfd
->xvec
->header_byteorder_big_p
)
1688 r_index
= ((rel
->r_index
[0] << 16)
1689 | (rel
->r_index
[1] << 8)
1691 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
1692 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
1693 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
1697 r_index
= ((rel
->r_index
[2] << 16)
1698 | (rel
->r_index
[1] << 8)
1700 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
1701 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
1702 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
1707 h
= sym_hashes
[r_index
];
1710 /* This should not normally happen, but it will in any
1711 case be caught in the relocation phase. */
1716 /* If this is a base relative reloc, we need to make an entry in
1717 the .got section. */
1718 if (r_type
== RELOC_BASE10
1719 || r_type
== RELOC_BASE13
1720 || r_type
== RELOC_BASE22
)
1724 if (! sunos_create_dynamic_sections (abfd
, info
, true))
1726 dynobj
= sunos_hash_table (info
)->dynobj
;
1727 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1728 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1729 srel
= bfd_get_section_by_name (dynobj
, ".dynrel");
1730 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
1735 if (h
->got_offset
!= 0)
1738 h
->got_offset
= sgot
->_raw_size
;
1742 if (r_index
>= bfd_get_symcount (abfd
))
1744 /* This is abnormal, but should be caught in the
1745 relocation phase. */
1749 if (adata (abfd
).local_got_offsets
== NULL
)
1751 adata (abfd
).local_got_offsets
=
1752 (bfd_vma
*) bfd_zalloc (abfd
,
1753 (bfd_get_symcount (abfd
)
1754 * sizeof (bfd_vma
)));
1755 if (adata (abfd
).local_got_offsets
== NULL
)
1757 bfd_set_error (bfd_error_no_memory
);
1762 if (adata (abfd
).local_got_offsets
[r_index
] != 0)
1765 adata (abfd
).local_got_offsets
[r_index
] = sgot
->_raw_size
;
1768 sgot
->_raw_size
+= BYTES_IN_WORD
;
1770 /* If we are making a shared library, or if the symbol is
1771 defined by a dynamic object, we will need a dynamic reloc
1775 && (h
->flags
& SUNOS_DEF_DYNAMIC
) != 0
1776 && (h
->flags
& SUNOS_DEF_REGULAR
) == 0))
1777 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1782 /* Otherwise, we are only interested in relocs against symbols
1783 defined in dynamic objects but not in regular objects. We
1784 only need to consider relocs against external symbols. */
1787 /* But, if we are creating a shared library, we need to
1788 generate an absolute reloc. */
1793 if (! sunos_create_dynamic_sections (abfd
, info
, true))
1795 dynobj
= sunos_hash_table (info
)->dynobj
;
1796 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1797 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1798 srel
= bfd_get_section_by_name (dynobj
, ".dynrel");
1799 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
1802 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1808 /* At this point common symbols have already been allocated, so
1809 we don't have to worry about them. We need to consider that
1810 we may have already seen this symbol and marked it undefined;
1811 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1813 if (h
->root
.root
.type
!= bfd_link_hash_defined
1814 && h
->root
.root
.type
!= bfd_link_hash_defweak
1815 && h
->root
.root
.type
!= bfd_link_hash_undefined
)
1818 if (r_type
!= RELOC_JMP_TBL
1820 && ((h
->flags
& SUNOS_DEF_DYNAMIC
) == 0
1821 || (h
->flags
& SUNOS_DEF_REGULAR
) != 0))
1824 if (strcmp (h
->root
.root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
1829 if (! sunos_create_dynamic_sections (abfd
, info
, true))
1831 dynobj
= sunos_hash_table (info
)->dynobj
;
1832 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1833 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1834 srel
= bfd_get_section_by_name (dynobj
, ".dynrel");
1835 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
1838 BFD_ASSERT (r_type
== RELOC_JMP_TBL
1839 || (h
->flags
& SUNOS_REF_REGULAR
) != 0);
1840 BFD_ASSERT (r_type
== RELOC_JMP_TBL
1842 || h
->plt_offset
!= 0
1843 || ((h
->root
.root
.type
== bfd_link_hash_defined
1844 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1845 ? (h
->root
.root
.u
.def
.section
->owner
->flags
1847 : (h
->root
.root
.u
.undef
.abfd
->flags
& DYNAMIC
) != 0));
1849 /* This reloc is against a symbol defined only by a dynamic
1850 object, or it is a jump table reloc from PIC compiled code. */
1852 if (r_type
!= RELOC_JMP_TBL
1853 && h
->root
.root
.type
== bfd_link_hash_undefined
)
1855 /* Presumably this symbol was marked as being undefined by
1856 an earlier reloc. */
1857 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1859 else if (r_type
!= RELOC_JMP_TBL
1860 && (h
->root
.root
.u
.def
.section
->flags
& SEC_CODE
) == 0)
1864 /* This reloc is not in the .text section. It must be
1865 copied into the dynamic relocs. We mark the symbol as
1867 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1868 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0)
1870 sub
= h
->root
.root
.u
.def
.section
->owner
;
1871 h
->root
.root
.type
= bfd_link_hash_undefined
;
1872 h
->root
.root
.u
.undef
.abfd
= sub
;
1877 /* This symbol is in the .text section. We must give it an
1878 entry in the procedure linkage table, if we have not
1879 already done so. We change the definition of the symbol
1880 to the .plt section; this will cause relocs against it to
1881 be handled correctly. */
1882 if (h
->plt_offset
== 0)
1884 if (splt
->_raw_size
== 0)
1885 splt
->_raw_size
= SPARC_PLT_ENTRY_SIZE
;
1886 h
->plt_offset
= splt
->_raw_size
;
1888 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0)
1890 if (h
->root
.root
.type
== bfd_link_hash_undefined
)
1891 h
->root
.root
.type
= bfd_link_hash_defined
;
1892 h
->root
.root
.u
.def
.section
= splt
;
1893 h
->root
.root
.u
.def
.value
= splt
->_raw_size
;
1896 splt
->_raw_size
+= SPARC_PLT_ENTRY_SIZE
;
1898 /* We will also need a dynamic reloc entry, unless this
1899 is a JMP_TBL reloc produced by linking PIC compiled
1900 code, and we are not making a shared library. */
1901 if (info
->shared
|| (h
->flags
& SUNOS_DEF_REGULAR
) == 0)
1902 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1905 /* If we are creating a shared library, we need to copy over
1906 any reloc other than a jump table reloc. */
1907 if (info
->shared
&& r_type
!= RELOC_JMP_TBL
)
1908 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1915 /* Build the hash table of dynamic symbols, and to mark as written all
1916 symbols from dynamic objects which we do not plan to write out. */
1919 sunos_scan_dynamic_symbol (h
, data
)
1920 struct sunos_link_hash_entry
*h
;
1923 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
1925 /* Set the written flag for symbols we do not want to write out as
1926 part of the regular symbol table. This is all symbols which are
1927 not defined in a regular object file. For some reason symbols
1928 which are referenced by a regular object and defined by a dynamic
1929 object do not seem to show up in the regular symbol table. */
1930 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0
1931 && strcmp (h
->root
.root
.root
.string
, "__DYNAMIC") != 0)
1932 h
->root
.written
= true;
1934 /* If this symbol is defined by a dynamic object and referenced by a
1935 regular object, see whether we gave it a reasonable value while
1936 scanning the relocs. */
1938 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0
1939 && (h
->flags
& SUNOS_DEF_DYNAMIC
) != 0
1940 && (h
->flags
& SUNOS_REF_REGULAR
) != 0)
1942 if ((h
->root
.root
.type
== bfd_link_hash_defined
1943 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1944 && ((h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
) != 0)
1945 && h
->root
.root
.u
.def
.section
->output_section
== NULL
)
1949 /* This symbol is currently defined in a dynamic section
1950 which is not being put into the output file. This
1951 implies that there is no reloc against the symbol. I'm
1952 not sure why this case would ever occur. In any case, we
1953 change the symbol to be undefined. */
1954 sub
= h
->root
.root
.u
.def
.section
->owner
;
1955 h
->root
.root
.type
= bfd_link_hash_undefined
;
1956 h
->root
.root
.u
.undef
.abfd
= sub
;
1960 /* If this symbol is defined or referenced by a regular file, add it
1961 to the dynamic symbols. */
1962 if ((h
->flags
& (SUNOS_DEF_REGULAR
| SUNOS_REF_REGULAR
)) != 0)
1967 unsigned char *name
;
1971 BFD_ASSERT (h
->dynindx
== -2);
1973 dynobj
= sunos_hash_table (info
)->dynobj
;
1975 h
->dynindx
= sunos_hash_table (info
)->dynsymcount
;
1976 ++sunos_hash_table (info
)->dynsymcount
;
1978 len
= strlen (h
->root
.root
.root
.string
);
1980 /* We don't bother to construct a BFD hash table for the strings
1981 which are the names of the dynamic symbols. Using a hash
1982 table for the regular symbols is beneficial, because the
1983 regular symbols includes the debugging symbols, which have
1984 long names and are often duplicated in several object files.
1985 There are no debugging symbols in the dynamic symbols. */
1986 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1987 BFD_ASSERT (s
!= NULL
);
1988 if (s
->contents
== NULL
)
1989 contents
= (bfd_byte
*) malloc (len
+ 1);
1991 contents
= (bfd_byte
*) realloc (s
->contents
,
1992 (size_t) (s
->_raw_size
+ len
+ 1));
1993 if (contents
== NULL
)
1995 bfd_set_error (bfd_error_no_memory
);
1998 s
->contents
= contents
;
2000 h
->dynstr_index
= s
->_raw_size
;
2001 strcpy (contents
+ s
->_raw_size
, h
->root
.root
.root
.string
);
2002 s
->_raw_size
+= len
+ 1;
2004 /* Add it to the dynamic hash table. */
2005 name
= (unsigned char *) h
->root
.root
.root
.string
;
2007 while (*name
!= '\0')
2008 hash
= (hash
<< 1) + *name
++;
2010 hash
%= sunos_hash_table (info
)->bucketcount
;
2012 s
= bfd_get_section_by_name (dynobj
, ".hash");
2013 BFD_ASSERT (s
!= NULL
);
2015 if (GET_SWORD (dynobj
, s
->contents
+ hash
* HASH_ENTRY_SIZE
) == -1)
2016 PUT_WORD (dynobj
, h
->dynindx
, s
->contents
+ hash
* HASH_ENTRY_SIZE
);
2021 next
= GET_WORD (dynobj
,
2023 + hash
* HASH_ENTRY_SIZE
2025 PUT_WORD (dynobj
, s
->_raw_size
/ HASH_ENTRY_SIZE
,
2026 s
->contents
+ hash
* HASH_ENTRY_SIZE
+ BYTES_IN_WORD
);
2027 PUT_WORD (dynobj
, h
->dynindx
, s
->contents
+ s
->_raw_size
);
2028 PUT_WORD (dynobj
, next
, s
->contents
+ s
->_raw_size
+ BYTES_IN_WORD
);
2029 s
->_raw_size
+= HASH_ENTRY_SIZE
;
2036 /* Link a dynamic object. We actually don't have anything to do at
2037 this point. This entry point exists to prevent the regular linker
2038 code from doing anything with the object. */
2042 sunos_link_dynamic_object (info
, abfd
)
2043 struct bfd_link_info
*info
;
2049 /* Write out a dynamic symbol. This is called by the final traversal
2050 over the symbol table. */
2053 sunos_write_dynamic_symbol (output_bfd
, info
, harg
)
2055 struct bfd_link_info
*info
;
2056 struct aout_link_hash_entry
*harg
;
2058 struct sunos_link_hash_entry
*h
= (struct sunos_link_hash_entry
*) harg
;
2062 struct external_nlist
*outsym
;
2067 switch (h
->root
.root
.type
)
2070 case bfd_link_hash_new
:
2072 /* Avoid variable not initialized warnings. */
2074 case bfd_link_hash_undefined
:
2075 type
= N_UNDF
| N_EXT
;
2078 case bfd_link_hash_defined
:
2079 case bfd_link_hash_defweak
:
2082 asection
*output_section
;
2084 sec
= h
->root
.root
.u
.def
.section
;
2085 output_section
= sec
->output_section
;
2086 BFD_ASSERT (bfd_is_abs_section (output_section
)
2087 || output_section
->owner
== output_bfd
);
2088 if (h
->plt_offset
!= 0
2089 && (h
->flags
& SUNOS_DEF_REGULAR
) == 0)
2091 type
= N_UNDF
| N_EXT
;
2096 if (output_section
== obj_textsec (output_bfd
))
2097 type
= (h
->root
.root
.type
== bfd_link_hash_defined
2100 else if (output_section
== obj_datasec (output_bfd
))
2101 type
= (h
->root
.root
.type
== bfd_link_hash_defined
2104 else if (output_section
== obj_bsssec (output_bfd
))
2105 type
= (h
->root
.root
.type
== bfd_link_hash_defined
2109 type
= (h
->root
.root
.type
== bfd_link_hash_defined
2113 val
= (h
->root
.root
.u
.def
.value
2114 + output_section
->vma
2115 + sec
->output_offset
);
2119 case bfd_link_hash_common
:
2120 type
= N_UNDF
| N_EXT
;
2121 val
= h
->root
.root
.u
.c
.size
;
2123 case bfd_link_hash_undefweak
:
2127 case bfd_link_hash_indirect
:
2128 case bfd_link_hash_warning
:
2129 /* FIXME: Ignore these for now. The circumstances under which
2130 they should be written out are not clear to me. */
2134 s
= bfd_get_section_by_name (sunos_hash_table (info
)->dynobj
, ".dynsym");
2135 BFD_ASSERT (s
!= NULL
);
2136 outsym
= ((struct external_nlist
*)
2137 (s
->contents
+ h
->dynindx
* EXTERNAL_NLIST_SIZE
));
2139 bfd_h_put_8 (output_bfd
, type
, outsym
->e_type
);
2140 bfd_h_put_8 (output_bfd
, 0, outsym
->e_other
);
2142 /* FIXME: The native linker doesn't use 0 for desc. It seems to use
2143 one less than the desc value in the shared library, although that
2145 bfd_h_put_16 (output_bfd
, 0, outsym
->e_desc
);
2147 PUT_WORD (output_bfd
, h
->dynstr_index
, outsym
->e_strx
);
2148 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
2150 /* If this symbol is in the procedure linkage table, fill in the
2152 if (h
->plt_offset
!= 0)
2160 dynobj
= sunos_hash_table (info
)->dynobj
;
2161 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2162 p
= splt
->contents
+ h
->plt_offset
;
2164 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
2166 r_address
= (splt
->output_section
->vma
2167 + splt
->output_offset
2170 switch (bfd_get_arch (output_bfd
))
2172 case bfd_arch_sparc
:
2173 if (info
->shared
|| (h
->flags
& SUNOS_DEF_REGULAR
) == 0)
2175 bfd_put_32 (output_bfd
, SPARC_PLT_ENTRY_WORD0
, p
);
2176 bfd_put_32 (output_bfd
,
2177 (SPARC_PLT_ENTRY_WORD1
2178 + (((- (h
->plt_offset
+ 4) >> 2)
2181 bfd_put_32 (output_bfd
, SPARC_PLT_ENTRY_WORD2
+ s
->reloc_count
,
2188 val
= (h
->root
.root
.u
.def
.section
->output_section
->vma
2189 + h
->root
.root
.u
.def
.section
->output_offset
2190 + h
->root
.root
.u
.def
.value
);
2191 bfd_put_32 (output_bfd
,
2192 SPARC_PLT_PIC_WORD0
+ ((val
>> 10) & 0x3fffff),
2194 bfd_put_32 (output_bfd
,
2195 SPARC_PLT_PIC_WORD1
+ (val
& 0x3ff),
2197 bfd_put_32 (output_bfd
, SPARC_PLT_PIC_WORD2
, p
+ 8);
2202 if (! info
->shared
&& (h
->flags
& SUNOS_DEF_REGULAR
) != 0)
2204 bfd_put_16 (output_bfd
, M68K_PLT_ENTRY_WORD0
, p
);
2205 bfd_put_32 (output_bfd
, (- (h
->plt_offset
+ 2)), p
+ 2);
2206 bfd_put_16 (output_bfd
, s
->reloc_count
, p
+ 6);
2214 /* We also need to add a jump table reloc, unless this is the
2215 result of a JMP_TBL reloc from PIC compiled code. */
2216 if (info
->shared
|| (h
->flags
& SUNOS_DEF_REGULAR
) == 0)
2218 BFD_ASSERT (s
->reloc_count
* obj_reloc_entry_size (dynobj
)
2220 p
= s
->contents
+ s
->reloc_count
* obj_reloc_entry_size (output_bfd
);
2221 if (obj_reloc_entry_size (output_bfd
) == RELOC_STD_SIZE
)
2223 struct reloc_std_external
*srel
;
2225 srel
= (struct reloc_std_external
*) p
;
2226 PUT_WORD (output_bfd
, r_address
, srel
->r_address
);
2227 if (output_bfd
->xvec
->header_byteorder_big_p
)
2229 srel
->r_index
[0] = h
->dynindx
>> 16;
2230 srel
->r_index
[1] = h
->dynindx
>> 8;
2231 srel
->r_index
[2] = h
->dynindx
;
2232 srel
->r_type
[0] = (RELOC_STD_BITS_EXTERN_BIG
2233 | RELOC_STD_BITS_JMPTABLE_BIG
);
2237 srel
->r_index
[2] = h
->dynindx
>> 16;
2238 srel
->r_index
[1] = h
->dynindx
>> 8;
2239 srel
->r_index
[0] = h
->dynindx
;
2240 srel
->r_type
[0] = (RELOC_STD_BITS_EXTERN_LITTLE
2241 | RELOC_STD_BITS_JMPTABLE_LITTLE
);
2246 struct reloc_ext_external
*erel
;
2248 erel
= (struct reloc_ext_external
*) p
;
2249 PUT_WORD (output_bfd
, r_address
, erel
->r_address
);
2250 if (output_bfd
->xvec
->header_byteorder_big_p
)
2252 erel
->r_index
[0] = h
->dynindx
>> 16;
2253 erel
->r_index
[1] = h
->dynindx
>> 8;
2254 erel
->r_index
[2] = h
->dynindx
;
2256 (RELOC_EXT_BITS_EXTERN_BIG
2257 | (RELOC_JMP_SLOT
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2261 erel
->r_index
[2] = h
->dynindx
>> 16;
2262 erel
->r_index
[1] = h
->dynindx
>> 8;
2263 erel
->r_index
[0] = h
->dynindx
;
2265 (RELOC_EXT_BITS_EXTERN_LITTLE
2266 | (RELOC_JMP_SLOT
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
));
2268 PUT_WORD (output_bfd
, (bfd_vma
) 0, erel
->r_addend
);
2278 /* This is called for each reloc against an external symbol. If this
2279 is a reloc which are are going to copy as a dynamic reloc, then
2280 copy it over, and tell the caller to not bother processing this
2285 sunos_check_dynamic_reloc (info
, input_bfd
, input_section
, harg
, reloc
,
2286 contents
, skip
, relocationp
)
2287 struct bfd_link_info
*info
;
2289 asection
*input_section
;
2290 struct aout_link_hash_entry
*harg
;
2294 bfd_vma
*relocationp
;
2296 struct sunos_link_hash_entry
*h
= (struct sunos_link_hash_entry
*) harg
;
2306 dynobj
= sunos_hash_table (info
)->dynobj
;
2308 if (h
!= NULL
&& h
->plt_offset
!= 0)
2312 /* Redirect the relocation to the PLT entry. */
2313 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2314 *relocationp
= (splt
->output_section
->vma
2315 + splt
->output_offset
2319 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
2321 struct reloc_std_external
*srel
;
2323 srel
= (struct reloc_std_external
*) reloc
;
2324 if (input_bfd
->xvec
->header_byteorder_big_p
)
2326 baserel
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
2327 jmptbl
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
2331 baserel
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
2332 jmptbl
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
2337 struct reloc_ext_external
*erel
;
2340 erel
= (struct reloc_ext_external
*) reloc
;
2341 if (input_bfd
->xvec
->header_byteorder_big_p
)
2342 r_type
= ((erel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
2343 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
2345 r_type
= ((erel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
2346 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
2347 baserel
= (r_type
== RELOC_BASE10
2348 || r_type
== RELOC_BASE13
2349 || r_type
== RELOC_BASE22
);
2350 jmptbl
= r_type
== RELOC_JMP_TBL
;
2355 bfd_vma
*got_offsetp
;
2359 got_offsetp
= &h
->got_offset
;
2360 else if (adata (input_bfd
).local_got_offsets
== NULL
)
2364 struct reloc_std_external
*srel
;
2367 srel
= (struct reloc_std_external
*) reloc
;
2368 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
2370 if (input_bfd
->xvec
->header_byteorder_big_p
)
2371 r_index
= ((srel
->r_index
[0] << 16)
2372 | (srel
->r_index
[1] << 8)
2373 | srel
->r_index
[2]);
2375 r_index
= ((srel
->r_index
[2] << 16)
2376 | (srel
->r_index
[1] << 8)
2377 | srel
->r_index
[0]);
2381 struct reloc_ext_external
*erel
;
2383 erel
= (struct reloc_ext_external
*) reloc
;
2384 if (input_bfd
->xvec
->header_byteorder_big_p
)
2385 r_index
= ((erel
->r_index
[0] << 16)
2386 | (erel
->r_index
[1] << 8)
2387 | erel
->r_index
[2]);
2389 r_index
= ((erel
->r_index
[2] << 16)
2390 | (erel
->r_index
[1] << 8)
2391 | erel
->r_index
[0]);
2394 got_offsetp
= adata (input_bfd
).local_got_offsets
+ r_index
;
2397 BFD_ASSERT (got_offsetp
!= NULL
&& *got_offsetp
!= 0);
2399 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2401 /* We set the least significant bit to indicate whether we have
2402 already initialized the GOT entry. */
2403 if ((*got_offsetp
& 1) == 0)
2407 && ((h
->flags
& SUNOS_DEF_DYNAMIC
) == 0
2408 || (h
->flags
& SUNOS_DEF_REGULAR
) != 0)))
2409 PUT_WORD (dynobj
, *relocationp
, sgot
->contents
+ *got_offsetp
);
2411 PUT_WORD (dynobj
, 0, sgot
->contents
+ *got_offsetp
);
2415 && (h
->flags
& SUNOS_DEF_DYNAMIC
) != 0
2416 && (h
->flags
& SUNOS_DEF_REGULAR
) == 0))
2418 /* We need to create a GLOB_DAT or 32 reloc to tell the
2419 dynamic linker to fill in this entry in the table. */
2421 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
2422 BFD_ASSERT (s
!= NULL
);
2423 BFD_ASSERT (s
->reloc_count
* obj_reloc_entry_size (dynobj
)
2427 + s
->reloc_count
* obj_reloc_entry_size (dynobj
));
2434 if (obj_reloc_entry_size (dynobj
) == RELOC_STD_SIZE
)
2436 struct reloc_std_external
*srel
;
2438 srel
= (struct reloc_std_external
*) p
;
2441 + sgot
->output_section
->vma
2442 + sgot
->output_offset
),
2444 if (dynobj
->xvec
->header_byteorder_big_p
)
2446 srel
->r_index
[0] = indx
>> 16;
2447 srel
->r_index
[1] = indx
>> 8;
2448 srel
->r_index
[2] = indx
;
2450 srel
->r_type
[0] = 2 << RELOC_STD_BITS_LENGTH_SH_BIG
;
2453 (RELOC_STD_BITS_EXTERN_BIG
2454 | RELOC_STD_BITS_BASEREL_BIG
2455 | RELOC_STD_BITS_RELATIVE_BIG
2456 | (2 << RELOC_STD_BITS_LENGTH_SH_BIG
));
2460 srel
->r_index
[2] = indx
>> 16;
2461 srel
->r_index
[1] = indx
>> 8;
2462 srel
->r_index
[0] = indx
;
2464 srel
->r_type
[0] = 2 << RELOC_STD_BITS_LENGTH_SH_LITTLE
;
2467 (RELOC_STD_BITS_EXTERN_LITTLE
2468 | RELOC_STD_BITS_BASEREL_LITTLE
2469 | RELOC_STD_BITS_RELATIVE_LITTLE
2470 | (2 << RELOC_STD_BITS_LENGTH_SH_LITTLE
));
2475 struct reloc_ext_external
*erel
;
2477 erel
= (struct reloc_ext_external
*) p
;
2480 + sgot
->output_section
->vma
2481 + sgot
->output_offset
),
2483 if (dynobj
->xvec
->header_byteorder_big_p
)
2485 erel
->r_index
[0] = indx
>> 16;
2486 erel
->r_index
[1] = indx
>> 8;
2487 erel
->r_index
[2] = indx
;
2490 RELOC_32
<< RELOC_EXT_BITS_TYPE_SH_BIG
;
2493 (RELOC_EXT_BITS_EXTERN_BIG
2494 | (RELOC_GLOB_DAT
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2498 erel
->r_index
[2] = indx
>> 16;
2499 erel
->r_index
[1] = indx
>> 8;
2500 erel
->r_index
[0] = indx
;
2503 RELOC_32
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
;
2506 (RELOC_EXT_BITS_EXTERN_LITTLE
2508 << RELOC_EXT_BITS_TYPE_SH_LITTLE
));
2510 PUT_WORD (dynobj
, 0, erel
->r_addend
);
2519 *relocationp
= sgot
->vma
+ (*got_offsetp
&~ 1);
2521 /* There is nothing else to do for a base relative reloc. */
2525 if (! sunos_hash_table (info
)->dynamic_sections_needed
)
2531 || h
->root
.root
.type
!= bfd_link_hash_undefined
2532 || (h
->flags
& SUNOS_DEF_REGULAR
) != 0
2533 || (h
->flags
& SUNOS_DEF_DYNAMIC
) == 0
2534 || (h
->root
.root
.u
.undef
.abfd
->flags
& DYNAMIC
) == 0)
2540 && (h
->dynindx
== -1
2542 || strcmp (h
->root
.root
.root
.string
,
2543 "__GLOBAL_OFFSET_TABLE_") == 0))
2547 /* It looks like this is a reloc we are supposed to copy. */
2549 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
2550 BFD_ASSERT (s
!= NULL
);
2551 BFD_ASSERT (s
->reloc_count
* obj_reloc_entry_size (dynobj
) < s
->_raw_size
);
2553 p
= s
->contents
+ s
->reloc_count
* obj_reloc_entry_size (dynobj
);
2555 /* Copy the reloc over. */
2556 memcpy (p
, reloc
, obj_reloc_entry_size (dynobj
));
2563 /* Adjust the address and symbol index. */
2564 if (obj_reloc_entry_size (dynobj
) == RELOC_STD_SIZE
)
2566 struct reloc_std_external
*srel
;
2568 srel
= (struct reloc_std_external
*) p
;
2570 (GET_WORD (dynobj
, srel
->r_address
)
2571 + input_section
->output_section
->vma
2572 + input_section
->output_offset
),
2574 if (dynobj
->xvec
->header_byteorder_big_p
)
2576 srel
->r_index
[0] = indx
>> 16;
2577 srel
->r_index
[1] = indx
>> 8;
2578 srel
->r_index
[2] = indx
;
2582 srel
->r_index
[2] = indx
>> 16;
2583 srel
->r_index
[1] = indx
>> 8;
2584 srel
->r_index
[0] = indx
;
2589 struct reloc_ext_external
*erel
;
2591 erel
= (struct reloc_ext_external
*) p
;
2593 (GET_WORD (dynobj
, erel
->r_address
)
2594 + input_section
->output_section
->vma
2595 + input_section
->output_offset
),
2597 if (dynobj
->xvec
->header_byteorder_big_p
)
2599 erel
->r_index
[0] = indx
>> 16;
2600 erel
->r_index
[1] = indx
>> 8;
2601 erel
->r_index
[2] = indx
;
2605 erel
->r_index
[2] = indx
>> 16;
2606 erel
->r_index
[1] = indx
>> 8;
2607 erel
->r_index
[0] = indx
;
2619 /* Finish up the dynamic linking information. */
2622 sunos_finish_dynamic_link (abfd
, info
)
2624 struct bfd_link_info
*info
;
2630 struct external_sun4_dynamic esd
;
2631 struct external_sun4_dynamic_link esdl
;
2633 if (! sunos_hash_table (info
)->dynamic_sections_needed
)
2636 dynobj
= sunos_hash_table (info
)->dynobj
;
2638 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2639 BFD_ASSERT (sdyn
!= NULL
);
2641 /* Finish up the .need section. The linker emulation code filled it
2642 in, but with offsets from the start of the section instead of
2643 real addresses. Now that we know the section location, we can
2644 fill in the final values. */
2645 s
= bfd_get_section_by_name (dynobj
, ".need");
2646 if (s
!= NULL
&& s
->_raw_size
!= 0)
2651 filepos
= s
->output_section
->filepos
+ s
->output_offset
;
2657 PUT_WORD (dynobj
, GET_WORD (dynobj
, p
) + filepos
, p
);
2658 val
= GET_WORD (dynobj
, p
+ 12);
2661 PUT_WORD (dynobj
, val
+ filepos
, p
+ 12);
2666 /* The first entry in the .got section is the address of the
2667 dynamic information, unless this is a shared library. */
2668 s
= bfd_get_section_by_name (dynobj
, ".got");
2669 BFD_ASSERT (s
!= NULL
);
2671 PUT_WORD (dynobj
, 0, s
->contents
);
2673 PUT_WORD (dynobj
, sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2676 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2678 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0
2679 && o
->contents
!= NULL
)
2681 BFD_ASSERT (o
->output_section
!= NULL
2682 && o
->output_section
->owner
== abfd
);
2683 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2684 o
->contents
, o
->output_offset
,
2690 /* Finish up the dynamic link information. */
2691 PUT_WORD (dynobj
, (bfd_vma
) 3, esd
.ld_version
);
2693 sdyn
->output_section
->vma
+ sdyn
->output_offset
+ sizeof esd
,
2696 (sdyn
->output_section
->vma
2697 + sdyn
->output_offset
2699 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
),
2702 if (! bfd_set_section_contents (abfd
, sdyn
->output_section
, &esd
,
2703 sdyn
->output_offset
, sizeof esd
))
2707 PUT_WORD (dynobj
, (bfd_vma
) 0, esdl
.ld_loaded
);
2709 s
= bfd_get_section_by_name (dynobj
, ".need");
2710 if (s
== NULL
|| s
->_raw_size
== 0)
2711 PUT_WORD (dynobj
, (bfd_vma
) 0, esdl
.ld_need
);
2713 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2716 s
= bfd_get_section_by_name (dynobj
, ".rules");
2717 if (s
== NULL
|| s
->_raw_size
== 0)
2718 PUT_WORD (dynobj
, (bfd_vma
) 0, esdl
.ld_rules
);
2720 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2723 s
= bfd_get_section_by_name (dynobj
, ".got");
2724 BFD_ASSERT (s
!= NULL
);
2725 PUT_WORD (dynobj
, s
->output_section
->vma
+ s
->output_offset
, esdl
.ld_got
);
2727 s
= bfd_get_section_by_name (dynobj
, ".plt");
2728 BFD_ASSERT (s
!= NULL
);
2729 PUT_WORD (dynobj
, s
->output_section
->vma
+ s
->output_offset
, esdl
.ld_plt
);
2730 PUT_WORD (dynobj
, s
->_raw_size
, esdl
.ld_plt_sz
);
2732 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
2733 BFD_ASSERT (s
!= NULL
);
2734 BFD_ASSERT (s
->reloc_count
* obj_reloc_entry_size (dynobj
) == s
->_raw_size
);
2735 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2738 s
= bfd_get_section_by_name (dynobj
, ".hash");
2739 BFD_ASSERT (s
!= NULL
);
2740 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2743 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
2744 BFD_ASSERT (s
!= NULL
);
2745 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2748 PUT_WORD (dynobj
, (bfd_vma
) 0, esdl
.ld_stab_hash
);
2750 PUT_WORD (dynobj
, (bfd_vma
) sunos_hash_table (info
)->bucketcount
,
2753 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
2754 BFD_ASSERT (s
!= NULL
);
2755 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2757 PUT_WORD (dynobj
, s
->_raw_size
, esdl
.ld_symb_size
);
2759 /* The size of the text area is the size of the .text section
2760 rounded up to a page boundary. FIXME: Should the page size be
2761 conditional on something? */
2763 BFD_ALIGN (obj_textsec (abfd
)->_raw_size
, 0x2000),
2766 if (! bfd_set_section_contents (abfd
, sdyn
->output_section
, &esdl
,
2767 (sdyn
->output_offset
2769 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
),
2773 abfd
->flags
|= DYNAMIC
;