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