bfd/sunos.c

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