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