1 /* BFD backend for SunOS binaries.
2 Copyright 1990, 1991, 1992, 1994, 1995, 1996, 1997, 1998, 2000, 2001,
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #define TARGETNAME "a.out-sunos-big"
25 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
26 remove whitespace added here, and thus will fail to concatenate
28 #define MY(OP) CONCAT2 (sunos_big_,OP)
34 /* Static routines defined in this file. */
36 static boolean sunos_read_dynamic_info
PARAMS ((bfd
*));
37 static long sunos_get_dynamic_symtab_upper_bound
PARAMS ((bfd
*));
38 static boolean sunos_slurp_dynamic_symtab
PARAMS ((bfd
*));
39 static long sunos_canonicalize_dynamic_symtab
PARAMS ((bfd
*, asymbol
**));
40 static long sunos_get_dynamic_reloc_upper_bound
PARAMS ((bfd
*));
41 static long sunos_canonicalize_dynamic_reloc
42 PARAMS ((bfd
*, arelent
**, asymbol
**));
43 static struct bfd_hash_entry
*sunos_link_hash_newfunc
44 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
45 static struct bfd_link_hash_table
*sunos_link_hash_table_create
47 static boolean sunos_create_dynamic_sections
48 PARAMS ((bfd
*, struct bfd_link_info
*, boolean
));
49 static boolean sunos_add_dynamic_symbols
50 PARAMS ((bfd
*, struct bfd_link_info
*, struct external_nlist
**,
51 bfd_size_type
*, char **));
52 static boolean sunos_add_one_symbol
53 PARAMS ((struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
54 bfd_vma
, const char *, boolean
, boolean
,
55 struct bfd_link_hash_entry
**));
56 static boolean sunos_scan_relocs
57 PARAMS ((struct bfd_link_info
*, bfd
*, asection
*, bfd_size_type
));
58 static boolean sunos_scan_std_relocs
59 PARAMS ((struct bfd_link_info
*, bfd
*, asection
*,
60 const struct reloc_std_external
*, bfd_size_type
));
61 static boolean sunos_scan_ext_relocs
62 PARAMS ((struct bfd_link_info
*, bfd
*, asection
*,
63 const struct reloc_ext_external
*, bfd_size_type
));
64 static boolean sunos_link_dynamic_object
65 PARAMS ((struct bfd_link_info
*, bfd
*));
66 static boolean sunos_write_dynamic_symbol
67 PARAMS ((bfd
*, struct bfd_link_info
*, struct aout_link_hash_entry
*));
68 static boolean sunos_check_dynamic_reloc
69 PARAMS ((struct bfd_link_info
*, bfd
*, asection
*,
70 struct aout_link_hash_entry
*, PTR
, bfd_byte
*, boolean
*,
72 static boolean sunos_finish_dynamic_link
73 PARAMS ((bfd
*, struct bfd_link_info
*));
75 #define MY_get_dynamic_symtab_upper_bound sunos_get_dynamic_symtab_upper_bound
76 #define MY_canonicalize_dynamic_symtab sunos_canonicalize_dynamic_symtab
77 #define MY_get_dynamic_reloc_upper_bound sunos_get_dynamic_reloc_upper_bound
78 #define MY_canonicalize_dynamic_reloc sunos_canonicalize_dynamic_reloc
79 #define MY_bfd_link_hash_table_create sunos_link_hash_table_create
80 #define MY_add_dynamic_symbols sunos_add_dynamic_symbols
81 #define MY_add_one_symbol sunos_add_one_symbol
82 #define MY_link_dynamic_object sunos_link_dynamic_object
83 #define MY_write_dynamic_symbol sunos_write_dynamic_symbol
84 #define MY_check_dynamic_reloc sunos_check_dynamic_reloc
85 #define MY_finish_dynamic_link sunos_finish_dynamic_link
87 /* ??? Where should this go? */
88 #define MACHTYPE_OK(mtype) \
89 (((mtype) == M_SPARC && bfd_lookup_arch (bfd_arch_sparc, 0) != NULL) \
90 || ((mtype) == M_SPARCLET \
91 && bfd_lookup_arch (bfd_arch_sparc, bfd_mach_sparc_sparclet) != NULL) \
92 || ((mtype) == M_SPARCLITE_LE \
93 && bfd_lookup_arch (bfd_arch_sparc, bfd_mach_sparc_sparclet) != NULL) \
94 || (((mtype) == M_UNKNOWN || (mtype) == M_68010 || (mtype) == M_68020) \
95 && bfd_lookup_arch (bfd_arch_m68k, 0) != NULL))
97 /* Include the usual a.out support. */
100 /* The SunOS 4.1.4 /usr/include/locale.h defines valid as a macro. */
103 /* SunOS shared library support. We store a pointer to this structure
104 in obj_aout_dynamic_info (abfd). */
106 struct sunos_dynamic_info
108 /* Whether we found any dynamic information. */
110 /* Dynamic information. */
111 struct internal_sun4_dynamic_link dyninfo
;
112 /* Number of dynamic symbols. */
113 unsigned long dynsym_count
;
114 /* Read in nlists for dynamic symbols. */
115 struct external_nlist
*dynsym
;
116 /* asymbol structures for dynamic symbols. */
117 aout_symbol_type
*canonical_dynsym
;
118 /* Read in dynamic string table. */
120 /* Number of dynamic relocs. */
121 unsigned long dynrel_count
;
122 /* Read in dynamic relocs. This may be reloc_std_external or
123 reloc_ext_external. */
125 /* arelent structures for dynamic relocs. */
126 arelent
*canonical_dynrel
;
129 /* The hash table of dynamic symbols is composed of two word entries.
130 See include/aout/sun4.h for details. */
132 #define HASH_ENTRY_SIZE (2 * BYTES_IN_WORD)
134 /* Read in the basic dynamic information. This locates the __DYNAMIC
135 structure and uses it to find the dynamic_link structure. It
136 creates and saves a sunos_dynamic_info structure. If it can't find
137 __DYNAMIC, it sets the valid field of the sunos_dynamic_info
138 structure to false to avoid doing this work again. */
141 sunos_read_dynamic_info (abfd
)
144 struct sunos_dynamic_info
*info
;
147 struct external_sun4_dynamic dyninfo
;
148 unsigned long dynver
;
149 struct external_sun4_dynamic_link linkinfo
;
152 if (obj_aout_dynamic_info (abfd
) != (PTR
) NULL
)
155 if ((abfd
->flags
& DYNAMIC
) == 0)
157 bfd_set_error (bfd_error_invalid_operation
);
161 amt
= sizeof (struct sunos_dynamic_info
);
162 info
= (struct sunos_dynamic_info
*) bfd_zalloc (abfd
, amt
);
168 info
->canonical_dynsym
= NULL
;
170 info
->canonical_dynrel
= NULL
;
171 obj_aout_dynamic_info (abfd
) = (PTR
) info
;
173 /* This code used to look for the __DYNAMIC symbol to locate the dynamic
175 However this inhibits recovering the dynamic symbols from a
176 stripped object file, so blindly assume that the dynamic linking
177 information is located at the start of the data section.
178 We could verify this assumption later by looking through the dynamic
179 symbols for the __DYNAMIC symbol. */
180 if ((abfd
->flags
& DYNAMIC
) == 0)
182 if (! bfd_get_section_contents (abfd
, obj_datasec (abfd
), (PTR
) &dyninfo
,
184 (bfd_size_type
) sizeof dyninfo
))
187 dynver
= GET_WORD (abfd
, dyninfo
.ld_version
);
188 if (dynver
!= 2 && dynver
!= 3)
191 dynoff
= GET_WORD (abfd
, dyninfo
.ld
);
193 /* dynoff is a virtual address. It is probably always in the .data
194 section, but this code should work even if it moves. */
195 if (dynoff
< bfd_get_section_vma (abfd
, obj_datasec (abfd
)))
196 dynsec
= obj_textsec (abfd
);
198 dynsec
= obj_datasec (abfd
);
199 dynoff
-= bfd_get_section_vma (abfd
, dynsec
);
200 if (dynoff
> bfd_section_size (abfd
, dynsec
))
203 /* This executable appears to be dynamically linked in a way that we
205 if (! bfd_get_section_contents (abfd
, dynsec
, (PTR
) &linkinfo
,
207 (bfd_size_type
) sizeof linkinfo
))
210 /* Swap in the dynamic link information. */
211 info
->dyninfo
.ld_loaded
= GET_WORD (abfd
, linkinfo
.ld_loaded
);
212 info
->dyninfo
.ld_need
= GET_WORD (abfd
, linkinfo
.ld_need
);
213 info
->dyninfo
.ld_rules
= GET_WORD (abfd
, linkinfo
.ld_rules
);
214 info
->dyninfo
.ld_got
= GET_WORD (abfd
, linkinfo
.ld_got
);
215 info
->dyninfo
.ld_plt
= GET_WORD (abfd
, linkinfo
.ld_plt
);
216 info
->dyninfo
.ld_rel
= GET_WORD (abfd
, linkinfo
.ld_rel
);
217 info
->dyninfo
.ld_hash
= GET_WORD (abfd
, linkinfo
.ld_hash
);
218 info
->dyninfo
.ld_stab
= GET_WORD (abfd
, linkinfo
.ld_stab
);
219 info
->dyninfo
.ld_stab_hash
= GET_WORD (abfd
, linkinfo
.ld_stab_hash
);
220 info
->dyninfo
.ld_buckets
= GET_WORD (abfd
, linkinfo
.ld_buckets
);
221 info
->dyninfo
.ld_symbols
= GET_WORD (abfd
, linkinfo
.ld_symbols
);
222 info
->dyninfo
.ld_symb_size
= GET_WORD (abfd
, linkinfo
.ld_symb_size
);
223 info
->dyninfo
.ld_text
= GET_WORD (abfd
, linkinfo
.ld_text
);
224 info
->dyninfo
.ld_plt_sz
= GET_WORD (abfd
, linkinfo
.ld_plt_sz
);
226 /* Reportedly the addresses need to be offset by the size of the
227 exec header in an NMAGIC file. */
228 if (adata (abfd
).magic
== n_magic
)
230 unsigned long exec_bytes_size
= adata (abfd
).exec_bytes_size
;
232 info
->dyninfo
.ld_need
+= exec_bytes_size
;
233 info
->dyninfo
.ld_rules
+= exec_bytes_size
;
234 info
->dyninfo
.ld_rel
+= exec_bytes_size
;
235 info
->dyninfo
.ld_hash
+= exec_bytes_size
;
236 info
->dyninfo
.ld_stab
+= exec_bytes_size
;
237 info
->dyninfo
.ld_symbols
+= exec_bytes_size
;
240 /* The only way to get the size of the symbol information appears to
241 be to determine the distance between it and the string table. */
242 info
->dynsym_count
= ((info
->dyninfo
.ld_symbols
- info
->dyninfo
.ld_stab
)
243 / EXTERNAL_NLIST_SIZE
);
244 BFD_ASSERT (info
->dynsym_count
* EXTERNAL_NLIST_SIZE
245 == (unsigned long) (info
->dyninfo
.ld_symbols
246 - info
->dyninfo
.ld_stab
));
248 /* Similarly, the relocs end at the hash table. */
249 info
->dynrel_count
= ((info
->dyninfo
.ld_hash
- info
->dyninfo
.ld_rel
)
250 / obj_reloc_entry_size (abfd
));
251 BFD_ASSERT (info
->dynrel_count
* obj_reloc_entry_size (abfd
)
252 == (unsigned long) (info
->dyninfo
.ld_hash
253 - info
->dyninfo
.ld_rel
));
260 /* Return the amount of memory required for the dynamic symbols. */
263 sunos_get_dynamic_symtab_upper_bound (abfd
)
266 struct sunos_dynamic_info
*info
;
268 if (! sunos_read_dynamic_info (abfd
))
271 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
274 bfd_set_error (bfd_error_no_symbols
);
278 return (info
->dynsym_count
+ 1) * sizeof (asymbol
*);
281 /* Read the external dynamic symbols. */
284 sunos_slurp_dynamic_symtab (abfd
)
287 struct sunos_dynamic_info
*info
;
290 /* Get the general dynamic information. */
291 if (obj_aout_dynamic_info (abfd
) == NULL
)
293 if (! sunos_read_dynamic_info (abfd
))
297 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
300 bfd_set_error (bfd_error_no_symbols
);
304 /* Get the dynamic nlist structures. */
305 if (info
->dynsym
== (struct external_nlist
*) NULL
)
307 amt
= (bfd_size_type
) info
->dynsym_count
* EXTERNAL_NLIST_SIZE
;
308 info
->dynsym
= (struct external_nlist
*) bfd_alloc (abfd
, amt
);
309 if (info
->dynsym
== NULL
&& info
->dynsym_count
!= 0)
311 if (bfd_seek (abfd
, (file_ptr
) info
->dyninfo
.ld_stab
, SEEK_SET
) != 0
312 || bfd_bread ((PTR
) info
->dynsym
, amt
, abfd
) != amt
)
314 if (info
->dynsym
!= NULL
)
316 bfd_release (abfd
, info
->dynsym
);
323 /* Get the dynamic strings. */
324 if (info
->dynstr
== (char *) NULL
)
326 amt
= info
->dyninfo
.ld_symb_size
;
327 info
->dynstr
= (char *) bfd_alloc (abfd
, amt
);
328 if (info
->dynstr
== NULL
&& info
->dyninfo
.ld_symb_size
!= 0)
330 if (bfd_seek (abfd
, (file_ptr
) info
->dyninfo
.ld_symbols
, SEEK_SET
) != 0
331 || bfd_bread ((PTR
) info
->dynstr
, amt
, abfd
) != amt
)
333 if (info
->dynstr
!= NULL
)
335 bfd_release (abfd
, info
->dynstr
);
345 /* Read in the dynamic symbols. */
348 sunos_canonicalize_dynamic_symtab (abfd
, storage
)
352 struct sunos_dynamic_info
*info
;
355 if (! sunos_slurp_dynamic_symtab (abfd
))
358 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
360 #ifdef CHECK_DYNAMIC_HASH
361 /* Check my understanding of the dynamic hash table by making sure
362 that each symbol can be located in the hash table. */
364 bfd_size_type table_size
;
368 if (info
->dyninfo
.ld_buckets
> info
->dynsym_count
)
370 table_size
= info
->dyninfo
.ld_stab
- info
->dyninfo
.ld_hash
;
371 table
= (bfd_byte
*) bfd_malloc (table_size
);
372 if (table
== NULL
&& table_size
!= 0)
374 if (bfd_seek (abfd
, (file_ptr
) info
->dyninfo
.ld_hash
, SEEK_SET
) != 0
375 || bfd_bread ((PTR
) table
, table_size
, abfd
) != table_size
)
377 for (i
= 0; i
< info
->dynsym_count
; i
++)
382 name
= ((unsigned char *) info
->dynstr
383 + GET_WORD (abfd
, info
->dynsym
[i
].e_strx
));
385 while (*name
!= '\0')
386 hash
= (hash
<< 1) + *name
++;
388 hash
%= info
->dyninfo
.ld_buckets
;
389 while (GET_WORD (abfd
, table
+ hash
* HASH_ENTRY_SIZE
) != i
)
391 hash
= GET_WORD (abfd
,
392 table
+ hash
* HASH_ENTRY_SIZE
+ BYTES_IN_WORD
);
393 if (hash
== 0 || hash
>= table_size
/ HASH_ENTRY_SIZE
)
399 #endif /* CHECK_DYNAMIC_HASH */
401 /* Get the asymbol structures corresponding to the dynamic nlist
403 if (info
->canonical_dynsym
== (aout_symbol_type
*) NULL
)
406 bfd_size_type strsize
= info
->dyninfo
.ld_symb_size
;
408 size
= (bfd_size_type
) info
->dynsym_count
* sizeof (aout_symbol_type
);
409 info
->canonical_dynsym
= (aout_symbol_type
*) bfd_alloc (abfd
, size
);
410 if (info
->canonical_dynsym
== NULL
&& info
->dynsym_count
!= 0)
413 if (! aout_32_translate_symbol_table (abfd
, info
->canonical_dynsym
,
415 (bfd_size_type
) info
->dynsym_count
,
416 info
->dynstr
, strsize
, true))
418 if (info
->canonical_dynsym
!= NULL
)
420 bfd_release (abfd
, info
->canonical_dynsym
);
421 info
->canonical_dynsym
= NULL
;
427 /* Return pointers to the dynamic asymbol structures. */
428 for (i
= 0; i
< info
->dynsym_count
; i
++)
429 *storage
++ = (asymbol
*) (info
->canonical_dynsym
+ i
);
432 return info
->dynsym_count
;
435 /* Return the amount of memory required for the dynamic relocs. */
438 sunos_get_dynamic_reloc_upper_bound (abfd
)
441 struct sunos_dynamic_info
*info
;
443 if (! sunos_read_dynamic_info (abfd
))
446 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
449 bfd_set_error (bfd_error_no_symbols
);
453 return (info
->dynrel_count
+ 1) * sizeof (arelent
*);
456 /* Read in the dynamic relocs. */
459 sunos_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
464 struct sunos_dynamic_info
*info
;
468 /* Get the general dynamic information. */
469 if (obj_aout_dynamic_info (abfd
) == (PTR
) NULL
)
471 if (! sunos_read_dynamic_info (abfd
))
475 info
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
478 bfd_set_error (bfd_error_no_symbols
);
482 /* Get the dynamic reloc information. */
483 if (info
->dynrel
== NULL
)
485 size
= (bfd_size_type
) info
->dynrel_count
* obj_reloc_entry_size (abfd
);
486 info
->dynrel
= (PTR
) bfd_alloc (abfd
, size
);
487 if (info
->dynrel
== NULL
&& size
!= 0)
489 if (bfd_seek (abfd
, (file_ptr
) info
->dyninfo
.ld_rel
, SEEK_SET
) != 0
490 || bfd_bread ((PTR
) info
->dynrel
, size
, abfd
) != size
)
492 if (info
->dynrel
!= NULL
)
494 bfd_release (abfd
, info
->dynrel
);
501 /* Get the arelent structures corresponding to the dynamic reloc
503 if (info
->canonical_dynrel
== (arelent
*) NULL
)
507 size
= (bfd_size_type
) info
->dynrel_count
* sizeof (arelent
);
508 info
->canonical_dynrel
= (arelent
*) bfd_alloc (abfd
, size
);
509 if (info
->canonical_dynrel
== NULL
&& info
->dynrel_count
!= 0)
512 to
= info
->canonical_dynrel
;
514 if (obj_reloc_entry_size (abfd
) == RELOC_EXT_SIZE
)
516 register struct reloc_ext_external
*p
;
517 struct reloc_ext_external
*pend
;
519 p
= (struct reloc_ext_external
*) info
->dynrel
;
520 pend
= p
+ info
->dynrel_count
;
521 for (; p
< pend
; p
++, to
++)
522 NAME(aout
,swap_ext_reloc_in
) (abfd
, p
, to
, syms
,
523 (bfd_size_type
) info
->dynsym_count
);
527 register struct reloc_std_external
*p
;
528 struct reloc_std_external
*pend
;
530 p
= (struct reloc_std_external
*) info
->dynrel
;
531 pend
= p
+ info
->dynrel_count
;
532 for (; p
< pend
; p
++, to
++)
533 NAME(aout
,swap_std_reloc_in
) (abfd
, p
, to
, syms
,
534 (bfd_size_type
) info
->dynsym_count
);
538 /* Return pointers to the dynamic arelent structures. */
539 for (i
= 0; i
< info
->dynrel_count
; i
++)
540 *storage
++ = info
->canonical_dynrel
+ i
;
543 return info
->dynrel_count
;
546 /* Code to handle linking of SunOS shared libraries. */
548 /* A SPARC procedure linkage table entry is 12 bytes. The first entry
549 in the table is a jump which is filled in by the runtime linker.
550 The remaining entries are branches back to the first entry,
551 followed by an index into the relocation table encoded to look like
554 #define SPARC_PLT_ENTRY_SIZE (12)
556 static const bfd_byte sparc_plt_first_entry
[SPARC_PLT_ENTRY_SIZE
] =
558 /* sethi %hi(0),%g1; address filled in by runtime linker. */
560 /* jmp %g1; offset filled in by runtime linker. */
566 /* save %sp, -96, %sp */
567 #define SPARC_PLT_ENTRY_WORD0 ((bfd_vma) 0x9de3bfa0)
568 /* call; address filled in later. */
569 #define SPARC_PLT_ENTRY_WORD1 ((bfd_vma) 0x40000000)
570 /* sethi; reloc index filled in later. */
571 #define SPARC_PLT_ENTRY_WORD2 ((bfd_vma) 0x01000000)
573 /* This sequence is used when for the jump table entry to a defined
574 symbol in a complete executable. It is used when linking PIC
575 compiled code which is not being put into a shared library. */
576 /* sethi <address to be filled in later>, %g1 */
577 #define SPARC_PLT_PIC_WORD0 ((bfd_vma) 0x03000000)
578 /* jmp %g1 + <address to be filled in later> */
579 #define SPARC_PLT_PIC_WORD1 ((bfd_vma) 0x81c06000)
581 #define SPARC_PLT_PIC_WORD2 ((bfd_vma) 0x01000000)
583 /* An m68k procedure linkage table entry is 8 bytes. The first entry
584 in the table is a jump which is filled in the by the runtime
585 linker. The remaining entries are branches back to the first
586 entry, followed by a two byte index into the relocation table. */
588 #define M68K_PLT_ENTRY_SIZE (8)
590 static const bfd_byte m68k_plt_first_entry
[M68K_PLT_ENTRY_SIZE
] =
594 /* Filled in by runtime linker with a magic address. */
601 #define M68K_PLT_ENTRY_WORD0 ((bfd_vma) 0x61ff)
602 /* Remaining words filled in later. */
604 /* An entry in the SunOS linker hash table. */
606 struct sunos_link_hash_entry
608 struct aout_link_hash_entry root
;
610 /* If this is a dynamic symbol, this is its index into the dynamic
611 symbol table. This is initialized to -1. As the linker looks at
612 the input files, it changes this to -2 if it will be added to the
613 dynamic symbol table. After all the input files have been seen,
614 the linker will know whether to build a dynamic symbol table; if
615 it does build one, this becomes the index into the table. */
618 /* If this is a dynamic symbol, this is the index of the name in the
619 dynamic symbol string table. */
622 /* The offset into the global offset table used for this symbol. If
623 the symbol does not require a GOT entry, this is 0. */
626 /* The offset into the procedure linkage table used for this symbol.
627 If the symbol does not require a PLT entry, this is 0. */
630 /* Some linker flags. */
632 /* Symbol is referenced by a regular object. */
633 #define SUNOS_REF_REGULAR 01
634 /* Symbol is defined by a regular object. */
635 #define SUNOS_DEF_REGULAR 02
636 /* Symbol is referenced by a dynamic object. */
637 #define SUNOS_REF_DYNAMIC 04
638 /* Symbol is defined by a dynamic object. */
639 #define SUNOS_DEF_DYNAMIC 010
640 /* Symbol is a constructor symbol in a regular object. */
641 #define SUNOS_CONSTRUCTOR 020
644 /* The SunOS linker hash table. */
646 struct sunos_link_hash_table
648 struct aout_link_hash_table root
;
650 /* The object which holds the dynamic sections. */
653 /* Whether we have created the dynamic sections. */
654 boolean dynamic_sections_created
;
656 /* Whether we need the dynamic sections. */
657 boolean dynamic_sections_needed
;
659 /* Whether we need the .got table. */
662 /* The number of dynamic symbols. */
665 /* The number of buckets in the hash table. */
668 /* The list of dynamic objects needed by dynamic objects included in
670 struct bfd_link_needed_list
*needed
;
672 /* The offset of __GLOBAL_OFFSET_TABLE_ into the .got section. */
676 /* Routine to create an entry in an SunOS link hash table. */
678 static struct bfd_hash_entry
*
679 sunos_link_hash_newfunc (entry
, table
, string
)
680 struct bfd_hash_entry
*entry
;
681 struct bfd_hash_table
*table
;
684 struct sunos_link_hash_entry
*ret
= (struct sunos_link_hash_entry
*) entry
;
686 /* Allocate the structure if it has not already been allocated by a
688 if (ret
== (struct sunos_link_hash_entry
*) NULL
)
689 ret
= ((struct sunos_link_hash_entry
*)
690 bfd_hash_allocate (table
, sizeof (struct sunos_link_hash_entry
)));
691 if (ret
== (struct sunos_link_hash_entry
*) NULL
)
692 return (struct bfd_hash_entry
*) ret
;
694 /* Call the allocation method of the superclass. */
695 ret
= ((struct sunos_link_hash_entry
*)
696 NAME(aout
,link_hash_newfunc
) ((struct bfd_hash_entry
*) ret
,
700 /* Set local fields. */
702 ret
->dynstr_index
= -1;
708 return (struct bfd_hash_entry
*) ret
;
711 /* Create a SunOS link hash table. */
713 static struct bfd_link_hash_table
*
714 sunos_link_hash_table_create (abfd
)
717 struct sunos_link_hash_table
*ret
;
718 bfd_size_type amt
= sizeof (struct sunos_link_hash_table
);
720 ret
= (struct sunos_link_hash_table
*) bfd_alloc (abfd
, amt
);
721 if (ret
== (struct sunos_link_hash_table
*) NULL
)
722 return (struct bfd_link_hash_table
*) NULL
;
723 if (! NAME(aout
,link_hash_table_init
) (&ret
->root
, abfd
,
724 sunos_link_hash_newfunc
))
726 bfd_release (abfd
, ret
);
727 return (struct bfd_link_hash_table
*) NULL
;
731 ret
->dynamic_sections_created
= false;
732 ret
->dynamic_sections_needed
= false;
733 ret
->got_needed
= false;
734 ret
->dynsymcount
= 0;
735 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
787 | SEC_LINKER_CREATED
);
789 /* The .dynamic section holds the basic dynamic information: the
790 sun4_dynamic structure, the dynamic debugger information, and
791 the sun4_dynamic_link structure. */
792 s
= bfd_make_section (abfd
, ".dynamic");
794 || ! bfd_set_section_flags (abfd
, s
, flags
)
795 || ! bfd_set_section_alignment (abfd
, s
, 2))
798 /* The .got section holds the global offset table. The address
799 is put in the ld_got field. */
800 s
= bfd_make_section (abfd
, ".got");
802 || ! bfd_set_section_flags (abfd
, s
, flags
)
803 || ! bfd_set_section_alignment (abfd
, s
, 2))
806 /* The .plt section holds the procedure linkage table. The
807 address is put in the ld_plt field. */
808 s
= bfd_make_section (abfd
, ".plt");
810 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
811 || ! bfd_set_section_alignment (abfd
, s
, 2))
814 /* The .dynrel section holds the dynamic relocs. The address is
815 put in the ld_rel field. */
816 s
= bfd_make_section (abfd
, ".dynrel");
818 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
819 || ! bfd_set_section_alignment (abfd
, s
, 2))
822 /* The .hash section holds the dynamic hash table. The address
823 is put in the ld_hash field. */
824 s
= bfd_make_section (abfd
, ".hash");
826 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
827 || ! bfd_set_section_alignment (abfd
, s
, 2))
830 /* The .dynsym section holds the dynamic symbols. The address
831 is put in the ld_stab field. */
832 s
= bfd_make_section (abfd
, ".dynsym");
834 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
835 || ! bfd_set_section_alignment (abfd
, s
, 2))
838 /* The .dynstr section holds the dynamic symbol string table.
839 The address is put in the ld_symbols field. */
840 s
= bfd_make_section (abfd
, ".dynstr");
842 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
843 || ! bfd_set_section_alignment (abfd
, s
, 2))
846 sunos_hash_table (info
)->dynamic_sections_created
= true;
849 if ((needed
&& ! sunos_hash_table (info
)->dynamic_sections_needed
)
854 dynobj
= sunos_hash_table (info
)->dynobj
;
856 s
= bfd_get_section_by_name (dynobj
, ".got");
857 if (s
->_raw_size
== 0)
858 s
->_raw_size
= BYTES_IN_WORD
;
860 sunos_hash_table (info
)->dynamic_sections_needed
= true;
861 sunos_hash_table (info
)->got_needed
= true;
867 /* Add dynamic symbols during a link. This is called by the a.out
868 backend linker for each object it encounters. */
871 sunos_add_dynamic_symbols (abfd
, info
, symsp
, sym_countp
, stringsp
)
873 struct bfd_link_info
*info
;
874 struct external_nlist
**symsp
;
875 bfd_size_type
*sym_countp
;
879 struct sunos_dynamic_info
*dinfo
;
883 /* Make sure we have all the required sections. */
884 if (info
->hash
->creator
== abfd
->xvec
)
886 if (! sunos_create_dynamic_sections (abfd
, info
,
887 (((abfd
->flags
& DYNAMIC
) != 0
888 && ! info
->relocateable
)
894 /* There is nothing else to do for a normal object. */
895 if ((abfd
->flags
& DYNAMIC
) == 0)
898 dynobj
= sunos_hash_table (info
)->dynobj
;
900 /* We do not want to include the sections in a dynamic object in the
901 output file. We hack by simply clobbering the list of sections
902 in the BFD. This could be handled more cleanly by, say, a new
903 section flag; the existing SEC_NEVER_LOAD flag is not the one we
904 want, because that one still implies that the section takes up
905 space in the output file. If this is the first object we have
906 seen, we must preserve the dynamic sections we just created. */
907 for (ps
= &abfd
->sections
; *ps
!= NULL
; )
909 if (abfd
!= dynobj
|| ((*ps
)->flags
& SEC_LINKER_CREATED
) == 0)
910 bfd_section_list_remove (abfd
, ps
);
915 /* The native linker seems to just ignore dynamic objects when -r is
917 if (info
->relocateable
)
920 /* There's no hope of using a dynamic object which does not exactly
921 match the format of the output file. */
922 if (info
->hash
->creator
!= abfd
->xvec
)
924 bfd_set_error (bfd_error_invalid_operation
);
928 /* Make sure we have a .need and a .rules sections. These are only
929 needed if there really is a dynamic object in the link, so they
930 are not added by sunos_create_dynamic_sections. */
931 if (bfd_get_section_by_name (dynobj
, ".need") == NULL
)
933 /* The .need section holds the list of names of shared objets
934 which must be included at runtime. The address of this
935 section is put in the ld_need field. */
936 asection
*s
= bfd_make_section (dynobj
, ".need");
938 || ! bfd_set_section_flags (dynobj
, s
,
944 || ! bfd_set_section_alignment (dynobj
, s
, 2))
948 if (bfd_get_section_by_name (dynobj
, ".rules") == NULL
)
950 /* The .rules section holds the path to search for shared
951 objects. The address of this section is put in the ld_rules
953 asection
*s
= bfd_make_section (dynobj
, ".rules");
955 || ! bfd_set_section_flags (dynobj
, s
,
961 || ! bfd_set_section_alignment (dynobj
, s
, 2))
965 /* Pick up the dynamic symbols and return them to the caller. */
966 if (! sunos_slurp_dynamic_symtab (abfd
))
969 dinfo
= (struct sunos_dynamic_info
*) obj_aout_dynamic_info (abfd
);
970 *symsp
= dinfo
->dynsym
;
971 *sym_countp
= dinfo
->dynsym_count
;
972 *stringsp
= dinfo
->dynstr
;
974 /* Record information about any other objects needed by this one. */
975 need
= dinfo
->dyninfo
.ld_need
;
979 unsigned long name
, flags
;
980 unsigned short major_vno
, minor_vno
;
981 struct bfd_link_needed_list
*needed
, **pp
;
987 if (bfd_seek (abfd
, (file_ptr
) need
, SEEK_SET
) != 0
988 || bfd_bread (buf
, (bfd_size_type
) 16, abfd
) != 16)
991 /* For the format of an ld_need entry, see aout/sun4.h. We
992 should probably define structs for this manipulation. */
994 name
= bfd_get_32 (abfd
, buf
);
995 flags
= bfd_get_32 (abfd
, buf
+ 4);
996 major_vno
= (unsigned short) bfd_get_16 (abfd
, buf
+ 8);
997 minor_vno
= (unsigned short) bfd_get_16 (abfd
, buf
+ 10);
998 need
= bfd_get_32 (abfd
, buf
+ 12);
1000 alc
= sizeof (struct bfd_link_needed_list
);
1001 needed
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, alc
);
1006 /* We return the name as [-l]name[.maj][.min]. */
1008 namebuf
= (char *) bfd_malloc (alc
+ 1);
1009 if (namebuf
== NULL
)
1013 if ((flags
& 0x80000000) != 0)
1018 if (bfd_seek (abfd
, (file_ptr
) name
, SEEK_SET
) != 0)
1026 if (bfd_bread (&b
, (bfd_size_type
) 1, abfd
) != 1)
1032 if ((bfd_size_type
) (p
- namebuf
) >= alc
)
1037 n
= (char *) bfd_realloc (namebuf
, alc
+ 1);
1043 p
= n
+ (p
- namebuf
);
1058 sprintf (majbuf
, ".%d", major_vno
);
1062 sprintf (minbuf
, ".%d", minor_vno
);
1064 if ((p
- namebuf
) + strlen (majbuf
) + strlen (minbuf
) >= alc
)
1068 alc
= (p
- namebuf
) + strlen (majbuf
) + strlen (minbuf
);
1069 n
= (char *) bfd_realloc (namebuf
, alc
+ 1);
1075 p
= n
+ (p
- namebuf
);
1083 namecopy
= bfd_alloc (abfd
, (bfd_size_type
) strlen (namebuf
) + 1);
1084 if (namecopy
== NULL
)
1089 strcpy (namecopy
, namebuf
);
1091 needed
->name
= namecopy
;
1093 needed
->next
= NULL
;
1095 for (pp
= &sunos_hash_table (info
)->needed
;
1105 /* Function to add a single symbol to the linker hash table. This is
1106 a wrapper around _bfd_generic_link_add_one_symbol which handles the
1107 tweaking needed for dynamic linking support. */
1110 sunos_add_one_symbol (info
, abfd
, name
, flags
, section
, value
, string
,
1111 copy
, collect
, hashp
)
1112 struct bfd_link_info
*info
;
1121 struct bfd_link_hash_entry
**hashp
;
1123 struct sunos_link_hash_entry
*h
;
1126 if ((flags
& (BSF_INDIRECT
| BSF_WARNING
| BSF_CONSTRUCTOR
)) != 0
1127 || ! bfd_is_und_section (section
))
1128 h
= sunos_link_hash_lookup (sunos_hash_table (info
), name
, true, copy
,
1131 h
= ((struct sunos_link_hash_entry
*)
1132 bfd_wrapped_link_hash_lookup (abfd
, info
, name
, true, copy
, false));
1137 *hashp
= (struct bfd_link_hash_entry
*) h
;
1139 /* Treat a common symbol in a dynamic object as defined in the .bss
1140 section of the dynamic object. We don't want to allocate space
1141 for it in our process image. */
1142 if ((abfd
->flags
& DYNAMIC
) != 0
1143 && bfd_is_com_section (section
))
1144 section
= obj_bsssec (abfd
);
1146 if (! bfd_is_und_section (section
)
1147 && h
->root
.root
.type
!= bfd_link_hash_new
1148 && h
->root
.root
.type
!= bfd_link_hash_undefined
1149 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1151 /* We are defining the symbol, and it is already defined. This
1152 is a potential multiple definition error. */
1153 if ((abfd
->flags
& DYNAMIC
) != 0)
1155 /* The definition we are adding is from a dynamic object.
1156 We do not want this new definition to override the
1157 existing definition, so we pretend it is just a
1159 section
= bfd_und_section_ptr
;
1161 else if (h
->root
.root
.type
== bfd_link_hash_defined
1162 && h
->root
.root
.u
.def
.section
->owner
!= NULL
1163 && (h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
) != 0)
1165 /* The existing definition is from a dynamic object. We
1166 want to override it with the definition we just found.
1167 Clobber the existing definition. */
1168 h
->root
.root
.type
= bfd_link_hash_undefined
;
1169 h
->root
.root
.u
.undef
.abfd
= h
->root
.root
.u
.def
.section
->owner
;
1171 else if (h
->root
.root
.type
== bfd_link_hash_common
1172 && (h
->root
.root
.u
.c
.p
->section
->owner
->flags
& DYNAMIC
) != 0)
1174 /* The existing definition is from a dynamic object. We
1175 want to override it with the definition we just found.
1176 Clobber the existing definition. We can't set it to new,
1177 because it is on the undefined list. */
1178 h
->root
.root
.type
= bfd_link_hash_undefined
;
1179 h
->root
.root
.u
.undef
.abfd
= h
->root
.root
.u
.c
.p
->section
->owner
;
1183 if ((abfd
->flags
& DYNAMIC
) != 0
1184 && abfd
->xvec
== info
->hash
->creator
1185 && (h
->flags
& SUNOS_CONSTRUCTOR
) != 0)
1187 /* The existing symbol is a constructor symbol, and this symbol
1188 is from a dynamic object. A constructor symbol is actually a
1189 definition, although the type will be bfd_link_hash_undefined
1190 at this point. We want to ignore the definition from the
1192 section
= bfd_und_section_ptr
;
1194 else if ((flags
& BSF_CONSTRUCTOR
) != 0
1195 && (abfd
->flags
& DYNAMIC
) == 0
1196 && h
->root
.root
.type
== bfd_link_hash_defined
1197 && h
->root
.root
.u
.def
.section
->owner
!= NULL
1198 && (h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
) != 0)
1200 /* The existing symbol is defined by a dynamic object, and this
1201 is a constructor symbol. As above, we want to force the use
1202 of the constructor symbol from the regular object. */
1203 h
->root
.root
.type
= bfd_link_hash_new
;
1206 /* Do the usual procedure for adding a symbol. */
1207 if (! _bfd_generic_link_add_one_symbol (info
, abfd
, name
, flags
, section
,
1208 value
, string
, copy
, collect
,
1212 if (abfd
->xvec
== info
->hash
->creator
)
1214 /* Set a flag in the hash table entry indicating the type of
1215 reference or definition we just found. Keep a count of the
1216 number of dynamic symbols we find. A dynamic symbol is one
1217 which is referenced or defined by both a regular object and a
1219 if ((abfd
->flags
& DYNAMIC
) == 0)
1221 if (bfd_is_und_section (section
))
1222 new_flag
= SUNOS_REF_REGULAR
;
1224 new_flag
= SUNOS_DEF_REGULAR
;
1228 if (bfd_is_und_section (section
))
1229 new_flag
= SUNOS_REF_DYNAMIC
;
1231 new_flag
= SUNOS_DEF_DYNAMIC
;
1233 h
->flags
|= new_flag
;
1235 if (h
->dynindx
== -1
1236 && (h
->flags
& (SUNOS_DEF_REGULAR
| SUNOS_REF_REGULAR
)) != 0)
1238 ++sunos_hash_table (info
)->dynsymcount
;
1242 if ((flags
& BSF_CONSTRUCTOR
) != 0
1243 && (abfd
->flags
& DYNAMIC
) == 0)
1244 h
->flags
|= SUNOS_CONSTRUCTOR
;
1250 /* Return the list of objects needed by BFD. */
1253 struct bfd_link_needed_list
*
1254 bfd_sunos_get_needed_list (abfd
, info
)
1255 bfd
*abfd ATTRIBUTE_UNUSED
;
1256 struct bfd_link_info
*info
;
1258 if (info
->hash
->creator
!= &MY(vec
))
1260 return sunos_hash_table (info
)->needed
;
1263 /* Record an assignment made to a symbol by a linker script. We need
1264 this in case some dynamic object refers to this symbol. */
1267 bfd_sunos_record_link_assignment (output_bfd
, info
, name
)
1269 struct bfd_link_info
*info
;
1272 struct sunos_link_hash_entry
*h
;
1274 if (output_bfd
->xvec
!= &MY(vec
))
1277 /* This is called after we have examined all the input objects. If
1278 the symbol does not exist, it merely means that no object refers
1279 to it, and we can just ignore it at this point. */
1280 h
= sunos_link_hash_lookup (sunos_hash_table (info
), name
,
1281 false, false, false);
1285 /* In a shared library, the __DYNAMIC symbol does not appear in the
1286 dynamic symbol table. */
1287 if (! info
->shared
|| strcmp (name
, "__DYNAMIC") != 0)
1289 h
->flags
|= SUNOS_DEF_REGULAR
;
1291 if (h
->dynindx
== -1)
1293 ++sunos_hash_table (info
)->dynsymcount
;
1301 /* Set up the sizes and contents of the dynamic sections created in
1302 sunos_add_dynamic_symbols. This is called by the SunOS linker
1303 emulation before_allocation routine. We must set the sizes of the
1304 sections before the linker sets the addresses of the various
1305 sections. This unfortunately requires reading all the relocs so
1306 that we can work out which ones need to become dynamic relocs. If
1307 info->keep_memory is true, we keep the relocs in memory; otherwise,
1308 we discard them, and will read them again later. */
1311 bfd_sunos_size_dynamic_sections (output_bfd
, info
, sdynptr
, sneedptr
,
1314 struct bfd_link_info
*info
;
1316 asection
**sneedptr
;
1317 asection
**srulesptr
;
1320 bfd_size_type dynsymcount
;
1321 struct sunos_link_hash_entry
*h
;
1324 bfd_size_type hashalloc
;
1332 if (info
->relocateable
)
1335 if (output_bfd
->xvec
!= &MY(vec
))
1338 /* Look through all the input BFD's and read their relocs. It would
1339 be better if we didn't have to do this, but there is no other way
1340 to determine the number of dynamic relocs we need, and, more
1341 importantly, there is no other way to know which symbols should
1342 get an entry in the procedure linkage table. */
1343 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
1345 if ((sub
->flags
& DYNAMIC
) == 0
1346 && sub
->xvec
== output_bfd
->xvec
)
1348 if (! sunos_scan_relocs (info
, sub
, obj_textsec (sub
),
1349 exec_hdr (sub
)->a_trsize
)
1350 || ! sunos_scan_relocs (info
, sub
, obj_datasec (sub
),
1351 exec_hdr (sub
)->a_drsize
))
1356 dynobj
= sunos_hash_table (info
)->dynobj
;
1357 dynsymcount
= sunos_hash_table (info
)->dynsymcount
;
1359 /* If there were no dynamic objects in the link, and we don't need
1360 to build a global offset table, there is nothing to do here. */
1361 if (! sunos_hash_table (info
)->dynamic_sections_needed
1362 && ! sunos_hash_table (info
)->got_needed
)
1365 /* If __GLOBAL_OFFSET_TABLE_ was mentioned, define it. */
1366 h
= sunos_link_hash_lookup (sunos_hash_table (info
),
1367 "__GLOBAL_OFFSET_TABLE_", false, false, false);
1368 if (h
!= NULL
&& (h
->flags
& SUNOS_REF_REGULAR
) != 0)
1370 h
->flags
|= SUNOS_DEF_REGULAR
;
1371 if (h
->dynindx
== -1)
1373 ++sunos_hash_table (info
)->dynsymcount
;
1376 h
->root
.root
.type
= bfd_link_hash_defined
;
1377 h
->root
.root
.u
.def
.section
= bfd_get_section_by_name (dynobj
, ".got");
1379 /* If the .got section is more than 0x1000 bytes, we set
1380 __GLOBAL_OFFSET_TABLE_ to be 0x1000 bytes into the section,
1381 so that 13 bit relocations have a greater chance of working. */
1382 s
= bfd_get_section_by_name (dynobj
, ".got");
1383 BFD_ASSERT (s
!= NULL
);
1384 if (s
->_raw_size
>= 0x1000)
1385 h
->root
.root
.u
.def
.value
= 0x1000;
1387 h
->root
.root
.u
.def
.value
= 0;
1389 sunos_hash_table (info
)->got_base
= h
->root
.root
.u
.def
.value
;
1392 /* If there are any shared objects in the link, then we need to set
1393 up the dynamic linking information. */
1394 if (sunos_hash_table (info
)->dynamic_sections_needed
)
1396 *sdynptr
= bfd_get_section_by_name (dynobj
, ".dynamic");
1398 /* The .dynamic section is always the same size. */
1400 BFD_ASSERT (s
!= NULL
);
1401 s
->_raw_size
= (sizeof (struct external_sun4_dynamic
)
1402 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
1403 + sizeof (struct external_sun4_dynamic_link
));
1405 /* Set the size of the .dynsym and .hash sections. We counted
1406 the number of dynamic symbols as we read the input files. We
1407 will build the dynamic symbol table (.dynsym) and the hash
1408 table (.hash) when we build the final symbol table, because
1409 until then we do not know the correct value to give the
1410 symbols. We build the dynamic symbol string table (.dynstr)
1411 in a traversal of the symbol table using
1412 sunos_scan_dynamic_symbol. */
1413 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
1414 BFD_ASSERT (s
!= NULL
);
1415 s
->_raw_size
= dynsymcount
* sizeof (struct external_nlist
);
1416 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
1417 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1420 /* The number of buckets is just the number of symbols divided
1421 by four. To compute the final size of the hash table, we
1422 must actually compute the hash table. Normally we need
1423 exactly as many entries in the hash table as there are
1424 dynamic symbols, but if some of the buckets are not used we
1425 will need additional entries. In the worst case, every
1426 symbol will hash to the same bucket, and we will need
1427 BUCKETCOUNT - 1 extra entries. */
1428 if (dynsymcount
>= 4)
1429 bucketcount
= dynsymcount
/ 4;
1430 else if (dynsymcount
> 0)
1431 bucketcount
= dynsymcount
;
1434 s
= bfd_get_section_by_name (dynobj
, ".hash");
1435 BFD_ASSERT (s
!= NULL
);
1436 hashalloc
= (dynsymcount
+ bucketcount
- 1) * HASH_ENTRY_SIZE
;
1437 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, hashalloc
);
1438 if (s
->contents
== NULL
&& dynsymcount
> 0)
1440 memset (s
->contents
, 0, (size_t) hashalloc
);
1441 for (i
= 0; i
< bucketcount
; i
++)
1442 PUT_WORD (output_bfd
, (bfd_vma
) -1, s
->contents
+ i
* HASH_ENTRY_SIZE
);
1443 s
->_raw_size
= bucketcount
* HASH_ENTRY_SIZE
;
1445 sunos_hash_table (info
)->bucketcount
= bucketcount
;
1447 /* Scan all the symbols, place them in the dynamic symbol table,
1448 and build the dynamic hash table. We reuse dynsymcount as a
1449 counter for the number of symbols we have added so far. */
1450 sunos_hash_table (info
)->dynsymcount
= 0;
1451 sunos_link_hash_traverse (sunos_hash_table (info
),
1452 sunos_scan_dynamic_symbol
,
1454 BFD_ASSERT (sunos_hash_table (info
)->dynsymcount
== dynsymcount
);
1456 /* The SunOS native linker seems to align the total size of the
1457 symbol strings to a multiple of 8. I don't know if this is
1458 important, but it can't hurt much. */
1459 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
1460 BFD_ASSERT (s
!= NULL
);
1461 if ((s
->_raw_size
& 7) != 0)
1466 add
= 8 - (s
->_raw_size
& 7);
1467 contents
= (bfd_byte
*) bfd_realloc (s
->contents
,
1468 s
->_raw_size
+ add
);
1469 if (contents
== NULL
)
1471 memset (contents
+ s
->_raw_size
, 0, (size_t) add
);
1472 s
->contents
= contents
;
1473 s
->_raw_size
+= add
;
1477 /* Now that we have worked out the sizes of the procedure linkage
1478 table and the dynamic relocs, allocate storage for them. */
1479 s
= bfd_get_section_by_name (dynobj
, ".plt");
1480 BFD_ASSERT (s
!= NULL
);
1481 if (s
->_raw_size
!= 0)
1483 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
1484 if (s
->contents
== NULL
)
1487 /* Fill in the first entry in the table. */
1488 switch (bfd_get_arch (dynobj
))
1490 case bfd_arch_sparc
:
1491 memcpy (s
->contents
, sparc_plt_first_entry
, SPARC_PLT_ENTRY_SIZE
);
1495 memcpy (s
->contents
, m68k_plt_first_entry
, M68K_PLT_ENTRY_SIZE
);
1503 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
1504 if (s
->_raw_size
!= 0)
1506 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
1507 if (s
->contents
== NULL
)
1510 /* We use the reloc_count field to keep track of how many of the
1511 relocs we have output so far. */
1514 /* Make space for the global offset table. */
1515 s
= bfd_get_section_by_name (dynobj
, ".got");
1516 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
1517 if (s
->contents
== NULL
)
1520 *sneedptr
= bfd_get_section_by_name (dynobj
, ".need");
1521 *srulesptr
= bfd_get_section_by_name (dynobj
, ".rules");
1526 /* Scan the relocs for an input section. */
1529 sunos_scan_relocs (info
, abfd
, sec
, rel_size
)
1530 struct bfd_link_info
*info
;
1533 bfd_size_type rel_size
;
1536 PTR free_relocs
= NULL
;
1541 if (! info
->keep_memory
)
1542 relocs
= free_relocs
= bfd_malloc (rel_size
);
1545 struct aout_section_data_struct
*n
;
1546 bfd_size_type amt
= sizeof (struct aout_section_data_struct
);
1548 n
= (struct aout_section_data_struct
*) bfd_alloc (abfd
, amt
);
1553 set_aout_section_data (sec
, n
);
1554 relocs
= bfd_malloc (rel_size
);
1555 aout_section_data (sec
)->relocs
= relocs
;
1561 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
1562 || bfd_bread (relocs
, rel_size
, abfd
) != rel_size
)
1565 if (obj_reloc_entry_size (abfd
) == RELOC_STD_SIZE
)
1567 if (! sunos_scan_std_relocs (info
, abfd
, sec
,
1568 (struct reloc_std_external
*) relocs
,
1574 if (! sunos_scan_ext_relocs (info
, abfd
, sec
,
1575 (struct reloc_ext_external
*) relocs
,
1580 if (free_relocs
!= NULL
)
1586 if (free_relocs
!= NULL
)
1591 /* Scan the relocs for an input section using standard relocs. We
1592 need to figure out what to do for each reloc against a dynamic
1593 symbol. If the symbol is in the .text section, an entry is made in
1594 the procedure linkage table. Note that this will do the wrong
1595 thing if the symbol is actually data; I don't think the Sun 3
1596 native linker handles this case correctly either. If the symbol is
1597 not in the .text section, we must preserve the reloc as a dynamic
1598 reloc. FIXME: We should also handle the PIC relocs here by
1599 building global offset table entries. */
1602 sunos_scan_std_relocs (info
, abfd
, sec
, relocs
, rel_size
)
1603 struct bfd_link_info
*info
;
1605 asection
*sec ATTRIBUTE_UNUSED
;
1606 const struct reloc_std_external
*relocs
;
1607 bfd_size_type rel_size
;
1610 asection
*splt
= NULL
;
1611 asection
*srel
= NULL
;
1612 struct sunos_link_hash_entry
**sym_hashes
;
1613 const struct reloc_std_external
*rel
, *relend
;
1615 /* We only know how to handle m68k plt entries. */
1616 if (bfd_get_arch (abfd
) != bfd_arch_m68k
)
1618 bfd_set_error (bfd_error_invalid_target
);
1624 sym_hashes
= (struct sunos_link_hash_entry
**) obj_aout_sym_hashes (abfd
);
1626 relend
= relocs
+ rel_size
/ RELOC_STD_SIZE
;
1627 for (rel
= relocs
; rel
< relend
; rel
++)
1630 struct sunos_link_hash_entry
*h
;
1632 /* We only want relocs against external symbols. */
1633 if (bfd_header_big_endian (abfd
))
1635 if ((rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
) == 0)
1640 if ((rel
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
) == 0)
1644 /* Get the symbol index. */
1645 if (bfd_header_big_endian (abfd
))
1646 r_index
= ((rel
->r_index
[0] << 16)
1647 | (rel
->r_index
[1] << 8)
1650 r_index
= ((rel
->r_index
[2] << 16)
1651 | (rel
->r_index
[1] << 8)
1654 /* Get the hash table entry. */
1655 h
= sym_hashes
[r_index
];
1658 /* This should not normally happen, but it will in any case
1659 be caught in the relocation phase. */
1663 /* At this point common symbols have already been allocated, so
1664 we don't have to worry about them. We need to consider that
1665 we may have already seen this symbol and marked it undefined;
1666 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1668 if (h
->root
.root
.type
!= bfd_link_hash_defined
1669 && h
->root
.root
.type
!= bfd_link_hash_defweak
1670 && h
->root
.root
.type
!= bfd_link_hash_undefined
)
1673 if ((h
->flags
& SUNOS_DEF_DYNAMIC
) == 0
1674 || (h
->flags
& SUNOS_DEF_REGULAR
) != 0)
1681 if (! sunos_create_dynamic_sections (abfd
, info
, false))
1683 dynobj
= sunos_hash_table (info
)->dynobj
;
1684 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1685 srel
= bfd_get_section_by_name (dynobj
, ".dynrel");
1686 BFD_ASSERT (splt
!= NULL
&& srel
!= NULL
);
1688 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1689 BFD_ASSERT (sgot
!= NULL
);
1690 if (sgot
->_raw_size
== 0)
1691 sgot
->_raw_size
= BYTES_IN_WORD
;
1692 sunos_hash_table (info
)->got_needed
= true;
1695 BFD_ASSERT ((h
->flags
& SUNOS_REF_REGULAR
) != 0);
1696 BFD_ASSERT (h
->plt_offset
!= 0
1697 || ((h
->root
.root
.type
== bfd_link_hash_defined
1698 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1699 ? (h
->root
.root
.u
.def
.section
->owner
->flags
1701 : (h
->root
.root
.u
.undef
.abfd
->flags
& DYNAMIC
) != 0));
1703 /* This reloc is against a symbol defined only by a dynamic
1706 if (h
->root
.root
.type
== bfd_link_hash_undefined
)
1708 /* Presumably this symbol was marked as being undefined by
1709 an earlier reloc. */
1710 srel
->_raw_size
+= RELOC_STD_SIZE
;
1712 else if ((h
->root
.root
.u
.def
.section
->flags
& SEC_CODE
) == 0)
1716 /* This reloc is not in the .text section. It must be
1717 copied into the dynamic relocs. We mark the symbol as
1719 srel
->_raw_size
+= RELOC_STD_SIZE
;
1720 sub
= h
->root
.root
.u
.def
.section
->owner
;
1721 h
->root
.root
.type
= bfd_link_hash_undefined
;
1722 h
->root
.root
.u
.undef
.abfd
= sub
;
1726 /* This symbol is in the .text section. We must give it an
1727 entry in the procedure linkage table, if we have not
1728 already done so. We change the definition of the symbol
1729 to the .plt section; this will cause relocs against it to
1730 be handled correctly. */
1731 if (h
->plt_offset
== 0)
1733 if (splt
->_raw_size
== 0)
1734 splt
->_raw_size
= M68K_PLT_ENTRY_SIZE
;
1735 h
->plt_offset
= splt
->_raw_size
;
1737 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0)
1739 h
->root
.root
.u
.def
.section
= splt
;
1740 h
->root
.root
.u
.def
.value
= splt
->_raw_size
;
1743 splt
->_raw_size
+= M68K_PLT_ENTRY_SIZE
;
1745 /* We may also need a dynamic reloc entry. */
1746 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0)
1747 srel
->_raw_size
+= RELOC_STD_SIZE
;
1755 /* Scan the relocs for an input section using extended relocs. We
1756 need to figure out what to do for each reloc against a dynamic
1757 symbol. If the reloc is a WDISP30, and the symbol is in the .text
1758 section, an entry is made in the procedure linkage table.
1759 Otherwise, we must preserve the reloc as a dynamic reloc. */
1762 sunos_scan_ext_relocs (info
, abfd
, sec
, relocs
, rel_size
)
1763 struct bfd_link_info
*info
;
1765 asection
*sec ATTRIBUTE_UNUSED
;
1766 const struct reloc_ext_external
*relocs
;
1767 bfd_size_type rel_size
;
1770 struct sunos_link_hash_entry
**sym_hashes
;
1771 const struct reloc_ext_external
*rel
, *relend
;
1772 asection
*splt
= NULL
;
1773 asection
*sgot
= NULL
;
1774 asection
*srel
= NULL
;
1777 /* We only know how to handle SPARC plt entries. */
1778 if (bfd_get_arch (abfd
) != bfd_arch_sparc
)
1780 bfd_set_error (bfd_error_invalid_target
);
1786 sym_hashes
= (struct sunos_link_hash_entry
**) obj_aout_sym_hashes (abfd
);
1788 relend
= relocs
+ rel_size
/ RELOC_EXT_SIZE
;
1789 for (rel
= relocs
; rel
< relend
; rel
++)
1791 unsigned int r_index
;
1794 struct sunos_link_hash_entry
*h
= NULL
;
1796 /* Swap in the reloc information. */
1797 if (bfd_header_big_endian (abfd
))
1799 r_index
= ((rel
->r_index
[0] << 16)
1800 | (rel
->r_index
[1] << 8)
1802 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
1803 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
1804 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
1808 r_index
= ((rel
->r_index
[2] << 16)
1809 | (rel
->r_index
[1] << 8)
1811 r_extern
= (0 != (rel
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
1812 r_type
= ((rel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
1813 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
1818 h
= sym_hashes
[r_index
];
1821 /* This should not normally happen, but it will in any
1822 case be caught in the relocation phase. */
1827 /* If this is a base relative reloc, we need to make an entry in
1828 the .got section. */
1829 if (r_type
== RELOC_BASE10
1830 || r_type
== RELOC_BASE13
1831 || r_type
== RELOC_BASE22
)
1835 if (! sunos_create_dynamic_sections (abfd
, info
, false))
1837 dynobj
= sunos_hash_table (info
)->dynobj
;
1838 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1839 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1840 srel
= bfd_get_section_by_name (dynobj
, ".dynrel");
1841 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
1843 /* Make sure we have an initial entry in the .got table. */
1844 if (sgot
->_raw_size
== 0)
1845 sgot
->_raw_size
= BYTES_IN_WORD
;
1846 sunos_hash_table (info
)->got_needed
= true;
1851 if (h
->got_offset
!= 0)
1854 h
->got_offset
= sgot
->_raw_size
;
1858 if (r_index
>= bfd_get_symcount (abfd
))
1860 /* This is abnormal, but should be caught in the
1861 relocation phase. */
1865 if (adata (abfd
).local_got_offsets
== NULL
)
1867 amt
= bfd_get_symcount (abfd
);
1868 amt
*= sizeof (bfd_vma
);
1869 adata (abfd
).local_got_offsets
=
1870 (bfd_vma
*) bfd_zalloc (abfd
, amt
);
1871 if (adata (abfd
).local_got_offsets
== NULL
)
1875 if (adata (abfd
).local_got_offsets
[r_index
] != 0)
1878 adata (abfd
).local_got_offsets
[r_index
] = sgot
->_raw_size
;
1881 sgot
->_raw_size
+= BYTES_IN_WORD
;
1883 /* If we are making a shared library, or if the symbol is
1884 defined by a dynamic object, we will need a dynamic reloc
1888 && (h
->flags
& SUNOS_DEF_DYNAMIC
) != 0
1889 && (h
->flags
& SUNOS_DEF_REGULAR
) == 0))
1890 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1895 /* Otherwise, we are only interested in relocs against symbols
1896 defined in dynamic objects but not in regular objects. We
1897 only need to consider relocs against external symbols. */
1900 /* But, if we are creating a shared library, we need to
1901 generate an absolute reloc. */
1906 if (! sunos_create_dynamic_sections (abfd
, info
, true))
1908 dynobj
= sunos_hash_table (info
)->dynobj
;
1909 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1910 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1911 srel
= bfd_get_section_by_name (dynobj
, ".dynrel");
1912 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
1915 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1921 /* At this point common symbols have already been allocated, so
1922 we don't have to worry about them. We need to consider that
1923 we may have already seen this symbol and marked it undefined;
1924 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1926 if (h
->root
.root
.type
!= bfd_link_hash_defined
1927 && h
->root
.root
.type
!= bfd_link_hash_defweak
1928 && h
->root
.root
.type
!= bfd_link_hash_undefined
)
1931 if (r_type
!= RELOC_JMP_TBL
1933 && ((h
->flags
& SUNOS_DEF_DYNAMIC
) == 0
1934 || (h
->flags
& SUNOS_DEF_REGULAR
) != 0))
1937 if (r_type
== RELOC_JMP_TBL
1939 && (h
->flags
& SUNOS_DEF_DYNAMIC
) == 0
1940 && (h
->flags
& SUNOS_DEF_REGULAR
) == 0)
1942 /* This symbol is apparently undefined. Don't do anything
1943 here; just let the relocation routine report an undefined
1948 if (strcmp (h
->root
.root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
1953 if (! sunos_create_dynamic_sections (abfd
, info
, false))
1955 dynobj
= sunos_hash_table (info
)->dynobj
;
1956 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1957 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1958 srel
= bfd_get_section_by_name (dynobj
, ".dynrel");
1959 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
1961 /* Make sure we have an initial entry in the .got table. */
1962 if (sgot
->_raw_size
== 0)
1963 sgot
->_raw_size
= BYTES_IN_WORD
;
1964 sunos_hash_table (info
)->got_needed
= true;
1967 BFD_ASSERT (r_type
== RELOC_JMP_TBL
1969 || (h
->flags
& SUNOS_REF_REGULAR
) != 0);
1970 BFD_ASSERT (r_type
== RELOC_JMP_TBL
1972 || h
->plt_offset
!= 0
1973 || ((h
->root
.root
.type
== bfd_link_hash_defined
1974 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1975 ? (h
->root
.root
.u
.def
.section
->owner
->flags
1977 : (h
->root
.root
.u
.undef
.abfd
->flags
& DYNAMIC
) != 0));
1979 /* This reloc is against a symbol defined only by a dynamic
1980 object, or it is a jump table reloc from PIC compiled code. */
1982 if (r_type
!= RELOC_JMP_TBL
1983 && h
->root
.root
.type
== bfd_link_hash_undefined
)
1985 /* Presumably this symbol was marked as being undefined by
1986 an earlier reloc. */
1987 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1989 else if (r_type
!= RELOC_JMP_TBL
1990 && (h
->root
.root
.u
.def
.section
->flags
& SEC_CODE
) == 0)
1994 /* This reloc is not in the .text section. It must be
1995 copied into the dynamic relocs. We mark the symbol as
1997 srel
->_raw_size
+= RELOC_EXT_SIZE
;
1998 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0)
2000 sub
= h
->root
.root
.u
.def
.section
->owner
;
2001 h
->root
.root
.type
= bfd_link_hash_undefined
;
2002 h
->root
.root
.u
.undef
.abfd
= sub
;
2007 /* This symbol is in the .text section. We must give it an
2008 entry in the procedure linkage table, if we have not
2009 already done so. We change the definition of the symbol
2010 to the .plt section; this will cause relocs against it to
2011 be handled correctly. */
2012 if (h
->plt_offset
== 0)
2014 if (splt
->_raw_size
== 0)
2015 splt
->_raw_size
= SPARC_PLT_ENTRY_SIZE
;
2016 h
->plt_offset
= splt
->_raw_size
;
2018 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0)
2020 if (h
->root
.root
.type
== bfd_link_hash_undefined
)
2021 h
->root
.root
.type
= bfd_link_hash_defined
;
2022 h
->root
.root
.u
.def
.section
= splt
;
2023 h
->root
.root
.u
.def
.value
= splt
->_raw_size
;
2026 splt
->_raw_size
+= SPARC_PLT_ENTRY_SIZE
;
2028 /* We will also need a dynamic reloc entry, unless this
2029 is a JMP_TBL reloc produced by linking PIC compiled
2030 code, and we are not making a shared library. */
2031 if (info
->shared
|| (h
->flags
& SUNOS_DEF_REGULAR
) == 0)
2032 srel
->_raw_size
+= RELOC_EXT_SIZE
;
2035 /* If we are creating a shared library, we need to copy over
2036 any reloc other than a jump table reloc. */
2037 if (info
->shared
&& r_type
!= RELOC_JMP_TBL
)
2038 srel
->_raw_size
+= RELOC_EXT_SIZE
;
2045 /* Build the hash table of dynamic symbols, and to mark as written all
2046 symbols from dynamic objects which we do not plan to write out. */
2049 sunos_scan_dynamic_symbol (h
, data
)
2050 struct sunos_link_hash_entry
*h
;
2053 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
2055 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2056 h
= (struct sunos_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2058 /* Set the written flag for symbols we do not want to write out as
2059 part of the regular symbol table. This is all symbols which are
2060 not defined in a regular object file. For some reason symbols
2061 which are referenced by a regular object and defined by a dynamic
2062 object do not seem to show up in the regular symbol table. It is
2063 possible for a symbol to have only SUNOS_REF_REGULAR set here, it
2064 is an undefined symbol which was turned into a common symbol
2065 because it was found in an archive object which was not included
2067 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0
2068 && (h
->flags
& SUNOS_DEF_DYNAMIC
) != 0
2069 && strcmp (h
->root
.root
.root
.string
, "__DYNAMIC") != 0)
2070 h
->root
.written
= true;
2072 /* If this symbol is defined by a dynamic object and referenced by a
2073 regular object, see whether we gave it a reasonable value while
2074 scanning the relocs. */
2076 if ((h
->flags
& SUNOS_DEF_REGULAR
) == 0
2077 && (h
->flags
& SUNOS_DEF_DYNAMIC
) != 0
2078 && (h
->flags
& SUNOS_REF_REGULAR
) != 0)
2080 if ((h
->root
.root
.type
== bfd_link_hash_defined
2081 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2082 && ((h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
) != 0)
2083 && h
->root
.root
.u
.def
.section
->output_section
== NULL
)
2087 /* This symbol is currently defined in a dynamic section
2088 which is not being put into the output file. This
2089 implies that there is no reloc against the symbol. I'm
2090 not sure why this case would ever occur. In any case, we
2091 change the symbol to be undefined. */
2092 sub
= h
->root
.root
.u
.def
.section
->owner
;
2093 h
->root
.root
.type
= bfd_link_hash_undefined
;
2094 h
->root
.root
.u
.undef
.abfd
= sub
;
2098 /* If this symbol is defined or referenced by a regular file, add it
2099 to the dynamic symbols. */
2100 if ((h
->flags
& (SUNOS_DEF_REGULAR
| SUNOS_REF_REGULAR
)) != 0)
2105 unsigned char *name
;
2109 BFD_ASSERT (h
->dynindx
== -2);
2111 dynobj
= sunos_hash_table (info
)->dynobj
;
2113 h
->dynindx
= sunos_hash_table (info
)->dynsymcount
;
2114 ++sunos_hash_table (info
)->dynsymcount
;
2116 len
= strlen (h
->root
.root
.root
.string
);
2118 /* We don't bother to construct a BFD hash table for the strings
2119 which are the names of the dynamic symbols. Using a hash
2120 table for the regular symbols is beneficial, because the
2121 regular symbols includes the debugging symbols, which have
2122 long names and are often duplicated in several object files.
2123 There are no debugging symbols in the dynamic symbols. */
2124 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
2125 BFD_ASSERT (s
!= NULL
);
2126 contents
= (bfd_byte
*) bfd_realloc (s
->contents
,
2127 s
->_raw_size
+ len
+ 1);
2128 if (contents
== NULL
)
2130 s
->contents
= contents
;
2132 h
->dynstr_index
= s
->_raw_size
;
2133 strcpy ((char *) contents
+ s
->_raw_size
, h
->root
.root
.root
.string
);
2134 s
->_raw_size
+= len
+ 1;
2136 /* Add it to the dynamic hash table. */
2137 name
= (unsigned char *) h
->root
.root
.root
.string
;
2139 while (*name
!= '\0')
2140 hash
= (hash
<< 1) + *name
++;
2142 hash
%= sunos_hash_table (info
)->bucketcount
;
2144 s
= bfd_get_section_by_name (dynobj
, ".hash");
2145 BFD_ASSERT (s
!= NULL
);
2147 if (GET_SWORD (dynobj
, s
->contents
+ hash
* HASH_ENTRY_SIZE
) == -1)
2148 PUT_WORD (dynobj
, h
->dynindx
, s
->contents
+ hash
* HASH_ENTRY_SIZE
);
2153 next
= GET_WORD (dynobj
,
2155 + hash
* HASH_ENTRY_SIZE
2157 PUT_WORD (dynobj
, s
->_raw_size
/ HASH_ENTRY_SIZE
,
2158 s
->contents
+ hash
* HASH_ENTRY_SIZE
+ BYTES_IN_WORD
);
2159 PUT_WORD (dynobj
, h
->dynindx
, s
->contents
+ s
->_raw_size
);
2160 PUT_WORD (dynobj
, next
, s
->contents
+ s
->_raw_size
+ BYTES_IN_WORD
);
2161 s
->_raw_size
+= HASH_ENTRY_SIZE
;
2168 /* Link a dynamic object. We actually don't have anything to do at
2169 this point. This entry point exists to prevent the regular linker
2170 code from doing anything with the object. */
2174 sunos_link_dynamic_object (info
, abfd
)
2175 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2176 bfd
*abfd ATTRIBUTE_UNUSED
;
2181 /* Write out a dynamic symbol. This is called by the final traversal
2182 over the symbol table. */
2185 sunos_write_dynamic_symbol (output_bfd
, info
, harg
)
2187 struct bfd_link_info
*info
;
2188 struct aout_link_hash_entry
*harg
;
2190 struct sunos_link_hash_entry
*h
= (struct sunos_link_hash_entry
*) harg
;
2194 struct external_nlist
*outsym
;
2196 /* If this symbol is in the procedure linkage table, fill in the
2198 if (h
->plt_offset
!= 0)
2205 dynobj
= sunos_hash_table (info
)->dynobj
;
2206 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2207 p
= splt
->contents
+ h
->plt_offset
;
2209 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
2211 r_address
= (splt
->output_section
->vma
2212 + splt
->output_offset
2215 switch (bfd_get_arch (output_bfd
))
2217 case bfd_arch_sparc
:
2218 if (info
->shared
|| (h
->flags
& SUNOS_DEF_REGULAR
) == 0)
2220 bfd_put_32 (output_bfd
, SPARC_PLT_ENTRY_WORD0
, p
);
2221 bfd_put_32 (output_bfd
,
2222 (SPARC_PLT_ENTRY_WORD1
2223 + (((- (h
->plt_offset
+ 4) >> 2)
2226 bfd_put_32 (output_bfd
, SPARC_PLT_ENTRY_WORD2
+ s
->reloc_count
,
2231 val
= (h
->root
.root
.u
.def
.section
->output_section
->vma
2232 + h
->root
.root
.u
.def
.section
->output_offset
2233 + h
->root
.root
.u
.def
.value
);
2234 bfd_put_32 (output_bfd
,
2235 SPARC_PLT_PIC_WORD0
+ ((val
>> 10) & 0x3fffff),
2237 bfd_put_32 (output_bfd
,
2238 SPARC_PLT_PIC_WORD1
+ (val
& 0x3ff),
2240 bfd_put_32 (output_bfd
, SPARC_PLT_PIC_WORD2
, p
+ 8);
2245 if (! info
->shared
&& (h
->flags
& SUNOS_DEF_REGULAR
) != 0)
2247 bfd_put_16 (output_bfd
, M68K_PLT_ENTRY_WORD0
, p
);
2248 bfd_put_32 (output_bfd
, (- (h
->plt_offset
+ 2)), p
+ 2);
2249 bfd_put_16 (output_bfd
, (bfd_vma
) s
->reloc_count
, p
+ 6);
2257 /* We also need to add a jump table reloc, unless this is the
2258 result of a JMP_TBL reloc from PIC compiled code. */
2259 if (info
->shared
|| (h
->flags
& SUNOS_DEF_REGULAR
) == 0)
2261 BFD_ASSERT (h
->dynindx
>= 0);
2262 BFD_ASSERT (s
->reloc_count
* obj_reloc_entry_size (dynobj
)
2264 p
= s
->contents
+ s
->reloc_count
* obj_reloc_entry_size (output_bfd
);
2265 if (obj_reloc_entry_size (output_bfd
) == RELOC_STD_SIZE
)
2267 struct reloc_std_external
*srel
;
2269 srel
= (struct reloc_std_external
*) p
;
2270 PUT_WORD (output_bfd
, r_address
, srel
->r_address
);
2271 if (bfd_header_big_endian (output_bfd
))
2273 srel
->r_index
[0] = (bfd_byte
) (h
->dynindx
>> 16);
2274 srel
->r_index
[1] = (bfd_byte
) (h
->dynindx
>> 8);
2275 srel
->r_index
[2] = (bfd_byte
) (h
->dynindx
);
2276 srel
->r_type
[0] = (RELOC_STD_BITS_EXTERN_BIG
2277 | RELOC_STD_BITS_JMPTABLE_BIG
);
2281 srel
->r_index
[2] = (bfd_byte
) (h
->dynindx
>> 16);
2282 srel
->r_index
[1] = (bfd_byte
) (h
->dynindx
>> 8);
2283 srel
->r_index
[0] = (bfd_byte
)h
->dynindx
;
2284 srel
->r_type
[0] = (RELOC_STD_BITS_EXTERN_LITTLE
2285 | RELOC_STD_BITS_JMPTABLE_LITTLE
);
2290 struct reloc_ext_external
*erel
;
2292 erel
= (struct reloc_ext_external
*) p
;
2293 PUT_WORD (output_bfd
, r_address
, erel
->r_address
);
2294 if (bfd_header_big_endian (output_bfd
))
2296 erel
->r_index
[0] = (bfd_byte
) (h
->dynindx
>> 16);
2297 erel
->r_index
[1] = (bfd_byte
) (h
->dynindx
>> 8);
2298 erel
->r_index
[2] = (bfd_byte
)h
->dynindx
;
2300 (RELOC_EXT_BITS_EXTERN_BIG
2301 | (RELOC_JMP_SLOT
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2305 erel
->r_index
[2] = (bfd_byte
) (h
->dynindx
>> 16);
2306 erel
->r_index
[1] = (bfd_byte
) (h
->dynindx
>> 8);
2307 erel
->r_index
[0] = (bfd_byte
)h
->dynindx
;
2309 (RELOC_EXT_BITS_EXTERN_LITTLE
2310 | (RELOC_JMP_SLOT
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
));
2312 PUT_WORD (output_bfd
, (bfd_vma
) 0, erel
->r_addend
);
2319 /* If this is not a dynamic symbol, we don't have to do anything
2320 else. We only check this after handling the PLT entry, because
2321 we can have a PLT entry for a nondynamic symbol when linking PIC
2322 compiled code from a regular object. */
2326 switch (h
->root
.root
.type
)
2329 case bfd_link_hash_new
:
2331 /* Avoid variable not initialized warnings. */
2333 case bfd_link_hash_undefined
:
2334 type
= N_UNDF
| N_EXT
;
2337 case bfd_link_hash_defined
:
2338 case bfd_link_hash_defweak
:
2341 asection
*output_section
;
2343 sec
= h
->root
.root
.u
.def
.section
;
2344 output_section
= sec
->output_section
;
2345 BFD_ASSERT (bfd_is_abs_section (output_section
)
2346 || output_section
->owner
== output_bfd
);
2347 if (h
->plt_offset
!= 0
2348 && (h
->flags
& SUNOS_DEF_REGULAR
) == 0)
2350 type
= N_UNDF
| N_EXT
;
2355 if (output_section
== obj_textsec (output_bfd
))
2356 type
= (h
->root
.root
.type
== bfd_link_hash_defined
2359 else if (output_section
== obj_datasec (output_bfd
))
2360 type
= (h
->root
.root
.type
== bfd_link_hash_defined
2363 else if (output_section
== obj_bsssec (output_bfd
))
2364 type
= (h
->root
.root
.type
== bfd_link_hash_defined
2368 type
= (h
->root
.root
.type
== bfd_link_hash_defined
2372 val
= (h
->root
.root
.u
.def
.value
2373 + output_section
->vma
2374 + sec
->output_offset
);
2378 case bfd_link_hash_common
:
2379 type
= N_UNDF
| N_EXT
;
2380 val
= h
->root
.root
.u
.c
.size
;
2382 case bfd_link_hash_undefweak
:
2386 case bfd_link_hash_indirect
:
2387 case bfd_link_hash_warning
:
2388 /* FIXME: Ignore these for now. The circumstances under which
2389 they should be written out are not clear to me. */
2393 s
= bfd_get_section_by_name (sunos_hash_table (info
)->dynobj
, ".dynsym");
2394 BFD_ASSERT (s
!= NULL
);
2395 outsym
= ((struct external_nlist
*)
2396 (s
->contents
+ h
->dynindx
* EXTERNAL_NLIST_SIZE
));
2398 H_PUT_8 (output_bfd
, type
, outsym
->e_type
);
2399 H_PUT_8 (output_bfd
, 0, outsym
->e_other
);
2401 /* FIXME: The native linker doesn't use 0 for desc. It seems to use
2402 one less than the desc value in the shared library, although that
2404 H_PUT_16 (output_bfd
, 0, outsym
->e_desc
);
2406 PUT_WORD (output_bfd
, h
->dynstr_index
, outsym
->e_strx
);
2407 PUT_WORD (output_bfd
, val
, outsym
->e_value
);
2412 /* This is called for each reloc against an external symbol. If this
2413 is a reloc which are are going to copy as a dynamic reloc, then
2414 copy it over, and tell the caller to not bother processing this
2419 sunos_check_dynamic_reloc (info
, input_bfd
, input_section
, harg
, reloc
,
2420 contents
, skip
, relocationp
)
2421 struct bfd_link_info
*info
;
2423 asection
*input_section
;
2424 struct aout_link_hash_entry
*harg
;
2426 bfd_byte
*contents ATTRIBUTE_UNUSED
;
2428 bfd_vma
*relocationp
;
2430 struct sunos_link_hash_entry
*h
= (struct sunos_link_hash_entry
*) harg
;
2441 dynobj
= sunos_hash_table (info
)->dynobj
;
2444 && h
->plt_offset
!= 0
2446 || (h
->flags
& SUNOS_DEF_REGULAR
) == 0))
2450 /* Redirect the relocation to the PLT entry. */
2451 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2452 *relocationp
= (splt
->output_section
->vma
2453 + splt
->output_offset
2457 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
2459 struct reloc_std_external
*srel
;
2461 srel
= (struct reloc_std_external
*) reloc
;
2462 if (bfd_header_big_endian (input_bfd
))
2464 baserel
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
2465 jmptbl
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
2466 pcrel
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
2470 baserel
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
2471 jmptbl
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
2472 pcrel
= (0 != (srel
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
2477 struct reloc_ext_external
*erel
;
2480 erel
= (struct reloc_ext_external
*) reloc
;
2481 if (bfd_header_big_endian (input_bfd
))
2482 r_type
= ((erel
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
2483 >> RELOC_EXT_BITS_TYPE_SH_BIG
);
2485 r_type
= ((erel
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
2486 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
);
2487 baserel
= (r_type
== RELOC_BASE10
2488 || r_type
== RELOC_BASE13
2489 || r_type
== RELOC_BASE22
);
2490 jmptbl
= r_type
== RELOC_JMP_TBL
;
2491 pcrel
= (r_type
== RELOC_DISP8
2492 || r_type
== RELOC_DISP16
2493 || r_type
== RELOC_DISP32
2494 || r_type
== RELOC_WDISP30
2495 || r_type
== RELOC_WDISP22
);
2496 /* We don't consider the PC10 and PC22 types to be PC relative,
2497 because they are pcrel_offset. */
2502 bfd_vma
*got_offsetp
;
2506 got_offsetp
= &h
->got_offset
;
2507 else if (adata (input_bfd
).local_got_offsets
== NULL
)
2511 struct reloc_std_external
*srel
;
2514 srel
= (struct reloc_std_external
*) reloc
;
2515 if (obj_reloc_entry_size (input_bfd
) == RELOC_STD_SIZE
)
2517 if (bfd_header_big_endian (input_bfd
))
2518 r_index
= ((srel
->r_index
[0] << 16)
2519 | (srel
->r_index
[1] << 8)
2520 | srel
->r_index
[2]);
2522 r_index
= ((srel
->r_index
[2] << 16)
2523 | (srel
->r_index
[1] << 8)
2524 | srel
->r_index
[0]);
2528 struct reloc_ext_external
*erel
;
2530 erel
= (struct reloc_ext_external
*) reloc
;
2531 if (bfd_header_big_endian (input_bfd
))
2532 r_index
= ((erel
->r_index
[0] << 16)
2533 | (erel
->r_index
[1] << 8)
2534 | erel
->r_index
[2]);
2536 r_index
= ((erel
->r_index
[2] << 16)
2537 | (erel
->r_index
[1] << 8)
2538 | erel
->r_index
[0]);
2541 got_offsetp
= adata (input_bfd
).local_got_offsets
+ r_index
;
2544 BFD_ASSERT (got_offsetp
!= NULL
&& *got_offsetp
!= 0);
2546 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2548 /* We set the least significant bit to indicate whether we have
2549 already initialized the GOT entry. */
2550 if ((*got_offsetp
& 1) == 0)
2554 && ((h
->flags
& SUNOS_DEF_DYNAMIC
) == 0
2555 || (h
->flags
& SUNOS_DEF_REGULAR
) != 0)))
2556 PUT_WORD (dynobj
, *relocationp
, sgot
->contents
+ *got_offsetp
);
2558 PUT_WORD (dynobj
, 0, sgot
->contents
+ *got_offsetp
);
2562 && (h
->flags
& SUNOS_DEF_DYNAMIC
) != 0
2563 && (h
->flags
& SUNOS_DEF_REGULAR
) == 0))
2565 /* We need to create a GLOB_DAT or 32 reloc to tell the
2566 dynamic linker to fill in this entry in the table. */
2568 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
2569 BFD_ASSERT (s
!= NULL
);
2570 BFD_ASSERT (s
->reloc_count
* obj_reloc_entry_size (dynobj
)
2574 + s
->reloc_count
* obj_reloc_entry_size (dynobj
));
2581 if (obj_reloc_entry_size (dynobj
) == RELOC_STD_SIZE
)
2583 struct reloc_std_external
*srel
;
2585 srel
= (struct reloc_std_external
*) p
;
2588 + sgot
->output_section
->vma
2589 + sgot
->output_offset
),
2591 if (bfd_header_big_endian (dynobj
))
2593 srel
->r_index
[0] = (bfd_byte
) (indx
>> 16);
2594 srel
->r_index
[1] = (bfd_byte
) (indx
>> 8);
2595 srel
->r_index
[2] = (bfd_byte
)indx
;
2597 srel
->r_type
[0] = 2 << RELOC_STD_BITS_LENGTH_SH_BIG
;
2600 (RELOC_STD_BITS_EXTERN_BIG
2601 | RELOC_STD_BITS_BASEREL_BIG
2602 | RELOC_STD_BITS_RELATIVE_BIG
2603 | (2 << RELOC_STD_BITS_LENGTH_SH_BIG
));
2607 srel
->r_index
[2] = (bfd_byte
) (indx
>> 16);
2608 srel
->r_index
[1] = (bfd_byte
) (indx
>> 8);
2609 srel
->r_index
[0] = (bfd_byte
)indx
;
2611 srel
->r_type
[0] = 2 << RELOC_STD_BITS_LENGTH_SH_LITTLE
;
2614 (RELOC_STD_BITS_EXTERN_LITTLE
2615 | RELOC_STD_BITS_BASEREL_LITTLE
2616 | RELOC_STD_BITS_RELATIVE_LITTLE
2617 | (2 << RELOC_STD_BITS_LENGTH_SH_LITTLE
));
2622 struct reloc_ext_external
*erel
;
2624 erel
= (struct reloc_ext_external
*) p
;
2627 + sgot
->output_section
->vma
2628 + sgot
->output_offset
),
2630 if (bfd_header_big_endian (dynobj
))
2632 erel
->r_index
[0] = (bfd_byte
) (indx
>> 16);
2633 erel
->r_index
[1] = (bfd_byte
) (indx
>> 8);
2634 erel
->r_index
[2] = (bfd_byte
)indx
;
2637 RELOC_32
<< RELOC_EXT_BITS_TYPE_SH_BIG
;
2640 (RELOC_EXT_BITS_EXTERN_BIG
2641 | (RELOC_GLOB_DAT
<< RELOC_EXT_BITS_TYPE_SH_BIG
));
2645 erel
->r_index
[2] = (bfd_byte
) (indx
>> 16);
2646 erel
->r_index
[1] = (bfd_byte
) (indx
>> 8);
2647 erel
->r_index
[0] = (bfd_byte
)indx
;
2650 RELOC_32
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
;
2653 (RELOC_EXT_BITS_EXTERN_LITTLE
2655 << RELOC_EXT_BITS_TYPE_SH_LITTLE
));
2657 PUT_WORD (dynobj
, 0, erel
->r_addend
);
2666 *relocationp
= (sgot
->vma
2667 + (*got_offsetp
&~ (bfd_vma
) 1)
2668 - sunos_hash_table (info
)->got_base
);
2670 /* There is nothing else to do for a base relative reloc. */
2674 if (! sunos_hash_table (info
)->dynamic_sections_needed
)
2680 || h
->root
.root
.type
!= bfd_link_hash_undefined
2681 || (h
->flags
& SUNOS_DEF_REGULAR
) != 0
2682 || (h
->flags
& SUNOS_DEF_DYNAMIC
) == 0
2683 || (h
->root
.root
.u
.undef
.abfd
->flags
& DYNAMIC
) == 0)
2689 && (h
->dynindx
== -1
2691 || strcmp (h
->root
.root
.root
.string
,
2692 "__GLOBAL_OFFSET_TABLE_") == 0))
2696 /* It looks like this is a reloc we are supposed to copy. */
2698 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
2699 BFD_ASSERT (s
!= NULL
);
2700 BFD_ASSERT (s
->reloc_count
* obj_reloc_entry_size (dynobj
) < s
->_raw_size
);
2702 p
= s
->contents
+ s
->reloc_count
* obj_reloc_entry_size (dynobj
);
2704 /* Copy the reloc over. */
2705 memcpy (p
, reloc
, obj_reloc_entry_size (dynobj
));
2712 /* Adjust the address and symbol index. */
2713 if (obj_reloc_entry_size (dynobj
) == RELOC_STD_SIZE
)
2715 struct reloc_std_external
*srel
;
2717 srel
= (struct reloc_std_external
*) p
;
2719 (GET_WORD (dynobj
, srel
->r_address
)
2720 + input_section
->output_section
->vma
2721 + input_section
->output_offset
),
2723 if (bfd_header_big_endian (dynobj
))
2725 srel
->r_index
[0] = (bfd_byte
) (indx
>> 16);
2726 srel
->r_index
[1] = (bfd_byte
) (indx
>> 8);
2727 srel
->r_index
[2] = (bfd_byte
)indx
;
2731 srel
->r_index
[2] = (bfd_byte
) (indx
>> 16);
2732 srel
->r_index
[1] = (bfd_byte
) (indx
>> 8);
2733 srel
->r_index
[0] = (bfd_byte
)indx
;
2735 /* FIXME: We may have to change the addend for a PC relative
2740 struct reloc_ext_external
*erel
;
2742 erel
= (struct reloc_ext_external
*) p
;
2744 (GET_WORD (dynobj
, erel
->r_address
)
2745 + input_section
->output_section
->vma
2746 + input_section
->output_offset
),
2748 if (bfd_header_big_endian (dynobj
))
2750 erel
->r_index
[0] = (bfd_byte
) (indx
>> 16);
2751 erel
->r_index
[1] = (bfd_byte
) (indx
>> 8);
2752 erel
->r_index
[2] = (bfd_byte
)indx
;
2756 erel
->r_index
[2] = (bfd_byte
) (indx
>> 16);
2757 erel
->r_index
[1] = (bfd_byte
) (indx
>> 8);
2758 erel
->r_index
[0] = (bfd_byte
)indx
;
2760 if (pcrel
&& h
!= NULL
)
2762 /* Adjust the addend for the change in address. */
2764 (GET_WORD (dynobj
, erel
->r_addend
)
2765 - (input_section
->output_section
->vma
2766 + input_section
->output_offset
2767 - input_section
->vma
)),
2780 /* Finish up the dynamic linking information. */
2783 sunos_finish_dynamic_link (abfd
, info
)
2785 struct bfd_link_info
*info
;
2792 if (! sunos_hash_table (info
)->dynamic_sections_needed
2793 && ! sunos_hash_table (info
)->got_needed
)
2796 dynobj
= sunos_hash_table (info
)->dynobj
;
2798 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2799 BFD_ASSERT (sdyn
!= NULL
);
2801 /* Finish up the .need section. The linker emulation code filled it
2802 in, but with offsets from the start of the section instead of
2803 real addresses. Now that we know the section location, we can
2804 fill in the final values. */
2805 s
= bfd_get_section_by_name (dynobj
, ".need");
2806 if (s
!= NULL
&& s
->_raw_size
!= 0)
2811 filepos
= s
->output_section
->filepos
+ s
->output_offset
;
2817 PUT_WORD (dynobj
, GET_WORD (dynobj
, p
) + filepos
, p
);
2818 val
= GET_WORD (dynobj
, p
+ 12);
2821 PUT_WORD (dynobj
, val
+ filepos
, p
+ 12);
2826 /* The first entry in the .got section is the address of the
2827 dynamic information, unless this is a shared library. */
2828 s
= bfd_get_section_by_name (dynobj
, ".got");
2829 BFD_ASSERT (s
!= NULL
);
2830 if (info
->shared
|| sdyn
->_raw_size
== 0)
2831 PUT_WORD (dynobj
, 0, s
->contents
);
2833 PUT_WORD (dynobj
, sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2836 for (o
= dynobj
->sections
; o
!= NULL
; o
= o
->next
)
2838 if ((o
->flags
& SEC_HAS_CONTENTS
) != 0
2839 && o
->contents
!= NULL
)
2841 BFD_ASSERT (o
->output_section
!= NULL
2842 && o
->output_section
->owner
== abfd
);
2843 if (! bfd_set_section_contents (abfd
, o
->output_section
,
2845 (file_ptr
) o
->output_offset
,
2851 if (sdyn
->_raw_size
> 0)
2853 struct external_sun4_dynamic esd
;
2854 struct external_sun4_dynamic_link esdl
;
2857 /* Finish up the dynamic link information. */
2858 PUT_WORD (dynobj
, (bfd_vma
) 3, esd
.ld_version
);
2860 sdyn
->output_section
->vma
+ sdyn
->output_offset
+ sizeof esd
,
2863 (sdyn
->output_section
->vma
2864 + sdyn
->output_offset
2866 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
),
2869 if (! bfd_set_section_contents (abfd
, sdyn
->output_section
, &esd
,
2870 (file_ptr
) sdyn
->output_offset
,
2871 (bfd_size_type
) sizeof esd
))
2874 PUT_WORD (dynobj
, (bfd_vma
) 0, esdl
.ld_loaded
);
2876 s
= bfd_get_section_by_name (dynobj
, ".need");
2877 if (s
== NULL
|| s
->_raw_size
== 0)
2878 PUT_WORD (dynobj
, (bfd_vma
) 0, esdl
.ld_need
);
2880 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2883 s
= bfd_get_section_by_name (dynobj
, ".rules");
2884 if (s
== NULL
|| s
->_raw_size
== 0)
2885 PUT_WORD (dynobj
, (bfd_vma
) 0, esdl
.ld_rules
);
2887 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2890 s
= bfd_get_section_by_name (dynobj
, ".got");
2891 BFD_ASSERT (s
!= NULL
);
2892 PUT_WORD (dynobj
, s
->output_section
->vma
+ s
->output_offset
,
2895 s
= bfd_get_section_by_name (dynobj
, ".plt");
2896 BFD_ASSERT (s
!= NULL
);
2897 PUT_WORD (dynobj
, s
->output_section
->vma
+ s
->output_offset
,
2899 PUT_WORD (dynobj
, s
->_raw_size
, esdl
.ld_plt_sz
);
2901 s
= bfd_get_section_by_name (dynobj
, ".dynrel");
2902 BFD_ASSERT (s
!= NULL
);
2903 BFD_ASSERT (s
->reloc_count
* obj_reloc_entry_size (dynobj
)
2905 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2908 s
= bfd_get_section_by_name (dynobj
, ".hash");
2909 BFD_ASSERT (s
!= NULL
);
2910 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2913 s
= bfd_get_section_by_name (dynobj
, ".dynsym");
2914 BFD_ASSERT (s
!= NULL
);
2915 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2918 PUT_WORD (dynobj
, (bfd_vma
) 0, esdl
.ld_stab_hash
);
2920 PUT_WORD (dynobj
, (bfd_vma
) sunos_hash_table (info
)->bucketcount
,
2923 s
= bfd_get_section_by_name (dynobj
, ".dynstr");
2924 BFD_ASSERT (s
!= NULL
);
2925 PUT_WORD (dynobj
, s
->output_section
->filepos
+ s
->output_offset
,
2927 PUT_WORD (dynobj
, s
->_raw_size
, esdl
.ld_symb_size
);
2929 /* The size of the text area is the size of the .text section
2930 rounded up to a page boundary. FIXME: Should the page size be
2931 conditional on something? */
2933 BFD_ALIGN (obj_textsec (abfd
)->_raw_size
, 0x2000),
2936 pos
= sdyn
->output_offset
;
2937 pos
+= sizeof esd
+ EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
;
2938 if (! bfd_set_section_contents (abfd
, sdyn
->output_section
, &esdl
,
2939 pos
, (bfd_size_type
) sizeof esdl
))
2942 abfd
->flags
|= DYNAMIC
;