projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ΓΏ
[deliverable/binutils-gdb.git] / bfd / sunos.c
CommitLineData
252b5132
RH		 1/* BFD backend for SunOS binaries.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
5
6This file is part of BFD, the Binary File Descriptor library.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22#define TARGETNAME "a.out-sunos-big"
23#define MY(OP) CAT(sunos_big_,OP)
24
25#include "bfd.h"
26#include "bfdlink.h"
27#include "libaout.h"
28
29/* Static routines defined in this file. */
30
31static boolean sunos_read_dynamic_info PARAMS ((bfd *));
32static long sunos_get_dynamic_symtab_upper_bound PARAMS ((bfd *));
33static boolean sunos_slurp_dynamic_symtab PARAMS ((bfd *));
34static long sunos_canonicalize_dynamic_symtab PARAMS ((bfd *, asymbol **));
35static long sunos_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
36static long sunos_canonicalize_dynamic_reloc
37 PARAMS ((bfd *, arelent **, asymbol **));
38static struct bfd_hash_entry *sunos_link_hash_newfunc
39 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
40static struct bfd_link_hash_table *sunos_link_hash_table_create
41 PARAMS ((bfd *));
42static boolean sunos_create_dynamic_sections
43 PARAMS ((bfd *, struct bfd_link_info *, boolean));
44static boolean sunos_add_dynamic_symbols
45 PARAMS ((bfd *, struct bfd_link_info *, struct external_nlist **,
46 bfd_size_type *, char **));
47static boolean sunos_add_one_symbol
48 PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
49 bfd_vma, const char *, boolean, boolean,
50 struct bfd_link_hash_entry **));
51static boolean sunos_scan_relocs
52 PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_size_type));
53static boolean sunos_scan_std_relocs
54 PARAMS ((struct bfd_link_info *, bfd *, asection *,
55 const struct reloc_std_external *, bfd_size_type));
56static boolean sunos_scan_ext_relocs
57 PARAMS ((struct bfd_link_info *, bfd *, asection *,
58 const struct reloc_ext_external *, bfd_size_type));
59static boolean sunos_link_dynamic_object
60 PARAMS ((struct bfd_link_info *, bfd *));
61static boolean sunos_write_dynamic_symbol
62 PARAMS ((bfd *, struct bfd_link_info *, struct aout_link_hash_entry *));
63static boolean sunos_check_dynamic_reloc
64 PARAMS ((struct bfd_link_info *, bfd *, asection *,
65 struct aout_link_hash_entry *, PTR, bfd_byte *, boolean *,
66 bfd_vma *));
67static boolean sunos_finish_dynamic_link
68 PARAMS ((bfd *, struct bfd_link_info *));
69
70#define MY_get_dynamic_symtab_upper_bound sunos_get_dynamic_symtab_upper_bound
71#define MY_canonicalize_dynamic_symtab sunos_canonicalize_dynamic_symtab
72#define MY_get_dynamic_reloc_upper_bound sunos_get_dynamic_reloc_upper_bound
73#define MY_canonicalize_dynamic_reloc sunos_canonicalize_dynamic_reloc
74#define MY_bfd_link_hash_table_create sunos_link_hash_table_create
75#define MY_add_dynamic_symbols sunos_add_dynamic_symbols
76#define MY_add_one_symbol sunos_add_one_symbol
77#define MY_link_dynamic_object sunos_link_dynamic_object
78#define MY_write_dynamic_symbol sunos_write_dynamic_symbol
79#define MY_check_dynamic_reloc sunos_check_dynamic_reloc
80#define MY_finish_dynamic_link sunos_finish_dynamic_link
81
82/* ??? Where should this go? */
83#define MACHTYPE_OK(mtype) \
84 (((mtype) == M_SPARC && bfd_lookup_arch (bfd_arch_sparc, 0) != NULL) \
85 || ((mtype) == M_SPARCLET \
86 && bfd_lookup_arch (bfd_arch_sparc, bfd_mach_sparc_sparclet) != NULL) \
87 || ((mtype) == M_SPARCLITE_LE \
88 && bfd_lookup_arch (bfd_arch_sparc, bfd_mach_sparc_sparclet) != NULL) \
89 || (((mtype) == M_UNKNOWN || (mtype) == M_68010 || (mtype) == M_68020) \
90 && bfd_lookup_arch (bfd_arch_m68k, 0) != NULL))
91
92/* Include the usual a.out support. */
93#include "aoutf1.h"
94
95/* The SunOS 4.1.4 /usr/include/locale.h defines valid as a macro. */
96#undef valid
97
98/* SunOS shared library support. We store a pointer to this structure
99 in obj_aout_dynamic_info (abfd). */
100
101struct sunos_dynamic_info
102{
103 /* Whether we found any dynamic information. */
104 boolean valid;
105 /* Dynamic information. */
106 struct internal_sun4_dynamic_link dyninfo;
107 /* Number of dynamic symbols. */
108 unsigned long dynsym_count;
109 /* Read in nlists for dynamic symbols. */
110 struct external_nlist *dynsym;
111 /* asymbol structures for dynamic symbols. */
112 aout_symbol_type *canonical_dynsym;
113 /* Read in dynamic string table. */
114 char *dynstr;
115 /* Number of dynamic relocs. */
116 unsigned long dynrel_count;
117 /* Read in dynamic relocs. This may be reloc_std_external or
118 reloc_ext_external. */
119 PTR dynrel;
120 /* arelent structures for dynamic relocs. */
121 arelent *canonical_dynrel;
122};
123
124/* The hash table of dynamic symbols is composed of two word entries.
125 See include/aout/sun4.h for details. */
126
127#define HASH_ENTRY_SIZE (2 * BYTES_IN_WORD)
128
129/* Read in the basic dynamic information. This locates the __DYNAMIC
130 structure and uses it to find the dynamic_link structure. It
131 creates and saves a sunos_dynamic_info structure. If it can't find
132 __DYNAMIC, it sets the valid field of the sunos_dynamic_info
133 structure to false to avoid doing this work again. */
134
135static boolean
136sunos_read_dynamic_info (abfd)
137 bfd *abfd;
138{
139 struct sunos_dynamic_info *info;
140 asection *dynsec;
141 bfd_vma dynoff;
142 struct external_sun4_dynamic dyninfo;
143 unsigned long dynver;
144 struct external_sun4_dynamic_link linkinfo;
145
146 if (obj_aout_dynamic_info (abfd) != (PTR) NULL)
147 return true;
148
149 if ((abfd->flags & DYNAMIC) == 0)
150 {
151 bfd_set_error (bfd_error_invalid_operation);
152 return false;
153 }
154
155 info = ((struct sunos_dynamic_info *)
156 bfd_zalloc (abfd, sizeof (struct sunos_dynamic_info)));
157 if (!info)
158 return false;
159 info->valid = false;
160 info->dynsym = NULL;
161 info->dynstr = NULL;
162 info->canonical_dynsym = NULL;
163 info->dynrel = NULL;
164 info->canonical_dynrel = NULL;
165 obj_aout_dynamic_info (abfd) = (PTR) info;
166
167 /* This code used to look for the __DYNAMIC symbol to locate the dynamic
168 linking information.
169 However this inhibits recovering the dynamic symbols from a
170 stripped object file, so blindly assume that the dynamic linking
171 information is located at the start of the data section.
172 We could verify this assumption later by looking through the dynamic
173 symbols for the __DYNAMIC symbol. */
174 if ((abfd->flags & DYNAMIC) == 0)
175 return true;
176 if (! bfd_get_section_contents (abfd, obj_datasec (abfd), (PTR) &dyninfo,
177 (file_ptr) 0, sizeof dyninfo))
178 return true;
179
180 dynver = GET_WORD (abfd, dyninfo.ld_version);
181 if (dynver != 2 && dynver != 3)
182 return true;
183
184 dynoff = GET_WORD (abfd, dyninfo.ld);
185
186 /* dynoff is a virtual address. It is probably always in the .data
187 section, but this code should work even if it moves. */
188 if (dynoff < bfd_get_section_vma (abfd, obj_datasec (abfd)))
189 dynsec = obj_textsec (abfd);
190 else
191 dynsec = obj_datasec (abfd);
192 dynoff -= bfd_get_section_vma (abfd, dynsec);
193 if (dynoff > bfd_section_size (abfd, dynsec))
194 return true;
195
196 /* This executable appears to be dynamically linked in a way that we
197 can understand. */
198 if (! bfd_get_section_contents (abfd, dynsec, (PTR) &linkinfo, dynoff,
199 (bfd_size_type) sizeof linkinfo))
200 return true;
201
202 /* Swap in the dynamic link information. */
203 info->dyninfo.ld_loaded = GET_WORD (abfd, linkinfo.ld_loaded);
204 info->dyninfo.ld_need = GET_WORD (abfd, linkinfo.ld_need);
205 info->dyninfo.ld_rules = GET_WORD (abfd, linkinfo.ld_rules);
206 info->dyninfo.ld_got = GET_WORD (abfd, linkinfo.ld_got);
207 info->dyninfo.ld_plt = GET_WORD (abfd, linkinfo.ld_plt);
208 info->dyninfo.ld_rel = GET_WORD (abfd, linkinfo.ld_rel);
209 info->dyninfo.ld_hash = GET_WORD (abfd, linkinfo.ld_hash);
210 info->dyninfo.ld_stab = GET_WORD (abfd, linkinfo.ld_stab);
211 info->dyninfo.ld_stab_hash = GET_WORD (abfd, linkinfo.ld_stab_hash);
212 info->dyninfo.ld_buckets = GET_WORD (abfd, linkinfo.ld_buckets);
213 info->dyninfo.ld_symbols = GET_WORD (abfd, linkinfo.ld_symbols);
214 info->dyninfo.ld_symb_size = GET_WORD (abfd, linkinfo.ld_symb_size);
215 info->dyninfo.ld_text = GET_WORD (abfd, linkinfo.ld_text);
216 info->dyninfo.ld_plt_sz = GET_WORD (abfd, linkinfo.ld_plt_sz);
217
218 /* Reportedly the addresses need to be offset by the size of the
219 exec header in an NMAGIC file. */
220 if (adata (abfd).magic == n_magic)
221 {
222 unsigned long exec_bytes_size = adata (abfd).exec_bytes_size;
223
224 info->dyninfo.ld_need += exec_bytes_size;
225 info->dyninfo.ld_rules += exec_bytes_size;
226 info->dyninfo.ld_rel += exec_bytes_size;
227 info->dyninfo.ld_hash += exec_bytes_size;
228 info->dyninfo.ld_stab += exec_bytes_size;
229 info->dyninfo.ld_symbols += exec_bytes_size;
230 }
231
232 /* The only way to get the size of the symbol information appears to
233 be to determine the distance between it and the string table. */
234 info->dynsym_count = ((info->dyninfo.ld_symbols - info->dyninfo.ld_stab)
235 / EXTERNAL_NLIST_SIZE);
236 BFD_ASSERT (info->dynsym_count * EXTERNAL_NLIST_SIZE
237 == (unsigned long) (info->dyninfo.ld_symbols
238 - info->dyninfo.ld_stab));
239
240 /* Similarly, the relocs end at the hash table. */
241 info->dynrel_count = ((info->dyninfo.ld_hash - info->dyninfo.ld_rel)
242 / obj_reloc_entry_size (abfd));
243 BFD_ASSERT (info->dynrel_count * obj_reloc_entry_size (abfd)
244 == (unsigned long) (info->dyninfo.ld_hash
245 - info->dyninfo.ld_rel));
246
247 info->valid = true;
248
249 return true;
250}
251
252/* Return the amount of memory required for the dynamic symbols. */
253
254static long
255sunos_get_dynamic_symtab_upper_bound (abfd)
256 bfd *abfd;
257{
258 struct sunos_dynamic_info *info;
259
260 if (! sunos_read_dynamic_info (abfd))
261 return -1;
262
263 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
264 if (! info->valid)
265 {
266 bfd_set_error (bfd_error_no_symbols);
267 return -1;
268 }
269
270 return (info->dynsym_count + 1) * sizeof (asymbol *);
271}
272
273/* Read the external dynamic symbols. */
274
275static boolean
276sunos_slurp_dynamic_symtab (abfd)
277 bfd *abfd;
278{
279 struct sunos_dynamic_info *info;
280
281 /* Get the general dynamic information. */
282 if (obj_aout_dynamic_info (abfd) == NULL)
283 {
284 if (! sunos_read_dynamic_info (abfd))
285 return false;
286 }
287
288 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
289 if (! info->valid)
290 {
291 bfd_set_error (bfd_error_no_symbols);
292 return false;
293 }
294
295 /* Get the dynamic nlist structures. */
296 if (info->dynsym == (struct external_nlist *) NULL)
297 {
298 info->dynsym = ((struct external_nlist *)
299 bfd_alloc (abfd,
300 (info->dynsym_count
301 * EXTERNAL_NLIST_SIZE)));
302 if (info->dynsym == NULL && info->dynsym_count != 0)
303 return false;
304 if (bfd_seek (abfd, info->dyninfo.ld_stab, SEEK_SET) != 0
305 || (bfd_read ((PTR) info->dynsym, info->dynsym_count,
306 EXTERNAL_NLIST_SIZE, abfd)
307 != info->dynsym_count * EXTERNAL_NLIST_SIZE))
308 {
309 if (info->dynsym != NULL)
310 {
311 bfd_release (abfd, info->dynsym);
312 info->dynsym = NULL;
313 }
314 return false;
315 }
316 }
317
318 /* Get the dynamic strings. */
319 if (info->dynstr == (char *) NULL)
320 {
321 info->dynstr = (char *) bfd_alloc (abfd, info->dyninfo.ld_symb_size);
322 if (info->dynstr == NULL && info->dyninfo.ld_symb_size != 0)
323 return false;
324 if (bfd_seek (abfd, info->dyninfo.ld_symbols, SEEK_SET) != 0
325 || (bfd_read ((PTR) info->dynstr, 1, info->dyninfo.ld_symb_size,
326 abfd)
327 != info->dyninfo.ld_symb_size))
328 {
329 if (info->dynstr != NULL)
330 {
331 bfd_release (abfd, info->dynstr);
332 info->dynstr = NULL;
333 }
334 return false;
335 }
336 }
337
338 return true;
339}
340
341/* Read in the dynamic symbols. */
342
343static long
344sunos_canonicalize_dynamic_symtab (abfd, storage)
345 bfd *abfd;
346 asymbol **storage;
347{
348 struct sunos_dynamic_info *info;
349 unsigned long i;
350
351 if (! sunos_slurp_dynamic_symtab (abfd))
352 return -1;
353
354 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
355
356#ifdef CHECK_DYNAMIC_HASH
357 /* Check my understanding of the dynamic hash table by making sure
358 that each symbol can be located in the hash table. */
359 {
360 bfd_size_type table_size;
361 bfd_byte *table;
362 bfd_size_type i;
363
364 if (info->dyninfo.ld_buckets > info->dynsym_count)
365 abort ();
366 table_size = info->dyninfo.ld_stab - info->dyninfo.ld_hash;
367 table = (bfd_byte *) bfd_malloc (table_size);
368 if (table == NULL && table_size != 0)
369 abort ();
370 if (bfd_seek (abfd, info->dyninfo.ld_hash, SEEK_SET) != 0
371 || bfd_read ((PTR) table, 1, table_size, abfd) != table_size)
372 abort ();
373 for (i = 0; i < info->dynsym_count; i++)
374 {
375 unsigned char *name;
376 unsigned long hash;
377
378 name = ((unsigned char *) info->dynstr
379 + GET_WORD (abfd, info->dynsym[i].e_strx));
380 hash = 0;
381 while (*name != '\0')
382 hash = (hash << 1) + *name++;
383 hash &= 0x7fffffff;
384 hash %= info->dyninfo.ld_buckets;
385 while (GET_WORD (abfd, table + hash * HASH_ENTRY_SIZE) != i)
386 {
387 hash = GET_WORD (abfd,
388 table + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD);
389 if (hash == 0 || hash >= table_size / HASH_ENTRY_SIZE)
390 abort ();
391 }
392 }
393 free (table);
394 }
395#endif /* CHECK_DYNAMIC_HASH */
396
397 /* Get the asymbol structures corresponding to the dynamic nlist
398 structures. */
399 if (info->canonical_dynsym == (aout_symbol_type *) NULL)
400 {
401 info->canonical_dynsym = ((aout_symbol_type *)
402 bfd_alloc (abfd,
403 (info->dynsym_count
404 * sizeof (aout_symbol_type))));
405 if (info->canonical_dynsym == NULL && info->dynsym_count != 0)
406 return -1;
407
408 if (! aout_32_translate_symbol_table (abfd, info->canonical_dynsym,
409 info->dynsym, info->dynsym_count,
410 info->dynstr,
411 info->dyninfo.ld_symb_size,
412 true))
413 {
414 if (info->canonical_dynsym != NULL)
415 {
416 bfd_release (abfd, info->canonical_dynsym);
417 info->canonical_dynsym = NULL;
418 }
419 return -1;
420 }
421 }
422
423 /* Return pointers to the dynamic asymbol structures. */
424 for (i = 0; i < info->dynsym_count; i++)
425 *storage++ = (asymbol *) (info->canonical_dynsym + i);
426 *storage = NULL;
427
428 return info->dynsym_count;
429}
430
431/* Return the amount of memory required for the dynamic relocs. */
432
433static long
434sunos_get_dynamic_reloc_upper_bound (abfd)
435 bfd *abfd;
436{
437 struct sunos_dynamic_info *info;
438
439 if (! sunos_read_dynamic_info (abfd))
440 return -1;
441
442 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
443 if (! info->valid)
444 {
445 bfd_set_error (bfd_error_no_symbols);
446 return -1;
447 }
448
449 return (info->dynrel_count + 1) * sizeof (arelent *);
450}
451
452/* Read in the dynamic relocs. */
453
454static long
455sunos_canonicalize_dynamic_reloc (abfd, storage, syms)
456 bfd *abfd;
457 arelent **storage;
458 asymbol **syms;
459{
460 struct sunos_dynamic_info *info;
461 unsigned long i;
462
463 /* Get the general dynamic information. */
464 if (obj_aout_dynamic_info (abfd) == (PTR) NULL)
465 {
466 if (! sunos_read_dynamic_info (abfd))
467 return -1;
468 }
469
470 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
471 if (! info->valid)
472 {
473 bfd_set_error (bfd_error_no_symbols);
474 return -1;
475 }
476
477 /* Get the dynamic reloc information. */
478 if (info->dynrel == NULL)
479 {
480 info->dynrel = (PTR) bfd_alloc (abfd,
481 (info->dynrel_count
482 * obj_reloc_entry_size (abfd)));
483 if (info->dynrel == NULL && info->dynrel_count != 0)
484 return -1;
485 if (bfd_seek (abfd, info->dyninfo.ld_rel, SEEK_SET) != 0
486 || (bfd_read ((PTR) info->dynrel, info->dynrel_count,
487 obj_reloc_entry_size (abfd), abfd)
488 != info->dynrel_count * obj_reloc_entry_size (abfd)))
489 {
490 if (info->dynrel != NULL)
491 {
492 bfd_release (abfd, info->dynrel);
493 info->dynrel = NULL;
494 }
495 return -1;
496 }
497 }
498
499 /* Get the arelent structures corresponding to the dynamic reloc
500 information. */
501 if (info->canonical_dynrel == (arelent *) NULL)
502 {
503 arelent *to;
504
505 info->canonical_dynrel = ((arelent *)
506 bfd_alloc (abfd,
507 (info->dynrel_count
508 * sizeof (arelent))));
509 if (info->canonical_dynrel == NULL && info->dynrel_count != 0)
510 return -1;
511
512 to = info->canonical_dynrel;
513
514 if (obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE)
515 {
516 register struct reloc_ext_external *p;
517 struct reloc_ext_external *pend;
518
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 info->dynsym_count);
524 }
525 else
526 {
527 register struct reloc_std_external *p;
528 struct reloc_std_external *pend;
529
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 info->dynsym_count);
535 }
536 }
537
538 /* Return pointers to the dynamic arelent structures. */
539 for (i = 0; i < info->dynrel_count; i++)
540 *storage++ = info->canonical_dynrel + i;
541 *storage = NULL;
542
543 return info->dynrel_count;
544}
545\f
546/* Code to handle linking of SunOS shared libraries. */
547
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
552 a sethi of %g0. */
553
554#define SPARC_PLT_ENTRY_SIZE (12)
555
556static const bfd_byte sparc_plt_first_entry[SPARC_PLT_ENTRY_SIZE] =
557{
558 /* sethi %hi(0),%g1; address filled in by runtime linker. */
559 0x3, 0, 0, 0,
560 /* jmp %g1; offset filled in by runtime linker. */
561 0x81, 0xc0, 0x60, 0,
562 /* nop */
563 0x1, 0, 0, 0
564};
565
566/* save %sp, -96, %sp */
567#define SPARC_PLT_ENTRY_WORD0 0x9de3bfa0
568/* call; address filled in later. */
569#define SPARC_PLT_ENTRY_WORD1 0x40000000
570/* sethi; reloc index filled in later. */
571#define SPARC_PLT_ENTRY_WORD2 0x01000000
572
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 0x03000000
578/* jmp %g1 + <address to be filled in later> */
579#define SPARC_PLT_PIC_WORD1 0x81c06000
580/* nop */
581#define SPARC_PLT_PIC_WORD2 0x01000000
582
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. */
587
588#define M68K_PLT_ENTRY_SIZE (8)
589
590static const bfd_byte m68k_plt_first_entry[M68K_PLT_ENTRY_SIZE] =
591{
592 /* jmps @# */
593 0x4e, 0xf9,
594 /* Filled in by runtime linker with a magic address. */
595 0, 0, 0, 0,
596 /* Not used? */
597 0, 0
598};
599
600/* bsrl */
601#define M68K_PLT_ENTRY_WORD0 (0x61ff)
602/* Remaining words filled in later. */
603
604/* An entry in the SunOS linker hash table. */
605
606struct sunos_link_hash_entry
607{
608 struct aout_link_hash_entry root;
609
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. */
616 long dynindx;
617
618 /* If this is a dynamic symbol, this is the index of the name in the
619 dynamic symbol string table. */
620 long dynstr_index;
621
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. */
624 bfd_vma got_offset;
625
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. */
628 bfd_vma plt_offset;
629
630 /* Some linker flags. */
631 unsigned char 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
642};
643
644/* The SunOS linker hash table. */
645
646struct sunos_link_hash_table
647{
648 struct aout_link_hash_table root;
649
650 /* The object which holds the dynamic sections. */
651 bfd *dynobj;
652
653 /* Whether we have created the dynamic sections. */
654 boolean dynamic_sections_created;
655
656 /* Whether we need the dynamic sections. */
657 boolean dynamic_sections_needed;
658
659 /* Whether we need the .got table. */
660 boolean got_needed;
661
662 /* The number of dynamic symbols. */
663 size_t dynsymcount;
664
665 /* The number of buckets in the hash table. */
666 size_t bucketcount;
667
668 /* The list of dynamic objects needed by dynamic objects included in
669 the link. */
670 struct bfd_link_needed_list *needed;
671
672 /* The offset of __GLOBAL_OFFSET_TABLE_ into the .got section. */
673 bfd_vma got_base;
674};
675
676/* Routine to create an entry in an SunOS link hash table. */
677
678static struct bfd_hash_entry *
679sunos_link_hash_newfunc (entry, table, string)
680 struct bfd_hash_entry *entry;
681 struct bfd_hash_table *table;
682 const char *string;
683{
684 struct sunos_link_hash_entry *ret = (struct sunos_link_hash_entry *) entry;
685
686 /* Allocate the structure if it has not already been allocated by a
687 subclass. */
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;
693
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,
697 table, string));
698 if (ret != NULL)
699 {
700 /* Set local fields. */
701 ret->dynindx = -1;
702 ret->dynstr_index = -1;
703 ret->got_offset = 0;
704 ret->plt_offset = 0;
705 ret->flags = 0;
706 }
707
708 return (struct bfd_hash_entry *) ret;
709}
710
711/* Create a SunOS link hash table. */
712
713static struct bfd_link_hash_table *
714sunos_link_hash_table_create (abfd)
715 bfd *abfd;
716{
717 struct sunos_link_hash_table *ret;
718
719 ret = ((struct sunos_link_hash_table *)
720 bfd_alloc (abfd, sizeof (struct sunos_link_hash_table)));
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))
725 {
726 bfd_release (abfd, ret);
727 return (struct bfd_link_hash_table *) NULL;
728 }
729
730 ret->dynobj = 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;
736 ret->needed = NULL;
737 ret->got_base = 0;
738
739 return &ret->root.root;
740}
741
742/* Look up an entry in an SunOS link hash table. */
743
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),\
747 (follow)))
748
749/* Traverse a SunOS link hash table. */
750
751#define sunos_link_hash_traverse(table, func, info) \
752 (aout_link_hash_traverse \
753 (&(table)->root, \
754 (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
755 (info)))
756
757/* Get the SunOS link hash table from the info structure. This is
758 just a cast. */
759
760#define sunos_hash_table(p) ((struct sunos_link_hash_table *) ((p)->hash))
761
762static boolean sunos_scan_dynamic_symbol
763 PARAMS ((struct sunos_link_hash_entry *, PTR));
764
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. */
771
772static boolean
773sunos_create_dynamic_sections (abfd, info, needed)
774 bfd *abfd;
775 struct bfd_link_info *info;
776 boolean needed;
777{
778 asection *s;
779
780 if (! sunos_hash_table (info)->dynamic_sections_created)
781 {
782 flagword flags;
783
784 sunos_hash_table (info)->dynobj = abfd;
785
786 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
787 | SEC_LINKER_CREATED);
788
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");
793 if (s == NULL
794 || ! bfd_set_section_flags (abfd, s, flags)
795 || ! bfd_set_section_alignment (abfd, s, 2))
796 return false;
797
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");
801 if (s == NULL
802 || ! bfd_set_section_flags (abfd, s, flags)
803 || ! bfd_set_section_alignment (abfd, s, 2))
804 return false;
805
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");
809 if (s == NULL
810 || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
811 || ! bfd_set_section_alignment (abfd, s, 2))
812 return false;
813
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");
817 if (s == NULL
818 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
819 || ! bfd_set_section_alignment (abfd, s, 2))
820 return false;
821
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");
825 if (s == NULL
826 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
827 || ! bfd_set_section_alignment (abfd, s, 2))
828 return false;
829
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");
833 if (s == NULL
834 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
835 || ! bfd_set_section_alignment (abfd, s, 2))
836 return false;
837
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");
841 if (s == NULL
842 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
843 || ! bfd_set_section_alignment (abfd, s, 2))
844 return false;
845
846 sunos_hash_table (info)->dynamic_sections_created = true;
847 }
848
849 if ((needed && ! sunos_hash_table (info)->dynamic_sections_needed)
850 || info->shared)
851 {
852 bfd *dynobj;
853
854 dynobj = sunos_hash_table (info)->dynobj;
855
856 s = bfd_get_section_by_name (dynobj, ".got");
857 if (s->_raw_size == 0)
858 s->_raw_size = BYTES_IN_WORD;
859
860 sunos_hash_table (info)->dynamic_sections_needed = true;
861 sunos_hash_table (info)->got_needed = true;
862 }
863
864 return true;
865}
866
867/* Add dynamic symbols during a link. This is called by the a.out
868 backend linker for each object it encounters. */
869
870static boolean
871sunos_add_dynamic_symbols (abfd, info, symsp, sym_countp, stringsp)
872 bfd *abfd;
873 struct bfd_link_info *info;
874 struct external_nlist **symsp;
875 bfd_size_type *sym_countp;
876 char **stringsp;
877{
878 asection *s;
879 bfd *dynobj;
880 struct sunos_dynamic_info *dinfo;
881 unsigned long need;
882
883 /* Make sure we have all the required sections. */
884 if (info->hash->creator == abfd->xvec)
885 {
886 if (! sunos_create_dynamic_sections (abfd, info,
887 (((abfd->flags & DYNAMIC) != 0
888 && ! info->relocateable)
889 ? true
890 : false)))
891 return false;
892 }
893
894 /* There is nothing else to do for a normal object. */
895 if ((abfd->flags & DYNAMIC) == 0)
896 return true;
897
898 dynobj = sunos_hash_table (info)->dynobj;
899
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 if (abfd != dynobj)
908 abfd->sections = NULL;
909 else
910 {
911 asection *s;
912
913 for (s = abfd->sections;
914 (s->flags & SEC_LINKER_CREATED) == 0;
915 s = s->next)
916 ;
917 abfd->sections = s;
918 }
919
920 /* The native linker seems to just ignore dynamic objects when -r is
921 used. */
922 if (info->relocateable)
923 return true;
924
925 /* There's no hope of using a dynamic object which does not exactly
926 match the format of the output file. */
927 if (info->hash->creator != abfd->xvec)
928 {
929 bfd_set_error (bfd_error_invalid_operation);
930 return false;
931 }
932
933 /* Make sure we have a .need and a .rules sections. These are only
934 needed if there really is a dynamic object in the link, so they
935 are not added by sunos_create_dynamic_sections. */
936 if (bfd_get_section_by_name (dynobj, ".need") == NULL)
937 {
938 /* The .need section holds the list of names of shared objets
939 which must be included at runtime. The address of this
940 section is put in the ld_need field. */
941 s = bfd_make_section (dynobj, ".need");
942 if (s == NULL
943 || ! bfd_set_section_flags (dynobj, s,
944 (SEC_ALLOC
945 | SEC_LOAD
946 | SEC_HAS_CONTENTS
947 | SEC_IN_MEMORY
948 | SEC_READONLY))
949 || ! bfd_set_section_alignment (dynobj, s, 2))
950 return false;
951 }
952
953 if (bfd_get_section_by_name (dynobj, ".rules") == NULL)
954 {
955 /* The .rules section holds the path to search for shared
956 objects. The address of this section is put in the ld_rules
957 field. */
958 s = bfd_make_section (dynobj, ".rules");
959 if (s == NULL
960 || ! bfd_set_section_flags (dynobj, s,
961 (SEC_ALLOC
962 | SEC_LOAD
963 | SEC_HAS_CONTENTS
964 | SEC_IN_MEMORY
965 | SEC_READONLY))
966 || ! bfd_set_section_alignment (dynobj, s, 2))
967 return false;
968 }
969
970 /* Pick up the dynamic symbols and return them to the caller. */
971 if (! sunos_slurp_dynamic_symtab (abfd))
972 return false;
973
974 dinfo = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
975 *symsp = dinfo->dynsym;
976 *sym_countp = dinfo->dynsym_count;
977 *stringsp = dinfo->dynstr;
978
979 /* Record information about any other objects needed by this one. */
980 need = dinfo->dyninfo.ld_need;
981 while (need != 0)
982 {
983 bfd_byte buf[16];
984 unsigned long name, flags;
985 unsigned short major_vno, minor_vno;
986 struct bfd_link_needed_list *needed, **pp;
987 char *namebuf, *p;
988 size_t alc;
989 bfd_byte b;
990 char *namecopy;
991
992 if (bfd_seek (abfd, need, SEEK_SET) != 0
993 || bfd_read (buf, 1, 16, abfd) != 16)
994 return false;
995
996 /* For the format of an ld_need entry, see aout/sun4.h. We
997 should probably define structs for this manipulation. */
998
999 name = bfd_get_32 (abfd, buf);
1000 flags = bfd_get_32 (abfd, buf + 4);
1001 major_vno = (unsigned short)bfd_get_16 (abfd, buf + 8);
1002 minor_vno = (unsigned short)bfd_get_16 (abfd, buf + 10);
1003 need = bfd_get_32 (abfd, buf + 12);
1004
1005 needed = ((struct bfd_link_needed_list *)
1006 bfd_alloc (abfd, sizeof (struct bfd_link_needed_list)));
1007 if (needed == NULL)
1008 return false;
1009 needed->by = abfd;
1010
1011 /* We return the name as [-l]name[.maj][.min]. */
1012 alc = 30;
1013 namebuf = (char *) bfd_malloc (alc + 1);
1014 if (namebuf == NULL)
1015 return false;
1016 p = namebuf;
1017
1018 if ((flags & 0x80000000) != 0)
1019 {
1020 *p++ = '-';
1021 *p++ = 'l';
1022 }
1023 if (bfd_seek (abfd, name, SEEK_SET) != 0)
1024 {
1025 free (namebuf);
1026 return false;
1027 }
1028
1029 do
1030 {
1031 if (bfd_read (&b, 1, 1, abfd) != 1)
1032 {
1033 free (namebuf);
1034 return false;
1035 }
1036
1037 if ((size_t) (p - namebuf) >= alc)
1038 {
1039 char *n;
1040
1041 alc *= 2;
1042 n = (char *) bfd_realloc (namebuf, alc + 1);
1043 if (n == NULL)
1044 {
1045 free (namebuf);
1046 return false;
1047 }
1048 p = n + (p - namebuf);
1049 namebuf = n;
1050 }
1051
1052 *p++ = b;
1053 }
1054 while (b != '\0');
1055
1056 if (major_vno == 0)
1057 *p = '\0';
1058 else
1059 {
1060 char majbuf[30];
1061 char minbuf[30];
1062
1063 sprintf (majbuf, ".%d", major_vno);
1064 if (minor_vno == 0)
1065 minbuf[0] = '\0';
1066 else
1067 sprintf (minbuf, ".%d", minor_vno);
1068
1069 if ((p - namebuf) + strlen (majbuf) + strlen (minbuf) >= alc)
1070 {
1071 char *n;
1072
1073 alc = (p - namebuf) + strlen (majbuf) + strlen (minbuf);
1074 n = (char *) bfd_realloc (namebuf, alc + 1);
1075 if (n == NULL)
1076 {
1077 free (namebuf);
1078 return false;
1079 }
1080 p = n + (p - namebuf);
1081 namebuf = n;
1082 }
1083
1084 strcpy (p, majbuf);
1085 strcat (p, minbuf);
1086 }
1087
1088 namecopy = bfd_alloc (abfd, strlen (namebuf) + 1);
1089 if (namecopy == NULL)
1090 {
1091 free (namebuf);
1092 return false;
1093 }
1094 strcpy (namecopy, namebuf);
1095 free (namebuf);
1096 needed->name = namecopy;
1097
1098 needed->next = NULL;
1099
1100 for (pp = &sunos_hash_table (info)->needed;
1101 *pp != NULL;
1102 pp = &(*pp)->next)
1103 ;
1104 *pp = needed;
1105 }
1106
1107 return true;
1108}
1109
1110/* Function to add a single symbol to the linker hash table. This is
1111 a wrapper around _bfd_generic_link_add_one_symbol which handles the
1112 tweaking needed for dynamic linking support. */
1113
1114static boolean
1115sunos_add_one_symbol (info, abfd, name, flags, section, value, string,
1116 copy, collect, hashp)
1117 struct bfd_link_info *info;
1118 bfd *abfd;
1119 const char *name;
1120 flagword flags;
1121 asection *section;
1122 bfd_vma value;
1123 const char *string;
1124 boolean copy;
1125 boolean collect;
1126 struct bfd_link_hash_entry **hashp;
1127{
1128 struct sunos_link_hash_entry *h;
1129 int new_flag;
1130
1131 if ((flags & (BSF_INDIRECT | BSF_WARNING | BSF_CONSTRUCTOR)) != 0
1132 || ! bfd_is_und_section (section))
1133 h = sunos_link_hash_lookup (sunos_hash_table (info), name, true, copy,
1134 false);
1135 else
1136 h = ((struct sunos_link_hash_entry *)
1137 bfd_wrapped_link_hash_lookup (abfd, info, name, true, copy, false));
1138 if (h == NULL)
1139 return false;
1140
1141 if (hashp != NULL)
1142 *hashp = (struct bfd_link_hash_entry *) h;
1143
1144 /* Treat a common symbol in a dynamic object as defined in the .bss
1145 section of the dynamic object. We don't want to allocate space
1146 for it in our process image. */
1147 if ((abfd->flags & DYNAMIC) != 0
1148 && bfd_is_com_section (section))
1149 section = obj_bsssec (abfd);
1150
1151 if (! bfd_is_und_section (section)
1152 && h->root.root.type != bfd_link_hash_new
1153 && h->root.root.type != bfd_link_hash_undefined
1154 && h->root.root.type != bfd_link_hash_defweak)
1155 {
1156 /* We are defining the symbol, and it is already defined. This
1157 is a potential multiple definition error. */
1158 if ((abfd->flags & DYNAMIC) != 0)
1159 {
1160 /* The definition we are adding is from a dynamic object.
1161 We do not want this new definition to override the
1162 existing definition, so we pretend it is just a
1163 reference. */
1164 section = bfd_und_section_ptr;
1165 }
1166 else if (h->root.root.type == bfd_link_hash_defined
1167 && h->root.root.u.def.section->owner != NULL
1168 && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
1169 {
1170 /* The existing definition is from a dynamic object. We
1171 want to override it with the definition we just found.
1172 Clobber the existing definition. */
1173 h->root.root.type = bfd_link_hash_undefined;
1174 h->root.root.u.undef.abfd = h->root.root.u.def.section->owner;
1175 }
1176 else if (h->root.root.type == bfd_link_hash_common
1177 && (h->root.root.u.c.p->section->owner->flags & DYNAMIC) != 0)
1178 {
1179 /* The existing definition is from a dynamic object. We
1180 want to override it with the definition we just found.
1181 Clobber the existing definition. We can't set it to new,
1182 because it is on the undefined list. */
1183 h->root.root.type = bfd_link_hash_undefined;
1184 h->root.root.u.undef.abfd = h->root.root.u.c.p->section->owner;
1185 }
1186 }
1187
1188 if ((abfd->flags & DYNAMIC) != 0
1189 && abfd->xvec == info->hash->creator
1190 && (h->flags & SUNOS_CONSTRUCTOR) != 0)
1191 {
1192 /* The existing symbol is a constructor symbol, and this symbol
1193 is from a dynamic object. A constructor symbol is actually a
1194 definition, although the type will be bfd_link_hash_undefined
1195 at this point. We want to ignore the definition from the
1196 dynamic object. */
1197 section = bfd_und_section_ptr;
1198 }
1199 else if ((flags & BSF_CONSTRUCTOR) != 0
1200 && (abfd->flags & DYNAMIC) == 0
1201 && h->root.root.type == bfd_link_hash_defined
1202 && h->root.root.u.def.section->owner != NULL
1203 && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
1204 {
1205 /* The existing symbol is defined by a dynamic object, and this
1206 is a constructor symbol. As above, we want to force the use
1207 of the constructor symbol from the regular object. */
1208 h->root.root.type = bfd_link_hash_new;
1209 }
1210
1211 /* Do the usual procedure for adding a symbol. */
1212 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
1213 value, string, copy, collect,
1214 hashp))
1215 return false;
1216
1217 if (abfd->xvec == info->hash->creator)
1218 {
1219 /* Set a flag in the hash table entry indicating the type of
1220 reference or definition we just found. Keep a count of the
1221 number of dynamic symbols we find. A dynamic symbol is one
1222 which is referenced or defined by both a regular object and a
1223 shared object. */
1224 if ((abfd->flags & DYNAMIC) == 0)
1225 {
1226 if (bfd_is_und_section (section))
1227 new_flag = SUNOS_REF_REGULAR;
1228 else
1229 new_flag = SUNOS_DEF_REGULAR;
1230 }
1231 else
1232 {
1233 if (bfd_is_und_section (section))
1234 new_flag = SUNOS_REF_DYNAMIC;
1235 else
1236 new_flag = SUNOS_DEF_DYNAMIC;
1237 }
1238 h->flags |= new_flag;
1239
1240 if (h->dynindx == -1
1241 && (h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
1242 {
1243 ++sunos_hash_table (info)->dynsymcount;
1244 h->dynindx = -2;
1245 }
1246
1247 if ((flags & BSF_CONSTRUCTOR) != 0
1248 && (abfd->flags & DYNAMIC) == 0)
1249 h->flags |= SUNOS_CONSTRUCTOR;
1250 }
1251
1252 return true;
1253}
1254
1255/* Return the list of objects needed by BFD. */
1256
1257/*ARGSUSED*/
1258struct bfd_link_needed_list *
1259bfd_sunos_get_needed_list (abfd, info)
1260 bfd *abfd;
1261 struct bfd_link_info *info;
1262{
1263 if (info->hash->creator != &MY(vec))
1264 return NULL;
1265 return sunos_hash_table (info)->needed;
1266}
1267
1268/* Record an assignment made to a symbol by a linker script. We need
1269 this in case some dynamic object refers to this symbol. */
1270
1271boolean
1272bfd_sunos_record_link_assignment (output_bfd, info, name)
1273 bfd *output_bfd;
1274 struct bfd_link_info *info;
1275 const char *name;
1276{
1277 struct sunos_link_hash_entry *h;
1278
1279 if (output_bfd->xvec != &MY(vec))
1280 return true;
1281
1282 /* This is called after we have examined all the input objects. If
1283 the symbol does not exist, it merely means that no object refers
1284 to it, and we can just ignore it at this point. */
1285 h = sunos_link_hash_lookup (sunos_hash_table (info), name,
1286 false, false, false);
1287 if (h == NULL)
1288 return true;
1289
1290 /* In a shared library, the __DYNAMIC symbol does not appear in the
1291 dynamic symbol table. */
1292 if (! info->shared || strcmp (name, "__DYNAMIC") != 0)
1293 {
1294 h->flags |= SUNOS_DEF_REGULAR;
1295
1296 if (h->dynindx == -1)
1297 {
1298 ++sunos_hash_table (info)->dynsymcount;
1299 h->dynindx = -2;
1300 }
1301 }
1302
1303 return true;
1304}
1305
1306/* Set up the sizes and contents of the dynamic sections created in
1307 sunos_add_dynamic_symbols. This is called by the SunOS linker
1308 emulation before_allocation routine. We must set the sizes of the
1309 sections before the linker sets the addresses of the various
1310 sections. This unfortunately requires reading all the relocs so
1311 that we can work out which ones need to become dynamic relocs. If
1312 info->keep_memory is true, we keep the relocs in memory; otherwise,
1313 we discard them, and will read them again later. */
1314
1315boolean
1316bfd_sunos_size_dynamic_sections (output_bfd, info, sdynptr, sneedptr,
1317 srulesptr)
1318 bfd *output_bfd;
1319 struct bfd_link_info *info;
1320 asection **sdynptr;
1321 asection **sneedptr;
1322 asection **srulesptr;
1323{
1324 bfd *dynobj;
1325 size_t dynsymcount;
1326 struct sunos_link_hash_entry *h;
1327 asection *s;
1328 size_t bucketcount;
1329 size_t hashalloc;
1330 size_t i;
1331 bfd *sub;
1332
1333 *sdynptr = NULL;
1334 *sneedptr = NULL;
1335 *srulesptr = NULL;
1336
1337 if (info->relocateable)
1338 return true;
1339
1340 if (output_bfd->xvec != &MY(vec))
1341 return true;
1342
1343 /* Look through all the input BFD's and read their relocs. It would
1344 be better if we didn't have to do this, but there is no other way
1345 to determine the number of dynamic relocs we need, and, more
1346 importantly, there is no other way to know which symbols should
1347 get an entry in the procedure linkage table. */
1348 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
1349 {
1350 if ((sub->flags & DYNAMIC) == 0
1351 && sub->xvec == output_bfd->xvec)
1352 {
1353 if (! sunos_scan_relocs (info, sub, obj_textsec (sub),
1354 exec_hdr (sub)->a_trsize)
1355 || ! sunos_scan_relocs (info, sub, obj_datasec (sub),
1356 exec_hdr (sub)->a_drsize))
1357 return false;
1358 }
1359 }
1360
1361 dynobj = sunos_hash_table (info)->dynobj;
1362 dynsymcount = sunos_hash_table (info)->dynsymcount;
1363
1364 /* If there were no dynamic objects in the link, and we don't need
1365 to build a global offset table, there is nothing to do here. */
1366 if (! sunos_hash_table (info)->dynamic_sections_needed
1367 && ! sunos_hash_table (info)->got_needed)
1368 return true;
1369
1370 /* If __GLOBAL_OFFSET_TABLE_ was mentioned, define it. */
1371 h = sunos_link_hash_lookup (sunos_hash_table (info),
1372 "__GLOBAL_OFFSET_TABLE_", false, false, false);
1373 if (h != NULL && (h->flags & SUNOS_REF_REGULAR) != 0)
1374 {
1375 h->flags |= SUNOS_DEF_REGULAR;
1376 if (h->dynindx == -1)
1377 {
1378 ++sunos_hash_table (info)->dynsymcount;
1379 h->dynindx = -2;
1380 }
1381 h->root.root.type = bfd_link_hash_defined;
1382 h->root.root.u.def.section = bfd_get_section_by_name (dynobj, ".got");
1383
1384 /* If the .got section is more than 0x1000 bytes, we set
1385 __GLOBAL_OFFSET_TABLE_ to be 0x1000 bytes into the section,
1386 so that 13 bit relocations have a greater chance of working. */
1387 s = bfd_get_section_by_name (dynobj, ".got");
1388 BFD_ASSERT (s != NULL);
1389 if (s->_raw_size >= 0x1000)
1390 h->root.root.u.def.value = 0x1000;
1391 else
1392 h->root.root.u.def.value = 0;
1393
1394 sunos_hash_table (info)->got_base = h->root.root.u.def.value;
1395 }
1396
1397 /* If there are any shared objects in the link, then we need to set
1398 up the dynamic linking information. */
1399 if (sunos_hash_table (info)->dynamic_sections_needed)
1400 {
1401 *sdynptr = bfd_get_section_by_name (dynobj, ".dynamic");
1402
1403 /* The .dynamic section is always the same size. */
1404 s = *sdynptr;
1405 BFD_ASSERT (s != NULL);
1406 s->_raw_size = (sizeof (struct external_sun4_dynamic)
1407 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
1408 + sizeof (struct external_sun4_dynamic_link));
1409
1410 /* Set the size of the .dynsym and .hash sections. We counted
1411 the number of dynamic symbols as we read the input files. We
1412 will build the dynamic symbol table (.dynsym) and the hash
1413 table (.hash) when we build the final symbol table, because
1414 until then we do not know the correct value to give the
1415 symbols. We build the dynamic symbol string table (.dynstr)
1416 in a traversal of the symbol table using
1417 sunos_scan_dynamic_symbol. */
1418 s = bfd_get_section_by_name (dynobj, ".dynsym");
1419 BFD_ASSERT (s != NULL);
1420 s->_raw_size = dynsymcount * sizeof (struct external_nlist);
1421 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1422 if (s->contents == NULL && s->_raw_size != 0)
1423 return false;
1424
1425 /* The number of buckets is just the number of symbols divided
1426 by four. To compute the final size of the hash table, we
1427 must actually compute the hash table. Normally we need
1428 exactly as many entries in the hash table as there are
1429 dynamic symbols, but if some of the buckets are not used we
1430 will need additional entries. In the worst case, every
1431 symbol will hash to the same bucket, and we will need
1432 BUCKETCOUNT - 1 extra entries. */
1433 if (dynsymcount >= 4)
1434 bucketcount = dynsymcount / 4;
1435 else if (dynsymcount > 0)
1436 bucketcount = dynsymcount;
1437 else
1438 bucketcount = 1;
1439 s = bfd_get_section_by_name (dynobj, ".hash");
1440 BFD_ASSERT (s != NULL);
1441 hashalloc = (dynsymcount + bucketcount - 1) * HASH_ENTRY_SIZE;
1442 s->contents = (bfd_byte *) bfd_alloc (dynobj, hashalloc);
1443 if (s->contents == NULL && dynsymcount > 0)
1444 return false;
1445 memset (s->contents, 0, hashalloc);
1446 for (i = 0; i < bucketcount; i++)
1447 PUT_WORD (output_bfd, (bfd_vma) -1, s->contents + i * HASH_ENTRY_SIZE);
1448 s->_raw_size = bucketcount * HASH_ENTRY_SIZE;
1449
1450 sunos_hash_table (info)->bucketcount = bucketcount;
1451
1452 /* Scan all the symbols, place them in the dynamic symbol table,
1453 and build the dynamic hash table. We reuse dynsymcount as a
1454 counter for the number of symbols we have added so far. */
1455 sunos_hash_table (info)->dynsymcount = 0;
1456 sunos_link_hash_traverse (sunos_hash_table (info),
1457 sunos_scan_dynamic_symbol,
1458 (PTR) info);
1459 BFD_ASSERT (sunos_hash_table (info)->dynsymcount == dynsymcount);
1460
1461 /* The SunOS native linker seems to align the total size of the
1462 symbol strings to a multiple of 8. I don't know if this is
1463 important, but it can't hurt much. */
1464 s = bfd_get_section_by_name (dynobj, ".dynstr");
1465 BFD_ASSERT (s != NULL);
1466 if ((s->_raw_size & 7) != 0)
1467 {
1468 bfd_size_type add;
1469 bfd_byte *contents;
1470
1471 add = 8 - (s->_raw_size & 7);
1472 contents = (bfd_byte *) bfd_realloc (s->contents,
1473 (size_t) (s->_raw_size + add));
1474 if (contents == NULL)
1475 return false;
1476 memset (contents + s->_raw_size, 0, (size_t) add);
1477 s->contents = contents;
1478 s->_raw_size += add;
1479 }
1480 }
1481
1482 /* Now that we have worked out the sizes of the procedure linkage
1483 table and the dynamic relocs, allocate storage for them. */
1484 s = bfd_get_section_by_name (dynobj, ".plt");
1485 BFD_ASSERT (s != NULL);
1486 if (s->_raw_size != 0)
1487 {
1488 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1489 if (s->contents == NULL)
1490 return false;
1491
1492 /* Fill in the first entry in the table. */
1493 switch (bfd_get_arch (dynobj))
1494 {
1495 case bfd_arch_sparc:
1496 memcpy (s->contents, sparc_plt_first_entry, SPARC_PLT_ENTRY_SIZE);
1497 break;
1498
1499 case bfd_arch_m68k:
1500 memcpy (s->contents, m68k_plt_first_entry, M68K_PLT_ENTRY_SIZE);
1501 break;
1502
1503 default:
1504 abort ();
1505 }
1506 }
1507
1508 s = bfd_get_section_by_name (dynobj, ".dynrel");
1509 if (s->_raw_size != 0)
1510 {
1511 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1512 if (s->contents == NULL)
1513 return false;
1514 }
1515 /* We use the reloc_count field to keep track of how many of the
1516 relocs we have output so far. */
1517 s->reloc_count = 0;
1518
1519 /* Make space for the global offset table. */
1520 s = bfd_get_section_by_name (dynobj, ".got");
1521 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1522 if (s->contents == NULL)
1523 return false;
1524
1525 *sneedptr = bfd_get_section_by_name (dynobj, ".need");
1526 *srulesptr = bfd_get_section_by_name (dynobj, ".rules");
1527
1528 return true;
1529}
1530
1531/* Scan the relocs for an input section. */
1532
1533static boolean
1534sunos_scan_relocs (info, abfd, sec, rel_size)
1535 struct bfd_link_info *info;
1536 bfd *abfd;
1537 asection *sec;
1538 bfd_size_type rel_size;
1539{
1540 PTR relocs;
1541 PTR free_relocs = NULL;
1542
1543 if (rel_size == 0)
1544 return true;
1545
1546 if (! info->keep_memory)
1547 relocs = free_relocs = bfd_malloc ((size_t) rel_size);
1548 else
1549 {
1550 struct aout_section_data_struct *n;
1551
1552 n = ((struct aout_section_data_struct *)
1553 bfd_alloc (abfd, sizeof (struct aout_section_data_struct)));
1554 if (n == NULL)
1555 relocs = NULL;
1556 else
1557 {
1558 set_aout_section_data (sec, n);
1559 relocs = bfd_malloc ((size_t) rel_size);
1560 aout_section_data (sec)->relocs = relocs;
1561 }
1562 }
1563 if (relocs == NULL)
1564 return false;
1565
1566 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
1567 || bfd_read (relocs, 1, rel_size, abfd) != rel_size)
1568 goto error_return;
1569
1570 if (obj_reloc_entry_size (abfd) == RELOC_STD_SIZE)
1571 {
1572 if (! sunos_scan_std_relocs (info, abfd, sec,
1573 (struct reloc_std_external *) relocs,
1574 rel_size))
1575 goto error_return;
1576 }
1577 else
1578 {
1579 if (! sunos_scan_ext_relocs (info, abfd, sec,
1580 (struct reloc_ext_external *) relocs,
1581 rel_size))
1582 goto error_return;
1583 }
1584
1585 if (free_relocs != NULL)
1586 free (free_relocs);
1587
1588 return true;
1589
1590 error_return:
1591 if (free_relocs != NULL)
1592 free (free_relocs);
1593 return false;
1594}
1595
1596/* Scan the relocs for an input section using standard relocs. We
1597 need to figure out what to do for each reloc against a dynamic
1598 symbol. If the symbol is in the .text section, an entry is made in
1599 the procedure linkage table. Note that this will do the wrong
1600 thing if the symbol is actually data; I don't think the Sun 3
1601 native linker handles this case correctly either. If the symbol is
1602 not in the .text section, we must preserve the reloc as a dynamic
1603 reloc. FIXME: We should also handle the PIC relocs here by
1604 building global offset table entries. */
1605
1606static boolean
1607sunos_scan_std_relocs (info, abfd, sec, relocs, rel_size)
1608 struct bfd_link_info *info;
1609 bfd *abfd;
1610 asection *sec;
1611 const struct reloc_std_external *relocs;
1612 bfd_size_type rel_size;
1613{
1614 bfd *dynobj;
1615 asection *splt = NULL;
1616 asection *srel = NULL;
1617 struct sunos_link_hash_entry **sym_hashes;
1618 const struct reloc_std_external *rel, *relend;
1619
1620 /* We only know how to handle m68k plt entries. */
1621 if (bfd_get_arch (abfd) != bfd_arch_m68k)
1622 {
1623 bfd_set_error (bfd_error_invalid_target);
1624 return false;
1625 }
1626
1627 dynobj = NULL;
1628
1629 sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
1630
1631 relend = relocs + rel_size / RELOC_STD_SIZE;
1632 for (rel = relocs; rel < relend; rel++)
1633 {
1634 int r_index;
1635 struct sunos_link_hash_entry *h;
1636
1637 /* We only want relocs against external symbols. */
1638 if (bfd_header_big_endian (abfd))
1639 {
1640 if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG) == 0)
1641 continue;
1642 }
1643 else
1644 {
1645 if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE) == 0)
1646 continue;
1647 }
1648
1649 /* Get the symbol index. */
1650 if (bfd_header_big_endian (abfd))
1651 r_index = ((rel->r_index[0] << 16)
1652 | (rel->r_index[1] << 8)
1653 | rel->r_index[2]);
1654 else
1655 r_index = ((rel->r_index[2] << 16)
1656 | (rel->r_index[1] << 8)
1657 | rel->r_index[0]);
1658
1659 /* Get the hash table entry. */
1660 h = sym_hashes[r_index];
1661 if (h == NULL)
1662 {
1663 /* This should not normally happen, but it will in any case
1664 be caught in the relocation phase. */
1665 continue;
1666 }
1667
1668 /* At this point common symbols have already been allocated, so
1669 we don't have to worry about them. We need to consider that
1670 we may have already seen this symbol and marked it undefined;
1671 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1672 will be zero. */
1673 if (h->root.root.type != bfd_link_hash_defined
1674 && h->root.root.type != bfd_link_hash_defweak
1675 && h->root.root.type != bfd_link_hash_undefined)
1676 continue;
1677
1678 if ((h->flags & SUNOS_DEF_DYNAMIC) == 0
1679 || (h->flags & SUNOS_DEF_REGULAR) != 0)
1680 continue;
1681
1682 if (dynobj == NULL)
1683 {
1684 asection *sgot;
1685
1686 if (! sunos_create_dynamic_sections (abfd, info, false))
1687 return false;
1688 dynobj = sunos_hash_table (info)->dynobj;
1689 splt = bfd_get_section_by_name (dynobj, ".plt");
1690 srel = bfd_get_section_by_name (dynobj, ".dynrel");
1691 BFD_ASSERT (splt != NULL && srel != NULL);
1692
1693 sgot = bfd_get_section_by_name (dynobj, ".got");
1694 BFD_ASSERT (sgot != NULL);
1695 if (sgot->_raw_size == 0)
1696 sgot->_raw_size = BYTES_IN_WORD;
1697 sunos_hash_table (info)->got_needed = true;
1698 }
1699
1700 BFD_ASSERT ((h->flags & SUNOS_REF_REGULAR) != 0);
1701 BFD_ASSERT (h->plt_offset != 0
1702 || ((h->root.root.type == bfd_link_hash_defined
1703 || h->root.root.type == bfd_link_hash_defweak)
1704 ? (h->root.root.u.def.section->owner->flags
1705 & DYNAMIC) != 0
1706 : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0));
1707
1708 /* This reloc is against a symbol defined only by a dynamic
1709 object. */
1710
1711 if (h->root.root.type == bfd_link_hash_undefined)
1712 {
1713 /* Presumably this symbol was marked as being undefined by
1714 an earlier reloc. */
1715 srel->_raw_size += RELOC_STD_SIZE;
1716 }
1717 else if ((h->root.root.u.def.section->flags & SEC_CODE) == 0)
1718 {
1719 bfd *sub;
1720
1721 /* This reloc is not in the .text section. It must be
1722 copied into the dynamic relocs. We mark the symbol as
1723 being undefined. */
1724 srel->_raw_size += RELOC_STD_SIZE;
1725 sub = h->root.root.u.def.section->owner;
1726 h->root.root.type = bfd_link_hash_undefined;
1727 h->root.root.u.undef.abfd = sub;
1728 }
1729 else
1730 {
1731 /* This symbol is in the .text section. We must give it an
1732 entry in the procedure linkage table, if we have not
1733 already done so. We change the definition of the symbol
1734 to the .plt section; this will cause relocs against it to
1735 be handled correctly. */
1736 if (h->plt_offset == 0)
1737 {
1738 if (splt->_raw_size == 0)
1739 splt->_raw_size = M68K_PLT_ENTRY_SIZE;
1740 h->plt_offset = splt->_raw_size;
1741
1742 if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1743 {
1744 h->root.root.u.def.section = splt;
1745 h->root.root.u.def.value = splt->_raw_size;
1746 }
1747
1748 splt->_raw_size += M68K_PLT_ENTRY_SIZE;
1749
1750 /* We may also need a dynamic reloc entry. */
1751 if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1752 srel->_raw_size += RELOC_STD_SIZE;
1753 }
1754 }
1755 }
1756
1757 return true;
1758}
1759
1760/* Scan the relocs for an input section using extended relocs. We
1761 need to figure out what to do for each reloc against a dynamic
1762 symbol. If the reloc is a WDISP30, and the symbol is in the .text
1763 section, an entry is made in the procedure linkage table.
1764 Otherwise, we must preserve the reloc as a dynamic reloc. */
1765
1766static boolean
1767sunos_scan_ext_relocs (info, abfd, sec, relocs, rel_size)
1768 struct bfd_link_info *info;
1769 bfd *abfd;
1770 asection *sec;
1771 const struct reloc_ext_external *relocs;
1772 bfd_size_type rel_size;
1773{
1774 bfd *dynobj;
1775 struct sunos_link_hash_entry **sym_hashes;
1776 const struct reloc_ext_external *rel, *relend;
1777 asection *splt = NULL;
1778 asection *sgot = NULL;
1779 asection *srel = NULL;
1780
1781 /* We only know how to handle SPARC plt entries. */
1782 if (bfd_get_arch (abfd) != bfd_arch_sparc)
1783 {
1784 bfd_set_error (bfd_error_invalid_target);
1785 return false;
1786 }
1787
1788 dynobj = NULL;
1789
1790 sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
1791
1792 relend = relocs + rel_size / RELOC_EXT_SIZE;
1793 for (rel = relocs; rel < relend; rel++)
1794 {
1795 unsigned int r_index;
1796 int r_extern;
1797 int r_type;
1798 struct sunos_link_hash_entry *h = NULL;
1799
1800 /* Swap in the reloc information. */
1801 if (bfd_header_big_endian (abfd))
1802 {
1803 r_index = ((rel->r_index[0] << 16)
1804 | (rel->r_index[1] << 8)
1805 | rel->r_index[2]);
1806 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
1807 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
1808 >> RELOC_EXT_BITS_TYPE_SH_BIG);
1809 }
1810 else
1811 {
1812 r_index = ((rel->r_index[2] << 16)
1813 | (rel->r_index[1] << 8)
1814 | rel->r_index[0]);
1815 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
1816 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
1817 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
1818 }
1819
1820 if (r_extern)
1821 {
1822 h = sym_hashes[r_index];
1823 if (h == NULL)
1824 {
1825 /* This should not normally happen, but it will in any
1826 case be caught in the relocation phase. */
1827 continue;
1828 }
1829 }
1830
1831 /* If this is a base relative reloc, we need to make an entry in
1832 the .got section. */
1833 if (r_type == RELOC_BASE10
1834 || r_type == RELOC_BASE13
1835 || r_type == RELOC_BASE22)
1836 {
1837 if (dynobj == NULL)
1838 {
1839 if (! sunos_create_dynamic_sections (abfd, info, false))
1840 return false;
1841 dynobj = sunos_hash_table (info)->dynobj;
1842 splt = bfd_get_section_by_name (dynobj, ".plt");
1843 sgot = bfd_get_section_by_name (dynobj, ".got");
1844 srel = bfd_get_section_by_name (dynobj, ".dynrel");
1845 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1846
1847 /* Make sure we have an initial entry in the .got table. */
1848 if (sgot->_raw_size == 0)
1849 sgot->_raw_size = BYTES_IN_WORD;
1850 sunos_hash_table (info)->got_needed = true;
1851 }
1852
1853 if (r_extern)
1854 {
1855 if (h->got_offset != 0)
1856 continue;
1857
1858 h->got_offset = sgot->_raw_size;
1859 }
1860 else
1861 {
1862 if (r_index >= bfd_get_symcount (abfd))
1863 {
1864 /* This is abnormal, but should be caught in the
1865 relocation phase. */
1866 continue;
1867 }
1868
1869 if (adata (abfd).local_got_offsets == NULL)
1870 {
1871 adata (abfd).local_got_offsets =
1872 (bfd_vma *) bfd_zalloc (abfd,
1873 (bfd_get_symcount (abfd)
1874 * sizeof (bfd_vma)));
1875 if (adata (abfd).local_got_offsets == NULL)
1876 return false;
1877 }
1878
1879 if (adata (abfd).local_got_offsets[r_index] != 0)
1880 continue;
1881
1882 adata (abfd).local_got_offsets[r_index] = sgot->_raw_size;
1883 }
1884
1885 sgot->_raw_size += BYTES_IN_WORD;
1886
1887 /* If we are making a shared library, or if the symbol is
1888 defined by a dynamic object, we will need a dynamic reloc
1889 entry. */
1890 if (info->shared
1891 || (h != NULL
1892 && (h->flags & SUNOS_DEF_DYNAMIC) != 0
1893 && (h->flags & SUNOS_DEF_REGULAR) == 0))
1894 srel->_raw_size += RELOC_EXT_SIZE;
1895
1896 continue;
1897 }
1898
1899 /* Otherwise, we are only interested in relocs against symbols
1900 defined in dynamic objects but not in regular objects. We
1901 only need to consider relocs against external symbols. */
1902 if (! r_extern)
1903 {
1904 /* But, if we are creating a shared library, we need to
1905 generate an absolute reloc. */
1906 if (info->shared)
1907 {
1908 if (dynobj == NULL)
1909 {
1910 if (! sunos_create_dynamic_sections (abfd, info, true))
1911 return false;
1912 dynobj = sunos_hash_table (info)->dynobj;
1913 splt = bfd_get_section_by_name (dynobj, ".plt");
1914 sgot = bfd_get_section_by_name (dynobj, ".got");
1915 srel = bfd_get_section_by_name (dynobj, ".dynrel");
1916 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1917 }
1918
1919 srel->_raw_size += RELOC_EXT_SIZE;
1920 }
1921
1922 continue;
1923 }
1924
1925 /* At this point common symbols have already been allocated, so
1926 we don't have to worry about them. We need to consider that
1927 we may have already seen this symbol and marked it undefined;
1928 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1929 will be zero. */
1930 if (h->root.root.type != bfd_link_hash_defined
1931 && h->root.root.type != bfd_link_hash_defweak
1932 && h->root.root.type != bfd_link_hash_undefined)
1933 continue;
1934
1935 if (r_type != RELOC_JMP_TBL
1936 && ! info->shared
1937 && ((h->flags & SUNOS_DEF_DYNAMIC) == 0
1938 || (h->flags & SUNOS_DEF_REGULAR) != 0))
1939 continue;
1940
1941 if (r_type == RELOC_JMP_TBL
1942 && ! info->shared
1943 && (h->flags & SUNOS_DEF_DYNAMIC) == 0
1944 && (h->flags & SUNOS_DEF_REGULAR) == 0)
1945 {
1946 /* This symbol is apparently undefined. Don't do anything
1947 here; just let the relocation routine report an undefined
1948 symbol. */
1949 continue;
1950 }
1951
1952 if (strcmp (h->root.root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
1953 continue;
1954
1955 if (dynobj == NULL)
1956 {
1957 if (! sunos_create_dynamic_sections (abfd, info, false))
1958 return false;
1959 dynobj = sunos_hash_table (info)->dynobj;
1960 splt = bfd_get_section_by_name (dynobj, ".plt");
1961 sgot = bfd_get_section_by_name (dynobj, ".got");
1962 srel = bfd_get_section_by_name (dynobj, ".dynrel");
1963 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1964
1965 /* Make sure we have an initial entry in the .got table. */
1966 if (sgot->_raw_size == 0)
1967 sgot->_raw_size = BYTES_IN_WORD;
1968 sunos_hash_table (info)->got_needed = true;
1969 }
1970
1971 BFD_ASSERT (r_type == RELOC_JMP_TBL
1972 || info->shared
1973 || (h->flags & SUNOS_REF_REGULAR) != 0);
1974 BFD_ASSERT (r_type == RELOC_JMP_TBL
1975 || info->shared
1976 || h->plt_offset != 0
1977 || ((h->root.root.type == bfd_link_hash_defined
1978 || h->root.root.type == bfd_link_hash_defweak)
1979 ? (h->root.root.u.def.section->owner->flags
1980 & DYNAMIC) != 0
1981 : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0));
1982
1983 /* This reloc is against a symbol defined only by a dynamic
1984 object, or it is a jump table reloc from PIC compiled code. */
1985
1986 if (r_type != RELOC_JMP_TBL
1987 && h->root.root.type == bfd_link_hash_undefined)
1988 {
1989 /* Presumably this symbol was marked as being undefined by
1990 an earlier reloc. */
1991 srel->_raw_size += RELOC_EXT_SIZE;
1992 }
1993 else if (r_type != RELOC_JMP_TBL
1994 && (h->root.root.u.def.section->flags & SEC_CODE) == 0)
1995 {
1996 bfd *sub;
1997
1998 /* This reloc is not in the .text section. It must be
1999 copied into the dynamic relocs. We mark the symbol as
2000 being undefined. */
2001 srel->_raw_size += RELOC_EXT_SIZE;
2002 if ((h->flags & SUNOS_DEF_REGULAR) == 0)
2003 {
2004 sub = h->root.root.u.def.section->owner;
2005 h->root.root.type = bfd_link_hash_undefined;
2006 h->root.root.u.undef.abfd = sub;
2007 }
2008 }
2009 else
2010 {
2011 /* This symbol is in the .text section. We must give it an
2012 entry in the procedure linkage table, if we have not
2013 already done so. We change the definition of the symbol
2014 to the .plt section; this will cause relocs against it to
2015 be handled correctly. */
2016 if (h->plt_offset == 0)
2017 {
2018 if (splt->_raw_size == 0)
2019 splt->_raw_size = SPARC_PLT_ENTRY_SIZE;
2020 h->plt_offset = splt->_raw_size;
2021
2022 if ((h->flags & SUNOS_DEF_REGULAR) == 0)
2023 {
2024 if (h->root.root.type == bfd_link_hash_undefined)
2025 h->root.root.type = bfd_link_hash_defined;
2026 h->root.root.u.def.section = splt;
2027 h->root.root.u.def.value = splt->_raw_size;
2028 }
2029
2030 splt->_raw_size += SPARC_PLT_ENTRY_SIZE;
2031
2032 /* We will also need a dynamic reloc entry, unless this
2033 is a JMP_TBL reloc produced by linking PIC compiled
2034 code, and we are not making a shared library. */
2035 if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
2036 srel->_raw_size += RELOC_EXT_SIZE;
2037 }
2038
2039 /* If we are creating a shared library, we need to copy over
2040 any reloc other than a jump table reloc. */
2041 if (info->shared && r_type != RELOC_JMP_TBL)
2042 srel->_raw_size += RELOC_EXT_SIZE;
2043 }
2044 }
2045
2046 return true;
2047}
2048
2049/* Build the hash table of dynamic symbols, and to mark as written all
2050 symbols from dynamic objects which we do not plan to write out. */
2051
2052static boolean
2053sunos_scan_dynamic_symbol (h, data)
2054 struct sunos_link_hash_entry *h;
2055 PTR data;
2056{
2057 struct bfd_link_info *info = (struct bfd_link_info *) data;
2058
2059 /* Set the written flag for symbols we do not want to write out as
2060 part of the regular symbol table. This is all symbols which are
2061 not defined in a regular object file. For some reason symbols
2062 which are referenced by a regular object and defined by a dynamic
2063 object do not seem to show up in the regular symbol table. It is
2064 possible for a symbol to have only SUNOS_REF_REGULAR set here, it
2065 is an undefined symbol which was turned into a common symbol
2066 because it was found in an archive object which was not included
2067 in the link. */
2068 if ((h->flags & SUNOS_DEF_REGULAR) == 0
2069 && (h->flags & SUNOS_DEF_DYNAMIC) != 0
2070 && strcmp (h->root.root.root.string, "__DYNAMIC") != 0)
2071 h->root.written = true;
2072
2073 /* If this symbol is defined by a dynamic object and referenced by a
2074 regular object, see whether we gave it a reasonable value while
2075 scanning the relocs. */
2076
2077 if ((h->flags & SUNOS_DEF_REGULAR) == 0
2078 && (h->flags & SUNOS_DEF_DYNAMIC) != 0
2079 && (h->flags & SUNOS_REF_REGULAR) != 0)
2080 {
2081 if ((h->root.root.type == bfd_link_hash_defined
2082 || h->root.root.type == bfd_link_hash_defweak)
2083 && ((h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
2084 && h->root.root.u.def.section->output_section == NULL)
2085 {
2086 bfd *sub;
2087
2088 /* This symbol is currently defined in a dynamic section
2089 which is not being put into the output file. This
2090 implies that there is no reloc against the symbol. I'm
2091 not sure why this case would ever occur. In any case, we
2092 change the symbol to be undefined. */
2093 sub = h->root.root.u.def.section->owner;
2094 h->root.root.type = bfd_link_hash_undefined;
2095 h->root.root.u.undef.abfd = sub;
2096 }
2097 }
2098
2099 /* If this symbol is defined or referenced by a regular file, add it
2100 to the dynamic symbols. */
2101 if ((h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
2102 {
2103 asection *s;
2104 size_t len;
2105 bfd_byte *contents;
2106 unsigned char *name;
2107 unsigned long hash;
2108 bfd *dynobj;
2109
2110 BFD_ASSERT (h->dynindx == -2);
2111
2112 dynobj = sunos_hash_table (info)->dynobj;
2113
2114 h->dynindx = sunos_hash_table (info)->dynsymcount;
2115 ++sunos_hash_table (info)->dynsymcount;
2116
2117 len = strlen (h->root.root.root.string);
2118
2119 /* We don't bother to construct a BFD hash table for the strings
2120 which are the names of the dynamic symbols. Using a hash
2121 table for the regular symbols is beneficial, because the
2122 regular symbols includes the debugging symbols, which have
2123 long names and are often duplicated in several object files.
2124 There are no debugging symbols in the dynamic symbols. */
2125 s = bfd_get_section_by_name (dynobj, ".dynstr");
2126 BFD_ASSERT (s != NULL);
2127 contents = (bfd_byte *) bfd_realloc (s->contents,
2128 s->_raw_size + len + 1);
2129 if (contents == NULL)
2130 return false;
2131 s->contents = contents;
2132
2133 h->dynstr_index = s->_raw_size;
2134 strcpy ((char *) contents + s->_raw_size, h->root.root.root.string);
2135 s->_raw_size += len + 1;
2136
2137 /* Add it to the dynamic hash table. */
2138 name = (unsigned char *) h->root.root.root.string;
2139 hash = 0;
2140 while (*name != '\0')
2141 hash = (hash << 1) + *name++;
2142 hash &= 0x7fffffff;
2143 hash %= sunos_hash_table (info)->bucketcount;
2144
2145 s = bfd_get_section_by_name (dynobj, ".hash");
2146 BFD_ASSERT (s != NULL);
2147
2148 if (GET_SWORD (dynobj, s->contents + hash * HASH_ENTRY_SIZE) == -1)
2149 PUT_WORD (dynobj, h->dynindx, s->contents + hash * HASH_ENTRY_SIZE);
2150 else
2151 {
2152 bfd_vma next;
2153
2154 next = GET_WORD (dynobj,
2155 (s->contents
2156 + hash * HASH_ENTRY_SIZE
2157 + BYTES_IN_WORD));
2158 PUT_WORD (dynobj, s->_raw_size / HASH_ENTRY_SIZE,
2159 s->contents + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD);
2160 PUT_WORD (dynobj, h->dynindx, s->contents + s->_raw_size);
2161 PUT_WORD (dynobj, next, s->contents + s->_raw_size + BYTES_IN_WORD);
2162 s->_raw_size += HASH_ENTRY_SIZE;
2163 }
2164 }
2165
2166 return true;
2167}
2168
2169/* Link a dynamic object. We actually don't have anything to do at
2170 this point. This entry point exists to prevent the regular linker
2171 code from doing anything with the object. */
2172
2173/*ARGSUSED*/
2174static boolean
2175sunos_link_dynamic_object (info, abfd)
2176 struct bfd_link_info *info;
2177 bfd *abfd;
2178{
2179 return true;
2180}
2181
2182/* Write out a dynamic symbol. This is called by the final traversal
2183 over the symbol table. */
2184
2185static boolean
2186sunos_write_dynamic_symbol (output_bfd, info, harg)
2187 bfd *output_bfd;
2188 struct bfd_link_info *info;
2189 struct aout_link_hash_entry *harg;
2190{
2191 struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
2192 int type;
2193 bfd_vma val;
2194 asection *s;
2195 struct external_nlist *outsym;
2196
2197 /* If this symbol is in the procedure linkage table, fill in the
2198 table entry. */
2199 if (h->plt_offset != 0)
2200 {
2201 bfd *dynobj;
2202 asection *splt;
2203 bfd_byte *p;
2204 asection *s;
2205 bfd_vma r_address;
2206
2207 dynobj = sunos_hash_table (info)->dynobj;
2208 splt = bfd_get_section_by_name (dynobj, ".plt");
2209 p = splt->contents + h->plt_offset;
2210
2211 s = bfd_get_section_by_name (dynobj, ".dynrel");
2212
2213 r_address = (splt->output_section->vma
2214 + splt->output_offset
2215 + h->plt_offset);
2216
2217 switch (bfd_get_arch (output_bfd))
2218 {
2219 case bfd_arch_sparc:
2220 if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
2221 {
2222 bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD0, p);
2223 bfd_put_32 (output_bfd,
2224 (SPARC_PLT_ENTRY_WORD1
2225 + (((- (h->plt_offset + 4) >> 2)
2226 & 0x3fffffff))),
2227 p + 4);
2228 bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD2 + s->reloc_count,
2229 p + 8);
2230 }
2231 else
2232 {
2233 bfd_vma val;
2234
2235 val = (h->root.root.u.def.section->output_section->vma
2236 + h->root.root.u.def.section->output_offset
2237 + h->root.root.u.def.value);
2238 bfd_put_32 (output_bfd,
2239 SPARC_PLT_PIC_WORD0 + ((val >> 10) & 0x3fffff),
2240 p);
2241 bfd_put_32 (output_bfd,
2242 SPARC_PLT_PIC_WORD1 + (val & 0x3ff),
2243 p + 4);
2244 bfd_put_32 (output_bfd, SPARC_PLT_PIC_WORD2, p + 8);
2245 }
2246 break;
2247
2248 case bfd_arch_m68k:
2249 if (! info->shared && (h->flags & SUNOS_DEF_REGULAR) != 0)
2250 abort ();
2251 bfd_put_16 (output_bfd, M68K_PLT_ENTRY_WORD0, p);
2252 bfd_put_32 (output_bfd, (- (h->plt_offset + 2)), p + 2);
2253 bfd_put_16 (output_bfd, s->reloc_count, p + 6);
2254 r_address += 2;
2255 break;
2256
2257 default:
2258 abort ();
2259 }
2260
2261 /* We also need to add a jump table reloc, unless this is the
2262 result of a JMP_TBL reloc from PIC compiled code. */
2263 if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
2264 {
2265 BFD_ASSERT (h->dynindx >= 0);
2266 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
2267 < s->_raw_size);
2268 p = s->contents + s->reloc_count * obj_reloc_entry_size (output_bfd);
2269 if (obj_reloc_entry_size (output_bfd) == RELOC_STD_SIZE)
2270 {
2271 struct reloc_std_external *srel;
2272
2273 srel = (struct reloc_std_external *) p;
2274 PUT_WORD (output_bfd, r_address, srel->r_address);
2275 if (bfd_header_big_endian (output_bfd))
2276 {
2277 srel->r_index[0] = (bfd_byte)(h->dynindx >> 16);
2278 srel->r_index[1] = (bfd_byte)(h->dynindx >> 8);
2279 srel->r_index[2] = (bfd_byte)(h->dynindx);
2280 srel->r_type[0] = (RELOC_STD_BITS_EXTERN_BIG
2281 | RELOC_STD_BITS_JMPTABLE_BIG);
2282 }
2283 else
2284 {
2285 srel->r_index[2] = (bfd_byte)(h->dynindx >> 16);
2286 srel->r_index[1] = (bfd_byte)(h->dynindx >> 8);
2287 srel->r_index[0] = (bfd_byte)h->dynindx;
2288 srel->r_type[0] = (RELOC_STD_BITS_EXTERN_LITTLE
2289 | RELOC_STD_BITS_JMPTABLE_LITTLE);
2290 }
2291 }
2292 else
2293 {
2294 struct reloc_ext_external *erel;
2295
2296 erel = (struct reloc_ext_external *) p;
2297 PUT_WORD (output_bfd, r_address, erel->r_address);
2298 if (bfd_header_big_endian (output_bfd))
2299 {
2300 erel->r_index[0] = (bfd_byte)(h->dynindx >> 16);
2301 erel->r_index[1] = (bfd_byte)(h->dynindx >> 8);
2302 erel->r_index[2] = (bfd_byte)h->dynindx;
2303 erel->r_type[0] =
2304 (RELOC_EXT_BITS_EXTERN_BIG
2305 | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_BIG));
2306 }
2307 else
2308 {
2309 erel->r_index[2] = (bfd_byte)(h->dynindx >> 16);
2310 erel->r_index[1] = (bfd_byte)(h->dynindx >> 8);
2311 erel->r_index[0] = (bfd_byte)h->dynindx;
2312 erel->r_type[0] =
2313 (RELOC_EXT_BITS_EXTERN_LITTLE
2314 | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2315 }
2316 PUT_WORD (output_bfd, (bfd_vma) 0, erel->r_addend);
2317 }
2318
2319 ++s->reloc_count;
2320 }
2321 }
2322
2323 /* If this is not a dynamic symbol, we don't have to do anything
2324 else. We only check this after handling the PLT entry, because
2325 we can have a PLT entry for a nondynamic symbol when linking PIC
2326 compiled code from a regular object. */
2327 if (h->dynindx < 0)
2328 return true;
2329
2330 switch (h->root.root.type)
2331 {
2332 default:
2333 case bfd_link_hash_new:
2334 abort ();
2335 /* Avoid variable not initialized warnings. */
2336 return true;
2337 case bfd_link_hash_undefined:
2338 type = N_UNDF | N_EXT;
2339 val = 0;
2340 break;
2341 case bfd_link_hash_defined:
2342 case bfd_link_hash_defweak:
2343 {
2344 asection *sec;
2345 asection *output_section;
2346
2347 sec = h->root.root.u.def.section;
2348 output_section = sec->output_section;
2349 BFD_ASSERT (bfd_is_abs_section (output_section)
2350 || output_section->owner == output_bfd);
2351 if (h->plt_offset != 0
2352 && (h->flags & SUNOS_DEF_REGULAR) == 0)
2353 {
2354 type = N_UNDF | N_EXT;
2355 val = 0;
2356 }
2357 else
2358 {
2359 if (output_section == obj_textsec (output_bfd))
2360 type = (h->root.root.type == bfd_link_hash_defined
2361 ? N_TEXT
2362 : N_WEAKT);
2363 else if (output_section == obj_datasec (output_bfd))
2364 type = (h->root.root.type == bfd_link_hash_defined
2365 ? N_DATA
2366 : N_WEAKD);
2367 else if (output_section == obj_bsssec (output_bfd))
2368 type = (h->root.root.type == bfd_link_hash_defined
2369 ? N_BSS
2370 : N_WEAKB);
2371 else
2372 type = (h->root.root.type == bfd_link_hash_defined
2373 ? N_ABS
2374 : N_WEAKA);
2375 type |= N_EXT;
2376 val = (h->root.root.u.def.value
2377 + output_section->vma
2378 + sec->output_offset);
2379 }
2380 }
2381 break;
2382 case bfd_link_hash_common:
2383 type = N_UNDF | N_EXT;
2384 val = h->root.root.u.c.size;
2385 break;
2386 case bfd_link_hash_undefweak:
2387 type = N_WEAKU;
2388 val = 0;
2389 break;
2390 case bfd_link_hash_indirect:
2391 case bfd_link_hash_warning:
2392 /* FIXME: Ignore these for now. The circumstances under which
2393 they should be written out are not clear to me. */
2394 return true;
2395 }
2396
2397 s = bfd_get_section_by_name (sunos_hash_table (info)->dynobj, ".dynsym");
2398 BFD_ASSERT (s != NULL);
2399 outsym = ((struct external_nlist *)
2400 (s->contents + h->dynindx * EXTERNAL_NLIST_SIZE));
2401
2402 bfd_h_put_8 (output_bfd, type, outsym->e_type);
2403 bfd_h_put_8 (output_bfd, 0, outsym->e_other);
2404
2405 /* FIXME: The native linker doesn't use 0 for desc. It seems to use
2406 one less than the desc value in the shared library, although that
2407 seems unlikely. */
2408 bfd_h_put_16 (output_bfd, 0, outsym->e_desc);
2409
2410 PUT_WORD (output_bfd, h->dynstr_index, outsym->e_strx);
2411 PUT_WORD (output_bfd, val, outsym->e_value);
2412
2413 return true;
2414}
2415
2416/* This is called for each reloc against an external symbol. If this
2417 is a reloc which are are going to copy as a dynamic reloc, then
2418 copy it over, and tell the caller to not bother processing this
2419 reloc. */
2420
2421/*ARGSUSED*/
2422static boolean
2423sunos_check_dynamic_reloc (info, input_bfd, input_section, harg, reloc,
2424 contents, skip, relocationp)
2425 struct bfd_link_info *info;
2426 bfd *input_bfd;
2427 asection *input_section;
2428 struct aout_link_hash_entry *harg;
2429 PTR reloc;
2430 bfd_byte *contents;
2431 boolean *skip;
2432 bfd_vma *relocationp;
2433{
2434 struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
2435 bfd *dynobj;
2436 boolean baserel;
2437 boolean jmptbl;
2438 boolean pcrel;
2439 asection *s;
2440 bfd_byte *p;
2441 long indx;
2442
2443 *skip = false;
2444
2445 dynobj = sunos_hash_table (info)->dynobj;
2446
2447 if (h != NULL
2448 && h->plt_offset != 0
2449 && (info->shared
2450 || (h->flags & SUNOS_DEF_REGULAR) == 0))
2451 {
2452 asection *splt;
2453
2454 /* Redirect the relocation to the PLT entry. */
2455 splt = bfd_get_section_by_name (dynobj, ".plt");
2456 *relocationp = (splt->output_section->vma
2457 + splt->output_offset
2458 + h->plt_offset);
2459 }
2460
2461 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
2462 {
2463 struct reloc_std_external *srel;
2464
2465 srel = (struct reloc_std_external *) reloc;
2466 if (bfd_header_big_endian (input_bfd))
2467 {
2468 baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2469 jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2470 pcrel = (0 != (srel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2471 }
2472 else
2473 {
2474 baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2475 jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2476 pcrel = (0 != (srel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2477 }
2478 }
2479 else
2480 {
2481 struct reloc_ext_external *erel;
2482 int r_type;
2483
2484 erel = (struct reloc_ext_external *) reloc;
2485 if (bfd_header_big_endian (input_bfd))
2486 r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2487 >> RELOC_EXT_BITS_TYPE_SH_BIG);
2488 else
2489 r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2490 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
2491 baserel = (r_type == RELOC_BASE10
2492 || r_type == RELOC_BASE13
2493 || r_type == RELOC_BASE22);
2494 jmptbl = r_type == RELOC_JMP_TBL;
2495 pcrel = (r_type == RELOC_DISP8
2496 || r_type == RELOC_DISP16
2497 || r_type == RELOC_DISP32
2498 || r_type == RELOC_WDISP30
2499 || r_type == RELOC_WDISP22);
2500 /* We don't consider the PC10 and PC22 types to be PC relative,
2501 because they are pcrel_offset. */
2502 }
2503
2504 if (baserel)
2505 {
2506 bfd_vma *got_offsetp;
2507 asection *sgot;
2508
2509 if (h != NULL)
2510 got_offsetp = &h->got_offset;
2511 else if (adata (input_bfd).local_got_offsets == NULL)
2512 got_offsetp = NULL;
2513 else
2514 {
2515 struct reloc_std_external *srel;
2516 int r_index;
2517
2518 srel = (struct reloc_std_external *) reloc;
2519 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
2520 {
2521 if (bfd_header_big_endian (input_bfd))
2522 r_index = ((srel->r_index[0] << 16)
2523 | (srel->r_index[1] << 8)
2524 | srel->r_index[2]);
2525 else
2526 r_index = ((srel->r_index[2] << 16)
2527 | (srel->r_index[1] << 8)
2528 | srel->r_index[0]);
2529 }
2530 else
2531 {
2532 struct reloc_ext_external *erel;
2533
2534 erel = (struct reloc_ext_external *) reloc;
2535 if (bfd_header_big_endian (input_bfd))
2536 r_index = ((erel->r_index[0] << 16)
2537 | (erel->r_index[1] << 8)
2538 | erel->r_index[2]);
2539 else
2540 r_index = ((erel->r_index[2] << 16)
2541 | (erel->r_index[1] << 8)
2542 | erel->r_index[0]);
2543 }
2544
2545 got_offsetp = adata (input_bfd).local_got_offsets + r_index;
2546 }
2547
2548 BFD_ASSERT (got_offsetp != NULL && *got_offsetp != 0);
2549
2550 sgot = bfd_get_section_by_name (dynobj, ".got");
2551
2552 /* We set the least significant bit to indicate whether we have
2553 already initialized the GOT entry. */
2554 if ((*got_offsetp & 1) == 0)
2555 {
2556 if (h == NULL
2557 || (! info->shared
2558 && ((h->flags & SUNOS_DEF_DYNAMIC) == 0
2559 || (h->flags & SUNOS_DEF_REGULAR) != 0)))
2560 PUT_WORD (dynobj, *relocationp, sgot->contents + *got_offsetp);
2561 else
2562 PUT_WORD (dynobj, 0, sgot->contents + *got_offsetp);
2563
2564 if (info->shared
2565 || (h != NULL
2566 && (h->flags & SUNOS_DEF_DYNAMIC) != 0
2567 && (h->flags & SUNOS_DEF_REGULAR) == 0))
2568 {
2569 /* We need to create a GLOB_DAT or 32 reloc to tell the
2570 dynamic linker to fill in this entry in the table. */
2571
2572 s = bfd_get_section_by_name (dynobj, ".dynrel");
2573 BFD_ASSERT (s != NULL);
2574 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
2575 < s->_raw_size);
2576
2577 p = (s->contents
2578 + s->reloc_count * obj_reloc_entry_size (dynobj));
2579
2580 if (h != NULL)
2581 indx = h->dynindx;
2582 else
2583 indx = 0;
2584
2585 if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE)
2586 {
2587 struct reloc_std_external *srel;
2588
2589 srel = (struct reloc_std_external *) p;
2590 PUT_WORD (dynobj,
2591 (*got_offsetp
2592 + sgot->output_section->vma
2593 + sgot->output_offset),
2594 srel->r_address);
2595 if (bfd_header_big_endian (dynobj))
2596 {
2597 srel->r_index[0] = (bfd_byte)(indx >> 16);
2598 srel->r_index[1] = (bfd_byte)(indx >> 8);
2599 srel->r_index[2] = (bfd_byte)indx;
2600 if (h == NULL)
2601 srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_BIG;
2602 else
2603 srel->r_type[0] =
2604 (RELOC_STD_BITS_EXTERN_BIG
2605 | RELOC_STD_BITS_BASEREL_BIG
2606 | RELOC_STD_BITS_RELATIVE_BIG
2607 | (2 << RELOC_STD_BITS_LENGTH_SH_BIG));
2608 }
2609 else
2610 {
2611 srel->r_index[2] = (bfd_byte)(indx >> 16);
2612 srel->r_index[1] = (bfd_byte)(indx >> 8);
2613 srel->r_index[0] = (bfd_byte)indx;
2614 if (h == NULL)
2615 srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_LITTLE;
2616 else
2617 srel->r_type[0] =
2618 (RELOC_STD_BITS_EXTERN_LITTLE
2619 | RELOC_STD_BITS_BASEREL_LITTLE
2620 | RELOC_STD_BITS_RELATIVE_LITTLE
2621 | (2 << RELOC_STD_BITS_LENGTH_SH_LITTLE));
2622 }
2623 }
2624 else
2625 {
2626 struct reloc_ext_external *erel;
2627
2628 erel = (struct reloc_ext_external *) p;
2629 PUT_WORD (dynobj,
2630 (*got_offsetp
2631 + sgot->output_section->vma
2632 + sgot->output_offset),
2633 erel->r_address);
2634 if (bfd_header_big_endian (dynobj))
2635 {
2636 erel->r_index[0] = (bfd_byte)(indx >> 16);
2637 erel->r_index[1] = (bfd_byte)(indx >> 8);
2638 erel->r_index[2] = (bfd_byte)indx;
2639 if (h == NULL)
2640 erel->r_type[0] =
2641 RELOC_32 << RELOC_EXT_BITS_TYPE_SH_BIG;
2642 else
2643 erel->r_type[0] =
2644 (RELOC_EXT_BITS_EXTERN_BIG
2645 | (RELOC_GLOB_DAT << RELOC_EXT_BITS_TYPE_SH_BIG));
2646 }
2647 else
2648 {
2649 erel->r_index[2] = (bfd_byte)(indx >> 16);
2650 erel->r_index[1] = (bfd_byte)(indx >> 8);
2651 erel->r_index[0] = (bfd_byte)indx;
2652 if (h == NULL)
2653 erel->r_type[0] =
2654 RELOC_32 << RELOC_EXT_BITS_TYPE_SH_LITTLE;
2655 else
2656 erel->r_type[0] =
2657 (RELOC_EXT_BITS_EXTERN_LITTLE
2658 | (RELOC_GLOB_DAT
2659 << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2660 }
2661 PUT_WORD (dynobj, 0, erel->r_addend);
2662 }
2663
2664 ++s->reloc_count;
2665 }
2666
2667 *got_offsetp |= 1;
2668 }
2669
2670 *relocationp = (sgot->vma
2671 + (*got_offsetp &~ 1)
2672 - sunos_hash_table (info)->got_base);
2673
2674 /* There is nothing else to do for a base relative reloc. */
2675 return true;
2676 }
2677
2678 if (! sunos_hash_table (info)->dynamic_sections_needed)
2679 return true;
2680 if (! info->shared)
2681 {
2682 if (h == NULL
2683 || h->dynindx == -1
2684 || h->root.root.type != bfd_link_hash_undefined
2685 || (h->flags & SUNOS_DEF_REGULAR) != 0
2686 || (h->flags & SUNOS_DEF_DYNAMIC) == 0
2687 || (h->root.root.u.undef.abfd->flags & DYNAMIC) == 0)
2688 return true;
2689 }
2690 else
2691 {
2692 if (h != NULL
2693 && (h->dynindx == -1
2694 || jmptbl
2695 || strcmp (h->root.root.root.string,
2696 "__GLOBAL_OFFSET_TABLE_") == 0))
2697 return true;
2698 }
2699
2700 /* It looks like this is a reloc we are supposed to copy. */
2701
2702 s = bfd_get_section_by_name (dynobj, ".dynrel");
2703 BFD_ASSERT (s != NULL);
2704 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) < s->_raw_size);
2705
2706 p = s->contents + s->reloc_count * obj_reloc_entry_size (dynobj);
2707
2708 /* Copy the reloc over. */
2709 memcpy (p, reloc, obj_reloc_entry_size (dynobj));
2710
2711 if (h != NULL)
2712 indx = h->dynindx;
2713 else
2714 indx = 0;
2715
2716 /* Adjust the address and symbol index. */
2717 if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE)
2718 {
2719 struct reloc_std_external *srel;
2720
2721 srel = (struct reloc_std_external *) p;
2722 PUT_WORD (dynobj,
2723 (GET_WORD (dynobj, srel->r_address)
2724 + input_section->output_section->vma
2725 + input_section->output_offset),
2726 srel->r_address);
2727 if (bfd_header_big_endian (dynobj))
2728 {
2729 srel->r_index[0] = (bfd_byte)(indx >> 16);
2730 srel->r_index[1] = (bfd_byte)(indx >> 8);
2731 srel->r_index[2] = (bfd_byte)indx;
2732 }
2733 else
2734 {
2735 srel->r_index[2] = (bfd_byte)(indx >> 16);
2736 srel->r_index[1] = (bfd_byte)(indx >> 8);
2737 srel->r_index[0] = (bfd_byte)indx;
2738 }
2739 /* FIXME: We may have to change the addend for a PC relative
2740 reloc. */
2741 }
2742 else
2743 {
2744 struct reloc_ext_external *erel;
2745
2746 erel = (struct reloc_ext_external *) p;
2747 PUT_WORD (dynobj,
2748 (GET_WORD (dynobj, erel->r_address)
2749 + input_section->output_section->vma
2750 + input_section->output_offset),
2751 erel->r_address);
2752 if (bfd_header_big_endian (dynobj))
2753 {
2754 erel->r_index[0] = (bfd_byte)(indx >> 16);
2755 erel->r_index[1] = (bfd_byte)(indx >> 8);
2756 erel->r_index[2] = (bfd_byte)indx;
2757 }
2758 else
2759 {
2760 erel->r_index[2] = (bfd_byte)(indx >> 16);
2761 erel->r_index[1] = (bfd_byte)(indx >> 8);
2762 erel->r_index[0] = (bfd_byte)indx;
2763 }
2764 if (pcrel && h != NULL)
2765 {
2766 /* Adjust the addend for the change in address. */
2767 PUT_WORD (dynobj,
2768 (GET_WORD (dynobj, erel->r_addend)
2769 - (input_section->output_section->vma
2770 + input_section->output_offset
2771 - input_section->vma)),
2772 erel->r_addend);
2773 }
2774 }
2775
2776 ++s->reloc_count;
2777
2778 if (h != NULL)
2779 *skip = true;
2780
2781 return true;
2782}
2783
2784/* Finish up the dynamic linking information. */
2785
2786static boolean
2787sunos_finish_dynamic_link (abfd, info)
2788 bfd *abfd;
2789 struct bfd_link_info *info;
2790{
2791 bfd *dynobj;
2792 asection *o;
2793 asection *s;
2794 asection *sdyn;
2795
2796 if (! sunos_hash_table (info)->dynamic_sections_needed
2797 && ! sunos_hash_table (info)->got_needed)
2798 return true;
2799
2800 dynobj = sunos_hash_table (info)->dynobj;
2801
2802 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2803 BFD_ASSERT (sdyn != NULL);
2804
2805 /* Finish up the .need section. The linker emulation code filled it
2806 in, but with offsets from the start of the section instead of
2807 real addresses. Now that we know the section location, we can
2808 fill in the final values. */
2809 s = bfd_get_section_by_name (dynobj, ".need");
2810 if (s != NULL && s->_raw_size != 0)
2811 {
2812 file_ptr filepos;
2813 bfd_byte *p;
2814
2815 filepos = s->output_section->filepos + s->output_offset;
2816 p = s->contents;
2817 while (1)
2818 {
2819 bfd_vma val;
2820
2821 PUT_WORD (dynobj, GET_WORD (dynobj, p) + filepos, p);
2822 val = GET_WORD (dynobj, p + 12);
2823 if (val == 0)
2824 break;
2825 PUT_WORD (dynobj, val + filepos, p + 12);
2826 p += 16;
2827 }
2828 }
2829
2830 /* The first entry in the .got section is the address of the
2831 dynamic information, unless this is a shared library. */
2832 s = bfd_get_section_by_name (dynobj, ".got");
2833 BFD_ASSERT (s != NULL);
2834 if (info->shared || sdyn->_raw_size == 0)
2835 PUT_WORD (dynobj, 0, s->contents);
2836 else
2837 PUT_WORD (dynobj, sdyn->output_section->vma + sdyn->output_offset,
2838 s->contents);
2839
2840 for (o = dynobj->sections; o != NULL; o = o->next)
2841 {
2842 if ((o->flags & SEC_HAS_CONTENTS) != 0
2843 && o->contents != NULL)
2844 {
2845 BFD_ASSERT (o->output_section != NULL
2846 && o->output_section->owner == abfd);
2847 if (! bfd_set_section_contents (abfd, o->output_section,
2848 o->contents, o->output_offset,
2849 o->_raw_size))
2850 return false;
2851 }
2852 }
2853
2854 if (sdyn->_raw_size > 0)
2855 {
2856 struct external_sun4_dynamic esd;
2857 struct external_sun4_dynamic_link esdl;
2858
2859 /* Finish up the dynamic link information. */
2860 PUT_WORD (dynobj, (bfd_vma) 3, esd.ld_version);
2861 PUT_WORD (dynobj,
2862 sdyn->output_section->vma + sdyn->output_offset + sizeof esd,
2863 esd.ldd);
2864 PUT_WORD (dynobj,
2865 (sdyn->output_section->vma
2866 + sdyn->output_offset
2867 + sizeof esd
2868 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE),
2869 esd.ld);
2870
2871 if (! bfd_set_section_contents (abfd, sdyn->output_section, &esd,
2872 sdyn->output_offset, sizeof esd))
2873 return false;
2874
2875 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_loaded);
2876
2877 s = bfd_get_section_by_name (dynobj, ".need");
2878 if (s == NULL || s->_raw_size == 0)
2879 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_need);
2880 else
2881 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2882 esdl.ld_need);
2883
2884 s = bfd_get_section_by_name (dynobj, ".rules");
2885 if (s == NULL || s->_raw_size == 0)
2886 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_rules);
2887 else
2888 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2889 esdl.ld_rules);
2890
2891 s = bfd_get_section_by_name (dynobj, ".got");
2892 BFD_ASSERT (s != NULL);
2893 PUT_WORD (dynobj, s->output_section->vma + s->output_offset,
2894 esdl.ld_got);
2895
2896 s = bfd_get_section_by_name (dynobj, ".plt");
2897 BFD_ASSERT (s != NULL);
2898 PUT_WORD (dynobj, s->output_section->vma + s->output_offset,
2899 esdl.ld_plt);
2900 PUT_WORD (dynobj, s->_raw_size, esdl.ld_plt_sz);
2901
2902 s = bfd_get_section_by_name (dynobj, ".dynrel");
2903 BFD_ASSERT (s != NULL);
2904 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
2905 == s->_raw_size);
2906 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2907 esdl.ld_rel);
2908
2909 s = bfd_get_section_by_name (dynobj, ".hash");
2910 BFD_ASSERT (s != NULL);
2911 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2912 esdl.ld_hash);
2913
2914 s = bfd_get_section_by_name (dynobj, ".dynsym");
2915 BFD_ASSERT (s != NULL);
2916 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2917 esdl.ld_stab);
2918
2919 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_stab_hash);
2920
2921 PUT_WORD (dynobj, (bfd_vma) sunos_hash_table (info)->bucketcount,
2922 esdl.ld_buckets);
2923
2924 s = bfd_get_section_by_name (dynobj, ".dynstr");
2925 BFD_ASSERT (s != NULL);
2926 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2927 esdl.ld_symbols);
2928 PUT_WORD (dynobj, s->_raw_size, esdl.ld_symb_size);
2929
2930 /* The size of the text area is the size of the .text section
2931 rounded up to a page boundary. FIXME: Should the page size be
2932 conditional on something? */
2933 PUT_WORD (dynobj,
2934 BFD_ALIGN (obj_textsec (abfd)->_raw_size, 0x2000),
2935 esdl.ld_text);
2936
2937 if (! bfd_set_section_contents (abfd, sdyn->output_section, &esdl,
2938 (sdyn->output_offset
2939 + sizeof esd
2940 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE),
2941 sizeof esdl))
2942 return false;
2943
2944 abfd->flags |= DYNAMIC;
2945 }
2946
2947 return true;
2948}
GDB Binutils - Deliverables
This page took 0.128505 seconds and 4 git commands to generate.