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