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