contrib/binutils/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_with_flags (abfd, ".dynamic", flags);
 749       if (s == NULL
 750           || ! bfd_set_section_alignment (abfd, s, 2))
 751         return FALSE;
 752
 753       /* The .got section holds the global offset table.  The address
 754          is put in the ld_got field.  */
 755       s = bfd_make_section_with_flags (abfd, ".got", flags);
 756       if (s == NULL
 757           || ! bfd_set_section_alignment (abfd, s, 2))
 758         return FALSE;
 759
 760       /* The .plt section holds the procedure linkage table.  The
 761          address is put in the ld_plt field.  */
 762       s = bfd_make_section_with_flags (abfd, ".plt", flags | SEC_CODE);
 763       if (s == NULL
 764           || ! bfd_set_section_alignment (abfd, s, 2))
 765         return FALSE;
 766
 767       /* The .dynrel section holds the dynamic relocs.  The address is
 768          put in the ld_rel field.  */
 769       s = bfd_make_section_with_flags (abfd, ".dynrel", flags | SEC_READONLY);
 770       if (s == NULL
 771           || ! bfd_set_section_alignment (abfd, s, 2))
 772         return FALSE;
 773
 774       /* The .hash section holds the dynamic hash table.  The address
 775          is put in the ld_hash field.  */
 776       s = bfd_make_section_with_flags (abfd, ".hash", flags | SEC_READONLY);
 777       if (s == NULL
 778           || ! bfd_set_section_alignment (abfd, s, 2))
 779         return FALSE;
 780
 781       /* The .dynsym section holds the dynamic symbols.  The address
 782          is put in the ld_stab field.  */
 783       s = bfd_make_section_with_flags (abfd, ".dynsym", flags | SEC_READONLY);
 784       if (s == NULL
 785           || ! bfd_set_section_alignment (abfd, s, 2))
 786         return FALSE;
 787
 788       /* The .dynstr section holds the dynamic symbol string table.
 789          The address is put in the ld_symbols field.  */
 790       s = bfd_make_section_with_flags (abfd, ".dynstr", flags | SEC_READONLY);
 791       if (s == NULL
 792           || ! bfd_set_section_alignment (abfd, s, 2))
 793         return FALSE;
 794
 795       sunos_hash_table (info)->dynamic_sections_created = TRUE;
 796     }
 797
 798   if ((needed && ! sunos_hash_table (info)->dynamic_sections_needed)
 799       || info->shared)
 800     {
 801       bfd *dynobj;
 802
 803       dynobj = sunos_hash_table (info)->dynobj;
 804
 805       s = bfd_get_section_by_name (dynobj, ".got");
 806       if (s->size == 0)
 807         s->size = BYTES_IN_WORD;
 808
 809       sunos_hash_table (info)->dynamic_sections_needed = TRUE;
 810       sunos_hash_table (info)->got_needed = TRUE;
 811     }
 812
 813   return TRUE;
 814 }
 815
 816 /* Add dynamic symbols during a link.  This is called by the a.out
 817    backend linker for each object it encounters.  */
 818
 819 static bfd_boolean
 820 sunos_add_dynamic_symbols (bfd *abfd,
 821                            struct bfd_link_info *info,
 822                            struct external_nlist **symsp,
 823                            bfd_size_type *sym_countp,
 824                            char **stringsp)
 825 {
 826   bfd *dynobj;
 827   struct sunos_dynamic_info *dinfo;
 828   unsigned long need;
 829
 830   /* Make sure we have all the required sections.  */
 831   if (info->hash->creator == abfd->xvec)
 832     {
 833       if (! sunos_create_dynamic_sections (abfd, info,
 834                                            ((abfd->flags & DYNAMIC) != 0
 835                                             && !info->relocatable)))
 836         return FALSE;
 837     }
 838
 839   /* There is nothing else to do for a normal object.  */
 840   if ((abfd->flags & DYNAMIC) == 0)
 841     return TRUE;
 842
 843   dynobj = sunos_hash_table (info)->dynobj;
 844
 845   /* We do not want to include the sections in a dynamic object in the
 846      output file.  We hack by simply clobbering the list of sections
 847      in the BFD.  This could be handled more cleanly by, say, a new
 848      section flag; the existing SEC_NEVER_LOAD flag is not the one we
 849      want, because that one still implies that the section takes up
 850      space in the output file.  If this is the first object we have
 851      seen, we must preserve the dynamic sections we just created.  */
 852   if (abfd != dynobj)
 853     abfd->sections = NULL;
 854   else
 855     {
 856       asection *s;
 857
 858       for (s = abfd->sections; s != NULL; s = s->next)
 859         {
 860           if ((s->flags & SEC_LINKER_CREATED) == 0)
 861             bfd_section_list_remove (abfd, s);
 862         }
 863     }
 864
 865   /* The native linker seems to just ignore dynamic objects when -r is
 866      used.  */
 867   if (info->relocatable)
 868     return TRUE;
 869
 870   /* There's no hope of using a dynamic object which does not exactly
 871      match the format of the output file.  */
 872   if (info->hash->creator != abfd->xvec)
 873     {
 874       bfd_set_error (bfd_error_invalid_operation);
 875       return FALSE;
 876     }
 877
 878   /* Make sure we have a .need and a .rules sections.  These are only
 879      needed if there really is a dynamic object in the link, so they
 880      are not added by sunos_create_dynamic_sections.  */
 881   if (bfd_get_section_by_name (dynobj, ".need") == NULL)
 882     {
 883       /* The .need section holds the list of names of shared objets
 884          which must be included at runtime.  The address of this
 885          section is put in the ld_need field.  */
 886       flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 887                         | SEC_IN_MEMORY | SEC_READONLY);
 888       asection *s = bfd_make_section_with_flags (dynobj, ".need", flags);
 889       if (s == NULL
 890           || ! bfd_set_section_alignment (dynobj, s, 2))
 891         return FALSE;
 892     }
 893
 894   if (bfd_get_section_by_name (dynobj, ".rules") == NULL)
 895     {
 896       /* The .rules section holds the path to search for shared
 897          objects.  The address of this section is put in the ld_rules
 898          field.  */
 899       flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 900                         | SEC_IN_MEMORY | SEC_READONLY);
 901       asection *s = bfd_make_section_with_flags (dynobj, ".rules", flags);
 902       if (s == NULL
 903           || ! bfd_set_section_alignment (dynobj, s, 2))
 904         return FALSE;
 905     }
 906
 907   /* Pick up the dynamic symbols and return them to the caller.  */
 908   if (! sunos_slurp_dynamic_symtab (abfd))
 909     return FALSE;
 910
 911   dinfo = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
 912   *symsp = dinfo->dynsym;
 913   *sym_countp = dinfo->dynsym_count;
 914   *stringsp = dinfo->dynstr;
 915
 916   /* Record information about any other objects needed by this one.  */
 917   need = dinfo->dyninfo.ld_need;
 918   while (need != 0)
 919     {
 920       bfd_byte buf[16];
 921       unsigned long name, flags;
 922       unsigned short major_vno, minor_vno;
 923       struct bfd_link_needed_list *needed, **pp;
 924       char *namebuf, *p;
 925       bfd_size_type alc;
 926       bfd_byte b;
 927       char *namecopy;
 928
 929       if (bfd_seek (abfd, (file_ptr) need, SEEK_SET) != 0
 930           || bfd_bread (buf, (bfd_size_type) 16, abfd) != 16)
 931         return FALSE;
 932
 933       /* For the format of an ld_need entry, see aout/sun4.h.  We
 934          should probably define structs for this manipulation.  */
 935       name = bfd_get_32 (abfd, buf);
 936       flags = bfd_get_32 (abfd, buf + 4);
 937       major_vno = (unsigned short) bfd_get_16 (abfd, buf + 8);
 938       minor_vno = (unsigned short) bfd_get_16 (abfd, buf + 10);
 939       need = bfd_get_32 (abfd, buf + 12);
 940
 941       alc = sizeof (struct bfd_link_needed_list);
 942       needed = bfd_alloc (abfd, alc);
 943       if (needed == NULL)
 944         return FALSE;
 945       needed->by = abfd;
 946
 947       /* We return the name as [-l]name[.maj][.min].  */
 948       alc = 30;
 949       namebuf = bfd_malloc (alc + 1);
 950       if (namebuf == NULL)
 951         return FALSE;
 952       p = namebuf;
 953
 954       if ((flags & 0x80000000) != 0)
 955         {
 956           *p++ = '-';
 957           *p++ = 'l';
 958         }
 959       if (bfd_seek (abfd, (file_ptr) name, SEEK_SET) != 0)
 960         {
 961           free (namebuf);
 962           return FALSE;
 963         }
 964
 965       do
 966         {
 967           if (bfd_bread (&b, (bfd_size_type) 1, abfd) != 1)
 968             {
 969               free (namebuf);
 970               return FALSE;
 971             }
 972
 973           if ((bfd_size_type) (p - namebuf) >= alc)
 974             {
 975               char *n;
 976
 977               alc *= 2;
 978               n = bfd_realloc (namebuf, alc + 1);
 979               if (n == NULL)
 980                 {
 981                   free (namebuf);
 982                   return FALSE;
 983                 }
 984               p = n + (p - namebuf);
 985               namebuf = n;
 986             }
 987
 988           *p++ = b;
 989         }
 990       while (b != '\0');
 991
 992       if (major_vno == 0)
 993         *p = '\0';
 994       else
 995         {
 996           char majbuf[30];
 997           char minbuf[30];
 998
 999           sprintf (majbuf, ".%d", major_vno);
1000           if (minor_vno == 0)
1001             minbuf[0] = '\0';
1002           else
1003             sprintf (minbuf, ".%d", minor_vno);
1004
1005           if ((p - namebuf) + strlen (majbuf) + strlen (minbuf) >= alc)
1006             {
1007               char *n;
1008
1009               alc = (p - namebuf) + strlen (majbuf) + strlen (minbuf);
1010               n = bfd_realloc (namebuf, alc + 1);
1011               if (n == NULL)
1012                 {
1013                   free (namebuf);
1014                   return FALSE;
1015                 }
1016               p = n + (p - namebuf);
1017               namebuf = n;
1018             }
1019
1020           strcpy (p, majbuf);
1021           strcat (p, minbuf);
1022         }
1023
1024       namecopy = bfd_alloc (abfd, (bfd_size_type) strlen (namebuf) + 1);
1025       if (namecopy == NULL)
1026         {
1027           free (namebuf);
1028           return FALSE;
1029         }
1030       strcpy (namecopy, namebuf);
1031       free (namebuf);
1032       needed->name = namecopy;
1033
1034       needed->next = NULL;
1035
1036       for (pp = &sunos_hash_table (info)->needed;
1037            *pp != NULL;
1038            pp = &(*pp)->next)
1039         ;
1040       *pp = needed;
1041     }
1042
1043   return TRUE;
1044 }
1045
1046 /* Function to add a single symbol to the linker hash table.  This is
1047    a wrapper around _bfd_generic_link_add_one_symbol which handles the
1048    tweaking needed for dynamic linking support.  */
1049
1050 static bfd_boolean
1051 sunos_add_one_symbol (struct bfd_link_info *info,
1052                       bfd *abfd,
1053                       const char *name,
1054                       flagword flags,
1055                       asection *section,
1056                       bfd_vma value,
1057                       const char *string,
1058                       bfd_boolean copy,
1059                       bfd_boolean collect,
1060                       struct bfd_link_hash_entry **hashp)
1061 {
1062   struct sunos_link_hash_entry *h;
1063   int new_flag;
1064
1065   if ((flags & (BSF_INDIRECT | BSF_WARNING | BSF_CONSTRUCTOR)) != 0
1066       || ! bfd_is_und_section (section))
1067     h = sunos_link_hash_lookup (sunos_hash_table (info), name, TRUE, copy,
1068                                 FALSE);
1069   else
1070     h = ((struct sunos_link_hash_entry *)
1071          bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, copy, FALSE));
1072   if (h == NULL)
1073     return FALSE;
1074
1075   if (hashp != NULL)
1076     *hashp = (struct bfd_link_hash_entry *) h;
1077
1078   /* Treat a common symbol in a dynamic object as defined in the .bss
1079      section of the dynamic object.  We don't want to allocate space
1080      for it in our process image.  */
1081   if ((abfd->flags & DYNAMIC) != 0
1082       && bfd_is_com_section (section))
1083     section = obj_bsssec (abfd);
1084
1085   if (! bfd_is_und_section (section)
1086       && h->root.root.type != bfd_link_hash_new
1087       && h->root.root.type != bfd_link_hash_undefined
1088       && h->root.root.type != bfd_link_hash_defweak)
1089     {
1090       /* We are defining the symbol, and it is already defined.  This
1091          is a potential multiple definition error.  */
1092       if ((abfd->flags & DYNAMIC) != 0)
1093         {
1094           /* The definition we are adding is from a dynamic object.
1095              We do not want this new definition to override the
1096              existing definition, so we pretend it is just a
1097              reference.  */
1098           section = bfd_und_section_ptr;
1099         }
1100       else if (h->root.root.type == bfd_link_hash_defined
1101                && h->root.root.u.def.section->owner != NULL
1102                && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
1103         {
1104           /* The existing definition is from a dynamic object.  We
1105              want to override it with the definition we just found.
1106              Clobber the existing definition.  */
1107           h->root.root.type = bfd_link_hash_undefined;
1108           h->root.root.u.undef.abfd = h->root.root.u.def.section->owner;
1109         }
1110       else if (h->root.root.type == bfd_link_hash_common
1111                && (h->root.root.u.c.p->section->owner->flags & DYNAMIC) != 0)
1112         {
1113           /* The existing definition is from a dynamic object.  We
1114              want to override it with the definition we just found.
1115              Clobber the existing definition.  We can't set it to new,
1116              because it is on the undefined list.  */
1117           h->root.root.type = bfd_link_hash_undefined;
1118           h->root.root.u.undef.abfd = h->root.root.u.c.p->section->owner;
1119         }
1120     }
1121
1122   if ((abfd->flags & DYNAMIC) != 0
1123       && abfd->xvec == info->hash->creator
1124       && (h->flags & SUNOS_CONSTRUCTOR) != 0)
1125     /* The existing symbol is a constructor symbol, and this symbol
1126        is from a dynamic object.  A constructor symbol is actually a
1127        definition, although the type will be bfd_link_hash_undefined
1128        at this point.  We want to ignore the definition from the
1129        dynamic object.  */
1130     section = bfd_und_section_ptr;
1131   else if ((flags & BSF_CONSTRUCTOR) != 0
1132            && (abfd->flags & DYNAMIC) == 0
1133            && h->root.root.type == bfd_link_hash_defined
1134            && h->root.root.u.def.section->owner != NULL
1135            && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
1136     /* The existing symbol is defined by a dynamic object, and this
1137        is a constructor symbol.  As above, we want to force the use
1138        of the constructor symbol from the regular object.  */
1139     h->root.root.type = bfd_link_hash_new;
1140
1141   /* Do the usual procedure for adding a symbol.  */
1142   if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
1143                                           value, string, copy, collect,
1144                                           hashp))
1145     return FALSE;
1146
1147   if (abfd->xvec == info->hash->creator)
1148     {
1149       /* Set a flag in the hash table entry indicating the type of
1150          reference or definition we just found.  Keep a count of the
1151          number of dynamic symbols we find.  A dynamic symbol is one
1152          which is referenced or defined by both a regular object and a
1153          shared object.  */
1154       if ((abfd->flags & DYNAMIC) == 0)
1155         {
1156           if (bfd_is_und_section (section))
1157             new_flag = SUNOS_REF_REGULAR;
1158           else
1159             new_flag = SUNOS_DEF_REGULAR;
1160         }
1161       else
1162         {
1163           if (bfd_is_und_section (section))
1164             new_flag = SUNOS_REF_DYNAMIC;
1165           else
1166             new_flag = SUNOS_DEF_DYNAMIC;
1167         }
1168       h->flags |= new_flag;
1169
1170       if (h->dynindx == -1
1171           && (h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
1172         {
1173           ++sunos_hash_table (info)->dynsymcount;
1174           h->dynindx = -2;
1175         }
1176
1177       if ((flags & BSF_CONSTRUCTOR) != 0
1178           && (abfd->flags & DYNAMIC) == 0)
1179         h->flags |= SUNOS_CONSTRUCTOR;
1180     }
1181
1182   return TRUE;
1183 }
1184
1185 extern const bfd_target MY (vec);
1186
1187 /* Return the list of objects needed by BFD.  */
1188
1189 struct bfd_link_needed_list *
1190 bfd_sunos_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
1191                            struct bfd_link_info *info)
1192 {
1193   if (info->hash->creator != &MY (vec))
1194     return NULL;
1195   return sunos_hash_table (info)->needed;
1196 }
1197
1198 /* Record an assignment made to a symbol by a linker script.  We need
1199    this in case some dynamic object refers to this symbol.  */
1200
1201 bfd_boolean
1202 bfd_sunos_record_link_assignment (bfd *output_bfd,
1203                                   struct bfd_link_info *info,
1204                                   const char *name)
1205 {
1206   struct sunos_link_hash_entry *h;
1207
1208   if (output_bfd->xvec != &MY(vec))
1209     return TRUE;
1210
1211   /* This is called after we have examined all the input objects.  If
1212      the symbol does not exist, it merely means that no object refers
1213      to it, and we can just ignore it at this point.  */
1214   h = sunos_link_hash_lookup (sunos_hash_table (info), name,
1215                               FALSE, FALSE, FALSE);
1216   if (h == NULL)
1217     return TRUE;
1218
1219   /* In a shared library, the __DYNAMIC symbol does not appear in the
1220      dynamic symbol table.  */
1221   if (! info->shared || strcmp (name, "__DYNAMIC") != 0)
1222     {
1223       h->flags |= SUNOS_DEF_REGULAR;
1224
1225       if (h->dynindx == -1)
1226         {
1227           ++sunos_hash_table (info)->dynsymcount;
1228           h->dynindx = -2;
1229         }
1230     }
1231
1232   return TRUE;
1233 }
1234
1235 /* Scan the relocs for an input section using standard relocs.  We
1236    need to figure out what to do for each reloc against a dynamic
1237    symbol.  If the symbol is in the .text section, an entry is made in
1238    the procedure linkage table.  Note that this will do the wrong
1239    thing if the symbol is actually data; I don't think the Sun 3
1240    native linker handles this case correctly either.  If the symbol is
1241    not in the .text section, we must preserve the reloc as a dynamic
1242    reloc.  FIXME: We should also handle the PIC relocs here by
1243    building global offset table entries.  */
1244
1245 static bfd_boolean
1246 sunos_scan_std_relocs (struct bfd_link_info *info,
1247                        bfd *abfd,
1248                        asection *sec ATTRIBUTE_UNUSED,
1249                        const struct reloc_std_external *relocs,
1250                        bfd_size_type rel_size)
1251 {
1252   bfd *dynobj;
1253   asection *splt = NULL;
1254   asection *srel = NULL;
1255   struct sunos_link_hash_entry **sym_hashes;
1256   const struct reloc_std_external *rel, *relend;
1257
1258   /* We only know how to handle m68k plt entries.  */
1259   if (bfd_get_arch (abfd) != bfd_arch_m68k)
1260     {
1261       bfd_set_error (bfd_error_invalid_target);
1262       return FALSE;
1263     }
1264
1265   dynobj = NULL;
1266
1267   sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
1268
1269   relend = relocs + rel_size / RELOC_STD_SIZE;
1270   for (rel = relocs; rel < relend; rel++)
1271     {
1272       int r_index;
1273       struct sunos_link_hash_entry *h;
1274
1275       /* We only want relocs against external symbols.  */
1276       if (bfd_header_big_endian (abfd))
1277         {
1278           if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG) == 0)
1279             continue;
1280         }
1281       else
1282         {
1283           if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE) == 0)
1284             continue;
1285         }
1286
1287       /* Get the symbol index.  */
1288       if (bfd_header_big_endian (abfd))
1289         r_index = ((rel->r_index[0] << 16)
1290                    | (rel->r_index[1] << 8)
1291                    | rel->r_index[2]);
1292       else
1293         r_index = ((rel->r_index[2] << 16)
1294                    | (rel->r_index[1] << 8)
1295                    | rel->r_index[0]);
1296
1297       /* Get the hash table entry.  */
1298       h = sym_hashes[r_index];
1299       if (h == NULL)
1300         /* This should not normally happen, but it will in any case
1301            be caught in the relocation phase.  */
1302         continue;
1303
1304       /* At this point common symbols have already been allocated, so
1305          we don't have to worry about them.  We need to consider that
1306          we may have already seen this symbol and marked it undefined;
1307          if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1308          will be zero.  */
1309       if (h->root.root.type != bfd_link_hash_defined
1310           && h->root.root.type != bfd_link_hash_defweak
1311           && h->root.root.type != bfd_link_hash_undefined)
1312         continue;
1313
1314       if ((h->flags & SUNOS_DEF_DYNAMIC) == 0
1315           || (h->flags & SUNOS_DEF_REGULAR) != 0)
1316         continue;
1317
1318       if (dynobj == NULL)
1319         {
1320           asection *sgot;
1321
1322           if (! sunos_create_dynamic_sections (abfd, info, FALSE))
1323             return FALSE;
1324           dynobj = sunos_hash_table (info)->dynobj;
1325           splt = bfd_get_section_by_name (dynobj, ".plt");
1326           srel = bfd_get_section_by_name (dynobj, ".dynrel");
1327           BFD_ASSERT (splt != NULL && srel != NULL);
1328
1329           sgot = bfd_get_section_by_name (dynobj, ".got");
1330           BFD_ASSERT (sgot != NULL);
1331           if (sgot->size == 0)
1332             sgot->size = BYTES_IN_WORD;
1333           sunos_hash_table (info)->got_needed = TRUE;
1334         }
1335
1336       BFD_ASSERT ((h->flags & SUNOS_REF_REGULAR) != 0);
1337       BFD_ASSERT (h->plt_offset != 0
1338                   || ((h->root.root.type == bfd_link_hash_defined
1339                        || h->root.root.type == bfd_link_hash_defweak)
1340                       ? (h->root.root.u.def.section->owner->flags
1341                          & DYNAMIC) != 0
1342                       : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0));
1343
1344       /* This reloc is against a symbol defined only by a dynamic
1345          object.  */
1346       if (h->root.root.type == bfd_link_hash_undefined)
1347         /* Presumably this symbol was marked as being undefined by
1348            an earlier reloc.  */
1349         srel->size += RELOC_STD_SIZE;
1350       else if ((h->root.root.u.def.section->flags & SEC_CODE) == 0)
1351         {
1352           bfd *sub;
1353
1354           /* This reloc is not in the .text section.  It must be
1355              copied into the dynamic relocs.  We mark the symbol as
1356              being undefined.  */
1357           srel->size += RELOC_STD_SIZE;
1358           sub = h->root.root.u.def.section->owner;
1359           h->root.root.type = bfd_link_hash_undefined;
1360           h->root.root.u.undef.abfd = sub;
1361         }
1362       else
1363         {
1364           /* This symbol is in the .text section.  We must give it an
1365              entry in the procedure linkage table, if we have not
1366              already done so.  We change the definition of the symbol
1367              to the .plt section; this will cause relocs against it to
1368              be handled correctly.  */
1369           if (h->plt_offset == 0)
1370             {
1371               if (splt->size == 0)
1372                 splt->size = M68K_PLT_ENTRY_SIZE;
1373               h->plt_offset = splt->size;
1374
1375               if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1376                 {
1377                   h->root.root.u.def.section = splt;
1378                   h->root.root.u.def.value = splt->size;
1379                 }
1380
1381               splt->size += M68K_PLT_ENTRY_SIZE;
1382
1383               /* We may also need a dynamic reloc entry.  */
1384               if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1385                 srel->size += RELOC_STD_SIZE;
1386             }
1387         }
1388     }
1389
1390   return TRUE;
1391 }
1392
1393 /* Scan the relocs for an input section using extended relocs.  We
1394    need to figure out what to do for each reloc against a dynamic
1395    symbol.  If the reloc is a WDISP30, and the symbol is in the .text
1396    section, an entry is made in the procedure linkage table.
1397    Otherwise, we must preserve the reloc as a dynamic reloc.  */
1398
1399 static bfd_boolean
1400 sunos_scan_ext_relocs (struct bfd_link_info *info,
1401                        bfd *abfd,
1402                        asection *sec ATTRIBUTE_UNUSED,
1403                        const struct reloc_ext_external *relocs,
1404                        bfd_size_type rel_size)
1405 {
1406   bfd *dynobj;
1407   struct sunos_link_hash_entry **sym_hashes;
1408   const struct reloc_ext_external *rel, *relend;
1409   asection *splt = NULL;
1410   asection *sgot = NULL;
1411   asection *srel = NULL;
1412   bfd_size_type amt;
1413
1414   /* We only know how to handle SPARC plt entries.  */
1415   if (bfd_get_arch (abfd) != bfd_arch_sparc)
1416     {
1417       bfd_set_error (bfd_error_invalid_target);
1418       return FALSE;
1419     }
1420
1421   dynobj = NULL;
1422
1423   sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
1424
1425   relend = relocs + rel_size / RELOC_EXT_SIZE;
1426   for (rel = relocs; rel < relend; rel++)
1427     {
1428       unsigned int r_index;
1429       int r_extern;
1430       int r_type;
1431       struct sunos_link_hash_entry *h = NULL;
1432
1433       /* Swap in the reloc information.  */
1434       if (bfd_header_big_endian (abfd))
1435         {
1436           r_index = ((rel->r_index[0] << 16)
1437                      | (rel->r_index[1] << 8)
1438                      | rel->r_index[2]);
1439           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
1440           r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
1441                     >> RELOC_EXT_BITS_TYPE_SH_BIG);
1442         }
1443       else
1444         {
1445           r_index = ((rel->r_index[2] << 16)
1446                      | (rel->r_index[1] << 8)
1447                      | rel->r_index[0]);
1448           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
1449           r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
1450                     >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
1451         }
1452
1453       if (r_extern)
1454         {
1455           h = sym_hashes[r_index];
1456           if (h == NULL)
1457             {
1458               /* This should not normally happen, but it will in any
1459                  case be caught in the relocation phase.  */
1460               continue;
1461             }
1462         }
1463
1464       /* If this is a base relative reloc, we need to make an entry in
1465          the .got section.  */
1466       if (r_type == RELOC_BASE10
1467           || r_type == RELOC_BASE13
1468           || r_type == RELOC_BASE22)
1469         {
1470           if (dynobj == NULL)
1471             {
1472               if (! sunos_create_dynamic_sections (abfd, info, FALSE))
1473                 return FALSE;
1474               dynobj = sunos_hash_table (info)->dynobj;
1475               splt = bfd_get_section_by_name (dynobj, ".plt");
1476               sgot = bfd_get_section_by_name (dynobj, ".got");
1477               srel = bfd_get_section_by_name (dynobj, ".dynrel");
1478               BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1479
1480               /* Make sure we have an initial entry in the .got table.  */
1481               if (sgot->size == 0)
1482                 sgot->size = BYTES_IN_WORD;
1483               sunos_hash_table (info)->got_needed = TRUE;
1484             }
1485
1486           if (r_extern)
1487             {
1488               if (h->got_offset != 0)
1489                 continue;
1490
1491               h->got_offset = sgot->size;
1492             }
1493           else
1494             {
1495               if (r_index >= bfd_get_symcount (abfd))
1496                 /* This is abnormal, but should be caught in the
1497                    relocation phase.  */
1498                 continue;
1499
1500               if (adata (abfd).local_got_offsets == NULL)
1501                 {
1502                   amt = bfd_get_symcount (abfd);
1503                   amt *= sizeof (bfd_vma);
1504                   adata (abfd).local_got_offsets = bfd_zalloc (abfd, amt);
1505                   if (adata (abfd).local_got_offsets == NULL)
1506                     return FALSE;
1507                 }
1508
1509               if (adata (abfd).local_got_offsets[r_index] != 0)
1510                 continue;
1511
1512               adata (abfd).local_got_offsets[r_index] = sgot->size;
1513             }
1514
1515           sgot->size += BYTES_IN_WORD;
1516
1517           /* If we are making a shared library, or if the symbol is
1518              defined by a dynamic object, we will need a dynamic reloc
1519              entry.  */
1520           if (info->shared
1521               || (h != NULL
1522                   && (h->flags & SUNOS_DEF_DYNAMIC) != 0
1523                   && (h->flags & SUNOS_DEF_REGULAR) == 0))
1524             srel->size += RELOC_EXT_SIZE;
1525
1526           continue;
1527         }
1528
1529       /* Otherwise, we are only interested in relocs against symbols
1530          defined in dynamic objects but not in regular objects.  We
1531          only need to consider relocs against external symbols.  */
1532       if (! r_extern)
1533         {
1534           /* But, if we are creating a shared library, we need to
1535              generate an absolute reloc.  */
1536           if (info->shared)
1537             {
1538               if (dynobj == NULL)
1539                 {
1540                   if (! sunos_create_dynamic_sections (abfd, info, TRUE))
1541                     return FALSE;
1542                   dynobj = sunos_hash_table (info)->dynobj;
1543                   splt = bfd_get_section_by_name (dynobj, ".plt");
1544                   sgot = bfd_get_section_by_name (dynobj, ".got");
1545                   srel = bfd_get_section_by_name (dynobj, ".dynrel");
1546                   BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1547                 }
1548
1549               srel->size += RELOC_EXT_SIZE;
1550             }
1551
1552           continue;
1553         }
1554
1555       /* At this point common symbols have already been allocated, so
1556          we don't have to worry about them.  We need to consider that
1557          we may have already seen this symbol and marked it undefined;
1558          if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
1559          will be zero.  */
1560       if (h->root.root.type != bfd_link_hash_defined
1561           && h->root.root.type != bfd_link_hash_defweak
1562           && h->root.root.type != bfd_link_hash_undefined)
1563         continue;
1564
1565       if (r_type != RELOC_JMP_TBL
1566           && ! info->shared
1567           && ((h->flags & SUNOS_DEF_DYNAMIC) == 0
1568               || (h->flags & SUNOS_DEF_REGULAR) != 0))
1569         continue;
1570
1571       if (r_type == RELOC_JMP_TBL
1572           && ! info->shared
1573           && (h->flags & SUNOS_DEF_DYNAMIC) == 0
1574           && (h->flags & SUNOS_DEF_REGULAR) == 0)
1575         {
1576           /* This symbol is apparently undefined.  Don't do anything
1577              here; just let the relocation routine report an undefined
1578              symbol.  */
1579           continue;
1580         }
1581
1582       if (strcmp (h->root.root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
1583         continue;
1584
1585       if (dynobj == NULL)
1586         {
1587           if (! sunos_create_dynamic_sections (abfd, info, FALSE))
1588             return FALSE;
1589           dynobj = sunos_hash_table (info)->dynobj;
1590           splt = bfd_get_section_by_name (dynobj, ".plt");
1591           sgot = bfd_get_section_by_name (dynobj, ".got");
1592           srel = bfd_get_section_by_name (dynobj, ".dynrel");
1593           BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1594
1595           /* Make sure we have an initial entry in the .got table.  */
1596           if (sgot->size == 0)
1597             sgot->size = BYTES_IN_WORD;
1598           sunos_hash_table (info)->got_needed = TRUE;
1599         }
1600
1601       BFD_ASSERT (r_type == RELOC_JMP_TBL
1602                   || info->shared
1603                   || (h->flags & SUNOS_REF_REGULAR) != 0);
1604       BFD_ASSERT (r_type == RELOC_JMP_TBL
1605                   || info->shared
1606                   || h->plt_offset != 0
1607                   || ((h->root.root.type == bfd_link_hash_defined
1608                        || h->root.root.type == bfd_link_hash_defweak)
1609                       ? (h->root.root.u.def.section->owner->flags
1610                          & DYNAMIC) != 0
1611                       : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0));
1612
1613       /* This reloc is against a symbol defined only by a dynamic
1614          object, or it is a jump table reloc from PIC compiled code.  */
1615
1616       if (r_type != RELOC_JMP_TBL
1617           && h->root.root.type == bfd_link_hash_undefined)
1618         /* Presumably this symbol was marked as being undefined by
1619            an earlier reloc.  */
1620         srel->size += RELOC_EXT_SIZE;
1621
1622       else if (r_type != RELOC_JMP_TBL
1623                && (h->root.root.u.def.section->flags & SEC_CODE) == 0)
1624         {
1625           bfd *sub;
1626
1627           /* This reloc is not in the .text section.  It must be
1628              copied into the dynamic relocs.  We mark the symbol as
1629              being undefined.  */
1630           srel->size += RELOC_EXT_SIZE;
1631           if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1632             {
1633               sub = h->root.root.u.def.section->owner;
1634               h->root.root.type = bfd_link_hash_undefined;
1635               h->root.root.u.undef.abfd = sub;
1636             }
1637         }
1638       else
1639         {
1640           /* This symbol is in the .text section.  We must give it an
1641              entry in the procedure linkage table, if we have not
1642              already done so.  We change the definition of the symbol
1643              to the .plt section; this will cause relocs against it to
1644              be handled correctly.  */
1645           if (h->plt_offset == 0)
1646             {
1647               if (splt->size == 0)
1648                 splt->size = SPARC_PLT_ENTRY_SIZE;
1649               h->plt_offset = splt->size;
1650
1651               if ((h->flags & SUNOS_DEF_REGULAR) == 0)
1652                 {
1653                   if (h->root.root.type == bfd_link_hash_undefined)
1654                     h->root.root.type = bfd_link_hash_defined;
1655                   h->root.root.u.def.section = splt;
1656                   h->root.root.u.def.value = splt->size;
1657                 }
1658
1659               splt->size += SPARC_PLT_ENTRY_SIZE;
1660
1661               /* We will also need a dynamic reloc entry, unless this
1662                  is a JMP_TBL reloc produced by linking PIC compiled
1663                  code, and we are not making a shared library.  */
1664               if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
1665                 srel->size += RELOC_EXT_SIZE;
1666             }
1667
1668           /* If we are creating a shared library, we need to copy over
1669              any reloc other than a jump table reloc.  */
1670           if (info->shared && r_type != RELOC_JMP_TBL)
1671             srel->size += RELOC_EXT_SIZE;
1672         }
1673     }
1674
1675   return TRUE;
1676 }
1677
1678 /* Scan the relocs for an input section.  */
1679
1680 static bfd_boolean
1681 sunos_scan_relocs (struct bfd_link_info *info,
1682                    bfd *abfd,
1683                    asection *sec,
1684                    bfd_size_type rel_size)
1685 {
1686   void * relocs;
1687   void * free_relocs = NULL;
1688
1689   if (rel_size == 0)
1690     return TRUE;
1691
1692   if (! info->keep_memory)
1693     relocs = free_relocs = bfd_malloc (rel_size);
1694   else
1695     {
1696       struct aout_section_data_struct *n;
1697       bfd_size_type amt = sizeof (struct aout_section_data_struct);
1698
1699       n = bfd_alloc (abfd, amt);
1700       if (n == NULL)
1701         relocs = NULL;
1702       else
1703         {
1704           set_aout_section_data (sec, n);
1705           relocs = bfd_malloc (rel_size);
1706           aout_section_data (sec)->relocs = relocs;
1707         }
1708     }
1709   if (relocs == NULL)
1710     return FALSE;
1711
1712   if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
1713       || bfd_bread (relocs, rel_size, abfd) != rel_size)
1714     goto error_return;
1715
1716   if (obj_reloc_entry_size (abfd) == RELOC_STD_SIZE)
1717     {
1718       if (! sunos_scan_std_relocs (info, abfd, sec,
1719                                    (struct reloc_std_external *) relocs,
1720                                    rel_size))
1721         goto error_return;
1722     }
1723   else
1724     {
1725       if (! sunos_scan_ext_relocs (info, abfd, sec,
1726                                    (struct reloc_ext_external *) relocs,
1727                                    rel_size))
1728         goto error_return;
1729     }
1730
1731   if (free_relocs != NULL)
1732     free (free_relocs);
1733
1734   return TRUE;
1735
1736  error_return:
1737   if (free_relocs != NULL)
1738     free (free_relocs);
1739   return FALSE;
1740 }
1741
1742 /* Build the hash table of dynamic symbols, and to mark as written all
1743    symbols from dynamic objects which we do not plan to write out.  */
1744
1745 static bfd_boolean
1746 sunos_scan_dynamic_symbol (struct sunos_link_hash_entry *h, void * data)
1747 {
1748   struct bfd_link_info *info = (struct bfd_link_info *) data;
1749
1750   if (h->root.root.type == bfd_link_hash_warning)
1751     h = (struct sunos_link_hash_entry *) h->root.root.u.i.link;
1752
1753   /* Set the written flag for symbols we do not want to write out as
1754      part of the regular symbol table.  This is all symbols which are
1755      not defined in a regular object file.  For some reason symbols
1756      which are referenced by a regular object and defined by a dynamic
1757      object do not seem to show up in the regular symbol table.  It is
1758      possible for a symbol to have only SUNOS_REF_REGULAR set here, it
1759      is an undefined symbol which was turned into a common symbol
1760      because it was found in an archive object which was not included
1761      in the link.  */
1762   if ((h->flags & SUNOS_DEF_REGULAR) == 0
1763       && (h->flags & SUNOS_DEF_DYNAMIC) != 0
1764       && strcmp (h->root.root.root.string, "__DYNAMIC") != 0)
1765     h->root.written = TRUE;
1766
1767   /* If this symbol is defined by a dynamic object and referenced by a
1768      regular object, see whether we gave it a reasonable value while
1769      scanning the relocs.  */
1770   if ((h->flags & SUNOS_DEF_REGULAR) == 0
1771       && (h->flags & SUNOS_DEF_DYNAMIC) != 0
1772       && (h->flags & SUNOS_REF_REGULAR) != 0)
1773     {
1774       if ((h->root.root.type == bfd_link_hash_defined
1775            || h->root.root.type == bfd_link_hash_defweak)
1776           && ((h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
1777           && h->root.root.u.def.section->output_section == NULL)
1778         {
1779           bfd *sub;
1780
1781           /* This symbol is currently defined in a dynamic section
1782              which is not being put into the output file.  This
1783              implies that there is no reloc against the symbol.  I'm
1784              not sure why this case would ever occur.  In any case, we
1785              change the symbol to be undefined.  */
1786           sub = h->root.root.u.def.section->owner;
1787           h->root.root.type = bfd_link_hash_undefined;
1788           h->root.root.u.undef.abfd = sub;
1789         }
1790     }
1791
1792   /* If this symbol is defined or referenced by a regular file, add it
1793      to the dynamic symbols.  */
1794   if ((h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
1795     {
1796       asection *s;
1797       size_t len;
1798       bfd_byte *contents;
1799       unsigned char *name;
1800       unsigned long hash;
1801       bfd *dynobj;
1802
1803       BFD_ASSERT (h->dynindx == -2);
1804
1805       dynobj = sunos_hash_table (info)->dynobj;
1806
1807       h->dynindx = sunos_hash_table (info)->dynsymcount;
1808       ++sunos_hash_table (info)->dynsymcount;
1809
1810       len = strlen (h->root.root.root.string);
1811
1812       /* We don't bother to construct a BFD hash table for the strings
1813          which are the names of the dynamic symbols.  Using a hash
1814          table for the regular symbols is beneficial, because the
1815          regular symbols includes the debugging symbols, which have
1816          long names and are often duplicated in several object files.
1817          There are no debugging symbols in the dynamic symbols.  */
1818       s = bfd_get_section_by_name (dynobj, ".dynstr");
1819       BFD_ASSERT (s != NULL);
1820       contents = bfd_realloc (s->contents, s->size + len + 1);
1821       if (contents == NULL)
1822         return FALSE;
1823       s->contents = contents;
1824
1825       h->dynstr_index = s->size;
1826       strcpy ((char *) contents + s->size, h->root.root.root.string);
1827       s->size += len + 1;
1828
1829       /* Add it to the dynamic hash table.  */
1830       name = (unsigned char *) h->root.root.root.string;
1831       hash = 0;
1832       while (*name != '\0')
1833         hash = (hash << 1) + *name++;
1834       hash &= 0x7fffffff;
1835       hash %= sunos_hash_table (info)->bucketcount;
1836
1837       s = bfd_get_section_by_name (dynobj, ".hash");
1838       BFD_ASSERT (s != NULL);
1839
1840       if (GET_SWORD (dynobj, s->contents + hash * HASH_ENTRY_SIZE) == -1)
1841         PUT_WORD (dynobj, h->dynindx, s->contents + hash * HASH_ENTRY_SIZE);
1842       else
1843         {
1844           bfd_vma next;
1845
1846           next = GET_WORD (dynobj,
1847                            (s->contents
1848                             + hash * HASH_ENTRY_SIZE
1849                             + BYTES_IN_WORD));
1850           PUT_WORD (dynobj, s->size / HASH_ENTRY_SIZE,
1851                     s->contents + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD);
1852           PUT_WORD (dynobj, h->dynindx, s->contents + s->size);
1853           PUT_WORD (dynobj, next, s->contents + s->size + BYTES_IN_WORD);
1854           s->size += HASH_ENTRY_SIZE;
1855         }
1856     }
1857
1858   return TRUE;
1859 }
1860
1861 /* Set up the sizes and contents of the dynamic sections created in
1862    sunos_add_dynamic_symbols.  This is called by the SunOS linker
1863    emulation before_allocation routine.  We must set the sizes of the
1864    sections before the linker sets the addresses of the various
1865    sections.  This unfortunately requires reading all the relocs so
1866    that we can work out which ones need to become dynamic relocs.  If
1867    info->keep_memory is TRUE, we keep the relocs in memory; otherwise,
1868    we discard them, and will read them again later.  */
1869
1870 bfd_boolean
1871 bfd_sunos_size_dynamic_sections (bfd *output_bfd,
1872                                  struct bfd_link_info *info,
1873                                  asection **sdynptr,
1874                                  asection **sneedptr,
1875                                  asection **srulesptr)
1876 {
1877   bfd *dynobj;
1878   bfd_size_type dynsymcount;
1879   struct sunos_link_hash_entry *h;
1880   asection *s;
1881   size_t bucketcount;
1882   bfd_size_type hashalloc;
1883   size_t i;
1884   bfd *sub;
1885
1886   *sdynptr = NULL;
1887   *sneedptr = NULL;
1888   *srulesptr = NULL;
1889
1890   if (info->relocatable)
1891     return TRUE;
1892
1893   if (output_bfd->xvec != &MY(vec))
1894     return TRUE;
1895
1896   /* Look through all the input BFD's and read their relocs.  It would
1897      be better if we didn't have to do this, but there is no other way
1898      to determine the number of dynamic relocs we need, and, more
1899      importantly, there is no other way to know which symbols should
1900      get an entry in the procedure linkage table.  */
1901   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
1902     {
1903       if ((sub->flags & DYNAMIC) == 0
1904           && sub->xvec == output_bfd->xvec)
1905         {
1906           if (! sunos_scan_relocs (info, sub, obj_textsec (sub),
1907                                    exec_hdr (sub)->a_trsize)
1908               || ! sunos_scan_relocs (info, sub, obj_datasec (sub),
1909                                       exec_hdr (sub)->a_drsize))
1910             return FALSE;
1911         }
1912     }
1913
1914   dynobj = sunos_hash_table (info)->dynobj;
1915   dynsymcount = sunos_hash_table (info)->dynsymcount;
1916
1917   /* If there were no dynamic objects in the link, and we don't need
1918      to build a global offset table, there is nothing to do here.  */
1919   if (! sunos_hash_table (info)->dynamic_sections_needed
1920       && ! sunos_hash_table (info)->got_needed)
1921     return TRUE;
1922
1923   /* If __GLOBAL_OFFSET_TABLE_ was mentioned, define it.  */
1924   h = sunos_link_hash_lookup (sunos_hash_table (info),
1925                               "__GLOBAL_OFFSET_TABLE_", FALSE, FALSE, FALSE);
1926   if (h != NULL && (h->flags & SUNOS_REF_REGULAR) != 0)
1927     {
1928       h->flags |= SUNOS_DEF_REGULAR;
1929       if (h->dynindx == -1)
1930         {
1931           ++sunos_hash_table (info)->dynsymcount;
1932           h->dynindx = -2;
1933         }
1934       h->root.root.type = bfd_link_hash_defined;
1935       h->root.root.u.def.section = bfd_get_section_by_name (dynobj, ".got");
1936
1937       /* If the .got section is more than 0x1000 bytes, we set
1938          __GLOBAL_OFFSET_TABLE_ to be 0x1000 bytes into the section,
1939          so that 13 bit relocations have a greater chance of working.  */
1940       s = bfd_get_section_by_name (dynobj, ".got");
1941       BFD_ASSERT (s != NULL);
1942       if (s->size >= 0x1000)
1943         h->root.root.u.def.value = 0x1000;
1944       else
1945         h->root.root.u.def.value = 0;
1946
1947       sunos_hash_table (info)->got_base = h->root.root.u.def.value;
1948     }
1949
1950   /* If there are any shared objects in the link, then we need to set
1951      up the dynamic linking information.  */
1952   if (sunos_hash_table (info)->dynamic_sections_needed)
1953     {
1954       *sdynptr = bfd_get_section_by_name (dynobj, ".dynamic");
1955
1956       /* The .dynamic section is always the same size.  */
1957       s = *sdynptr;
1958       BFD_ASSERT (s != NULL);
1959       s->size = (sizeof (struct external_sun4_dynamic)
1960                       + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
1961                       + sizeof (struct external_sun4_dynamic_link));
1962
1963       /* Set the size of the .dynsym and .hash sections.  We counted
1964          the number of dynamic symbols as we read the input files.  We
1965          will build the dynamic symbol table (.dynsym) and the hash
1966          table (.hash) when we build the final symbol table, because
1967          until then we do not know the correct value to give the
1968          symbols.  We build the dynamic symbol string table (.dynstr)
1969          in a traversal of the symbol table using
1970          sunos_scan_dynamic_symbol.  */
1971       s = bfd_get_section_by_name (dynobj, ".dynsym");
1972       BFD_ASSERT (s != NULL);
1973       s->size = dynsymcount * sizeof (struct external_nlist);
1974       s->contents = bfd_alloc (output_bfd, s->size);
1975       if (s->contents == NULL && s->size != 0)
1976         return FALSE;
1977
1978       /* The number of buckets is just the number of symbols divided
1979          by four.  To compute the final size of the hash table, we
1980          must actually compute the hash table.  Normally we need
1981          exactly as many entries in the hash table as there are
1982          dynamic symbols, but if some of the buckets are not used we
1983          will need additional entries.  In the worst case, every
1984          symbol will hash to the same bucket, and we will need
1985          BUCKETCOUNT - 1 extra entries.  */
1986       if (dynsymcount >= 4)
1987         bucketcount = dynsymcount / 4;
1988       else if (dynsymcount > 0)
1989         bucketcount = dynsymcount;
1990       else
1991         bucketcount = 1;
1992       s = bfd_get_section_by_name (dynobj, ".hash");
1993       BFD_ASSERT (s != NULL);
1994       hashalloc = (dynsymcount + bucketcount - 1) * HASH_ENTRY_SIZE;
1995       s->contents = bfd_zalloc (dynobj, hashalloc);
1996       if (s->contents == NULL && dynsymcount > 0)
1997         return FALSE;
1998       for (i = 0; i < bucketcount; i++)
1999         PUT_WORD (output_bfd, (bfd_vma) -1, s->contents + i * HASH_ENTRY_SIZE);
2000       s->size = bucketcount * HASH_ENTRY_SIZE;
2001
2002       sunos_hash_table (info)->bucketcount = bucketcount;
2003
2004       /* Scan all the symbols, place them in the dynamic symbol table,
2005          and build the dynamic hash table.  We reuse dynsymcount as a
2006          counter for the number of symbols we have added so far.  */
2007       sunos_hash_table (info)->dynsymcount = 0;
2008       sunos_link_hash_traverse (sunos_hash_table (info),
2009                                 sunos_scan_dynamic_symbol,
2010                                 (void *) info);
2011       BFD_ASSERT (sunos_hash_table (info)->dynsymcount == dynsymcount);
2012
2013       /* The SunOS native linker seems to align the total size of the
2014          symbol strings to a multiple of 8.  I don't know if this is
2015          important, but it can't hurt much.  */
2016       s = bfd_get_section_by_name (dynobj, ".dynstr");
2017       BFD_ASSERT (s != NULL);
2018       if ((s->size & 7) != 0)
2019         {
2020           bfd_size_type add;
2021           bfd_byte *contents;
2022
2023           add = 8 - (s->size & 7);
2024           contents = bfd_realloc (s->contents, s->size + add);
2025           if (contents == NULL)
2026             return FALSE;
2027           memset (contents + s->size, 0, (size_t) add);
2028           s->contents = contents;
2029           s->size += add;
2030         }
2031     }
2032
2033   /* Now that we have worked out the sizes of the procedure linkage
2034      table and the dynamic relocs, allocate storage for them.  */
2035   s = bfd_get_section_by_name (dynobj, ".plt");
2036   BFD_ASSERT (s != NULL);
2037   if (s->size != 0)
2038     {
2039       s->contents = bfd_alloc (dynobj, s->size);
2040       if (s->contents == NULL)
2041         return FALSE;
2042
2043       /* Fill in the first entry in the table.  */
2044       switch (bfd_get_arch (dynobj))
2045         {
2046         case bfd_arch_sparc:
2047           memcpy (s->contents, sparc_plt_first_entry, SPARC_PLT_ENTRY_SIZE);
2048           break;
2049
2050         case bfd_arch_m68k:
2051           memcpy (s->contents, m68k_plt_first_entry, M68K_PLT_ENTRY_SIZE);
2052           break;
2053
2054         default:
2055           abort ();
2056         }
2057     }
2058
2059   s = bfd_get_section_by_name (dynobj, ".dynrel");
2060   if (s->size != 0)
2061     {
2062       s->contents = bfd_alloc (dynobj, s->size);
2063       if (s->contents == NULL)
2064         return FALSE;
2065     }
2066   /* We use the reloc_count field to keep track of how many of the
2067      relocs we have output so far.  */
2068   s->reloc_count = 0;
2069
2070   /* Make space for the global offset table.  */
2071   s = bfd_get_section_by_name (dynobj, ".got");
2072   s->contents = bfd_alloc (dynobj, s->size);
2073   if (s->contents == NULL)
2074     return FALSE;
2075
2076   *sneedptr = bfd_get_section_by_name (dynobj, ".need");
2077   *srulesptr = bfd_get_section_by_name (dynobj, ".rules");
2078
2079   return TRUE;
2080 }
2081
2082 /* Link a dynamic object.  We actually don't have anything to do at
2083    this point.  This entry point exists to prevent the regular linker
2084    code from doing anything with the object.  */
2085
2086 static bfd_boolean
2087 sunos_link_dynamic_object (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2088                            bfd *abfd ATTRIBUTE_UNUSED)
2089 {
2090   return TRUE;
2091 }
2092
2093 /* Write out a dynamic symbol.  This is called by the final traversal
2094    over the symbol table.  */
2095
2096 static bfd_boolean
2097 sunos_write_dynamic_symbol (bfd *output_bfd,
2098                             struct bfd_link_info *info,
2099                             struct aout_link_hash_entry *harg)
2100 {
2101   struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
2102   int type;
2103   bfd_vma val;
2104   asection *s;
2105   struct external_nlist *outsym;
2106
2107   /* If this symbol is in the procedure linkage table, fill in the
2108      table entry.  */
2109   if (h->plt_offset != 0)
2110     {
2111       bfd *dynobj;
2112       asection *splt;
2113       bfd_byte *p;
2114       bfd_vma r_address;
2115
2116       dynobj = sunos_hash_table (info)->dynobj;
2117       splt = bfd_get_section_by_name (dynobj, ".plt");
2118       p = splt->contents + h->plt_offset;
2119
2120       s = bfd_get_section_by_name (dynobj, ".dynrel");
2121
2122       r_address = (splt->output_section->vma
2123                    + splt->output_offset
2124                    + h->plt_offset);
2125
2126       switch (bfd_get_arch (output_bfd))
2127         {
2128         case bfd_arch_sparc:
2129           if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
2130             {
2131               bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD0, p);
2132               bfd_put_32 (output_bfd,
2133                           (SPARC_PLT_ENTRY_WORD1
2134                            + (((- (h->plt_offset + 4) >> 2)
2135                                & 0x3fffffff))),
2136                           p + 4);
2137               bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD2 + s->reloc_count,
2138                           p + 8);
2139             }
2140           else
2141             {
2142               val = (h->root.root.u.def.section->output_section->vma
2143                      + h->root.root.u.def.section->output_offset
2144                      + h->root.root.u.def.value);
2145               bfd_put_32 (output_bfd,
2146                           SPARC_PLT_PIC_WORD0 + ((val >> 10) & 0x3fffff),
2147                           p);
2148               bfd_put_32 (output_bfd,
2149                           SPARC_PLT_PIC_WORD1 + (val & 0x3ff),
2150                           p + 4);
2151               bfd_put_32 (output_bfd, SPARC_PLT_PIC_WORD2, p + 8);
2152             }
2153           break;
2154
2155         case bfd_arch_m68k:
2156           if (! info->shared && (h->flags & SUNOS_DEF_REGULAR) != 0)
2157             abort ();
2158           bfd_put_16 (output_bfd, M68K_PLT_ENTRY_WORD0, p);
2159           bfd_put_32 (output_bfd, (- (h->plt_offset + 2)), p + 2);
2160           bfd_put_16 (output_bfd, (bfd_vma) s->reloc_count, p + 6);
2161           r_address += 2;
2162           break;
2163
2164         default:
2165           abort ();
2166         }
2167
2168       /* We also need to add a jump table reloc, unless this is the
2169          result of a JMP_TBL reloc from PIC compiled code.  */
2170       if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
2171         {
2172           BFD_ASSERT (h->dynindx >= 0);
2173           BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
2174                       < s->size);
2175           p = s->contents + s->reloc_count * obj_reloc_entry_size (output_bfd);
2176           if (obj_reloc_entry_size (output_bfd) == RELOC_STD_SIZE)
2177             {
2178               struct reloc_std_external *srel;
2179
2180               srel = (struct reloc_std_external *) p;
2181               PUT_WORD (output_bfd, r_address, srel->r_address);
2182               if (bfd_header_big_endian (output_bfd))
2183                 {
2184                   srel->r_index[0] = (bfd_byte) (h->dynindx >> 16);
2185                   srel->r_index[1] = (bfd_byte) (h->dynindx >> 8);
2186                   srel->r_index[2] = (bfd_byte) (h->dynindx);
2187                   srel->r_type[0] = (RELOC_STD_BITS_EXTERN_BIG
2188                                      | RELOC_STD_BITS_JMPTABLE_BIG);
2189                 }
2190               else
2191                 {
2192                   srel->r_index[2] = (bfd_byte) (h->dynindx >> 16);
2193                   srel->r_index[1] = (bfd_byte) (h->dynindx >> 8);
2194                   srel->r_index[0] = (bfd_byte)h->dynindx;
2195                   srel->r_type[0] = (RELOC_STD_BITS_EXTERN_LITTLE
2196                                      | RELOC_STD_BITS_JMPTABLE_LITTLE);
2197                 }
2198             }
2199           else
2200             {
2201               struct reloc_ext_external *erel;
2202
2203               erel = (struct reloc_ext_external *) p;
2204               PUT_WORD (output_bfd, r_address, erel->r_address);
2205               if (bfd_header_big_endian (output_bfd))
2206                 {
2207                   erel->r_index[0] = (bfd_byte) (h->dynindx >> 16);
2208                   erel->r_index[1] = (bfd_byte) (h->dynindx >> 8);
2209                   erel->r_index[2] = (bfd_byte)h->dynindx;
2210                   erel->r_type[0] =
2211                     (RELOC_EXT_BITS_EXTERN_BIG
2212                      | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_BIG));
2213                 }
2214               else
2215                 {
2216                   erel->r_index[2] = (bfd_byte) (h->dynindx >> 16);
2217                   erel->r_index[1] = (bfd_byte) (h->dynindx >> 8);
2218                   erel->r_index[0] = (bfd_byte)h->dynindx;
2219                   erel->r_type[0] =
2220                     (RELOC_EXT_BITS_EXTERN_LITTLE
2221                      | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2222                 }
2223               PUT_WORD (output_bfd, (bfd_vma) 0, erel->r_addend);
2224             }
2225
2226           ++s->reloc_count;
2227         }
2228     }
2229
2230   /* If this is not a dynamic symbol, we don't have to do anything
2231      else.  We only check this after handling the PLT entry, because
2232      we can have a PLT entry for a nondynamic symbol when linking PIC
2233      compiled code from a regular object.  */
2234   if (h->dynindx < 0)
2235     return TRUE;
2236
2237   switch (h->root.root.type)
2238     {
2239     default:
2240     case bfd_link_hash_new:
2241       abort ();
2242       /* Avoid variable not initialized warnings.  */
2243       return TRUE;
2244     case bfd_link_hash_undefined:
2245       type = N_UNDF | N_EXT;
2246       val = 0;
2247       break;
2248     case bfd_link_hash_defined:
2249     case bfd_link_hash_defweak:
2250       {
2251         asection *sec;
2252         asection *output_section;
2253
2254         sec = h->root.root.u.def.section;
2255         output_section = sec->output_section;
2256         BFD_ASSERT (bfd_is_abs_section (output_section)
2257                     || output_section->owner == output_bfd);
2258         if (h->plt_offset != 0
2259             && (h->flags & SUNOS_DEF_REGULAR) == 0)
2260           {
2261             type = N_UNDF | N_EXT;
2262             val = 0;
2263           }
2264         else
2265           {
2266             if (output_section == obj_textsec (output_bfd))
2267               type = (h->root.root.type == bfd_link_hash_defined
2268                       ? N_TEXT
2269                       : N_WEAKT);
2270             else if (output_section == obj_datasec (output_bfd))
2271               type = (h->root.root.type == bfd_link_hash_defined
2272                       ? N_DATA
2273                       : N_WEAKD);
2274             else if (output_section == obj_bsssec (output_bfd))
2275               type = (h->root.root.type == bfd_link_hash_defined
2276                       ? N_BSS
2277                       : N_WEAKB);
2278             else
2279               type = (h->root.root.type == bfd_link_hash_defined
2280                       ? N_ABS
2281                       : N_WEAKA);
2282             type |= N_EXT;
2283             val = (h->root.root.u.def.value
2284                    + output_section->vma
2285                    + sec->output_offset);
2286           }
2287       }
2288       break;
2289     case bfd_link_hash_common:
2290       type = N_UNDF | N_EXT;
2291       val = h->root.root.u.c.size;
2292       break;
2293     case bfd_link_hash_undefweak:
2294       type = N_WEAKU;
2295       val = 0;
2296       break;
2297     case bfd_link_hash_indirect:
2298     case bfd_link_hash_warning:
2299       /* FIXME: Ignore these for now.  The circumstances under which
2300          they should be written out are not clear to me.  */
2301       return TRUE;
2302     }
2303
2304   s = bfd_get_section_by_name (sunos_hash_table (info)->dynobj, ".dynsym");
2305   BFD_ASSERT (s != NULL);
2306   outsym = ((struct external_nlist *)
2307             (s->contents + h->dynindx * EXTERNAL_NLIST_SIZE));
2308
2309   H_PUT_8 (output_bfd, type, outsym->e_type);
2310   H_PUT_8 (output_bfd, 0, outsym->e_other);
2311
2312   /* FIXME: The native linker doesn't use 0 for desc.  It seems to use
2313      one less than the desc value in the shared library, although that
2314      seems unlikely.  */
2315   H_PUT_16 (output_bfd, 0, outsym->e_desc);
2316
2317   PUT_WORD (output_bfd, h->dynstr_index, outsym->e_strx);
2318   PUT_WORD (output_bfd, val, outsym->e_value);
2319
2320   return TRUE;
2321 }
2322
2323 /* This is called for each reloc against an external symbol.  If this
2324    is a reloc which are are going to copy as a dynamic reloc, then
2325    copy it over, and tell the caller to not bother processing this
2326    reloc.  */
2327
2328 static bfd_boolean
2329 sunos_check_dynamic_reloc (struct bfd_link_info *info,
2330                            bfd *input_bfd,
2331                            asection *input_section,
2332                            struct aout_link_hash_entry *harg,
2333                            void * reloc,
2334                            bfd_byte *contents ATTRIBUTE_UNUSED,
2335                            bfd_boolean *skip,
2336                            bfd_vma *relocationp)
2337 {
2338   struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
2339   bfd *dynobj;
2340   bfd_boolean baserel;
2341   bfd_boolean jmptbl;
2342   bfd_boolean pcrel;
2343   asection *s;
2344   bfd_byte *p;
2345   long indx;
2346
2347   *skip = FALSE;
2348
2349   dynobj = sunos_hash_table (info)->dynobj;
2350
2351   if (h != NULL
2352       && h->plt_offset != 0
2353       && (info->shared
2354           || (h->flags & SUNOS_DEF_REGULAR) == 0))
2355     {
2356       asection *splt;
2357
2358       /* Redirect the relocation to the PLT entry.  */
2359       splt = bfd_get_section_by_name (dynobj, ".plt");
2360       *relocationp = (splt->output_section->vma
2361                       + splt->output_offset
2362                       + h->plt_offset);
2363     }
2364
2365   if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
2366     {
2367       struct reloc_std_external *srel;
2368
2369       srel = (struct reloc_std_external *) reloc;
2370       if (bfd_header_big_endian (input_bfd))
2371         {
2372           baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2373           jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2374           pcrel = (0 != (srel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2375         }
2376       else
2377         {
2378           baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2379           jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2380           pcrel = (0 != (srel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2381         }
2382     }
2383   else
2384     {
2385       struct reloc_ext_external *erel;
2386       int r_type;
2387
2388       erel = (struct reloc_ext_external *) reloc;
2389       if (bfd_header_big_endian (input_bfd))
2390         r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2391                   >> RELOC_EXT_BITS_TYPE_SH_BIG);
2392       else
2393         r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2394                   >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
2395       baserel = (r_type == RELOC_BASE10
2396                  || r_type == RELOC_BASE13
2397                  || r_type == RELOC_BASE22);
2398       jmptbl = r_type == RELOC_JMP_TBL;
2399       pcrel = (r_type == RELOC_DISP8
2400                || r_type == RELOC_DISP16
2401                || r_type == RELOC_DISP32
2402                || r_type == RELOC_WDISP30
2403                || r_type == RELOC_WDISP22);
2404       /* We don't consider the PC10 and PC22 types to be PC relative,
2405          because they are pcrel_offset.  */
2406     }
2407
2408   if (baserel)
2409     {
2410       bfd_vma *got_offsetp;
2411       asection *sgot;
2412
2413       if (h != NULL)
2414         got_offsetp = &h->got_offset;
2415       else if (adata (input_bfd).local_got_offsets == NULL)
2416         got_offsetp = NULL;
2417       else
2418         {
2419           struct reloc_std_external *srel;
2420           int r_index;
2421
2422           srel = (struct reloc_std_external *) reloc;
2423           if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
2424             {
2425               if (bfd_header_big_endian (input_bfd))
2426                 r_index = ((srel->r_index[0] << 16)
2427                            | (srel->r_index[1] << 8)
2428                            | srel->r_index[2]);
2429               else
2430                 r_index = ((srel->r_index[2] << 16)
2431                            | (srel->r_index[1] << 8)
2432                            | srel->r_index[0]);
2433             }
2434           else
2435             {
2436               struct reloc_ext_external *erel;
2437
2438               erel = (struct reloc_ext_external *) reloc;
2439               if (bfd_header_big_endian (input_bfd))
2440                 r_index = ((erel->r_index[0] << 16)
2441                            | (erel->r_index[1] << 8)
2442                            | erel->r_index[2]);
2443               else
2444                 r_index = ((erel->r_index[2] << 16)
2445                            | (erel->r_index[1] << 8)
2446                            | erel->r_index[0]);
2447             }
2448
2449           got_offsetp = adata (input_bfd).local_got_offsets + r_index;
2450         }
2451
2452       BFD_ASSERT (got_offsetp != NULL && *got_offsetp != 0);
2453
2454       sgot = bfd_get_section_by_name (dynobj, ".got");
2455
2456       /* We set the least significant bit to indicate whether we have
2457          already initialized the GOT entry.  */
2458       if ((*got_offsetp & 1) == 0)
2459         {
2460           if (h == NULL
2461               || (! info->shared
2462                   && ((h->flags & SUNOS_DEF_DYNAMIC) == 0
2463                       || (h->flags & SUNOS_DEF_REGULAR) != 0)))
2464             PUT_WORD (dynobj, *relocationp, sgot->contents + *got_offsetp);
2465           else
2466             PUT_WORD (dynobj, 0, sgot->contents + *got_offsetp);
2467
2468           if (info->shared
2469               || (h != NULL
2470                   && (h->flags & SUNOS_DEF_DYNAMIC) != 0
2471                   && (h->flags & SUNOS_DEF_REGULAR) == 0))
2472             {
2473               /* We need to create a GLOB_DAT or 32 reloc to tell the
2474                  dynamic linker to fill in this entry in the table.  */
2475
2476               s = bfd_get_section_by_name (dynobj, ".dynrel");
2477               BFD_ASSERT (s != NULL);
2478               BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
2479                           < s->size);
2480
2481               p = (s->contents
2482                    + s->reloc_count * obj_reloc_entry_size (dynobj));
2483
2484               if (h != NULL)
2485                 indx = h->dynindx;
2486               else
2487                 indx = 0;
2488
2489               if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE)
2490                 {
2491                   struct reloc_std_external *srel;
2492
2493                   srel = (struct reloc_std_external *) p;
2494                   PUT_WORD (dynobj,
2495                             (*got_offsetp
2496                              + sgot->output_section->vma
2497                              + sgot->output_offset),
2498                             srel->r_address);
2499                   if (bfd_header_big_endian (dynobj))
2500                     {
2501                       srel->r_index[0] = (bfd_byte) (indx >> 16);
2502                       srel->r_index[1] = (bfd_byte) (indx >> 8);
2503                       srel->r_index[2] = (bfd_byte)indx;
2504                       if (h == NULL)
2505                         srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_BIG;
2506                       else
2507                         srel->r_type[0] =
2508                           (RELOC_STD_BITS_EXTERN_BIG
2509                            | RELOC_STD_BITS_BASEREL_BIG
2510                            | RELOC_STD_BITS_RELATIVE_BIG
2511                            | (2 << RELOC_STD_BITS_LENGTH_SH_BIG));
2512                     }
2513                   else
2514                     {
2515                       srel->r_index[2] = (bfd_byte) (indx >> 16);
2516                       srel->r_index[1] = (bfd_byte) (indx >> 8);
2517                       srel->r_index[0] = (bfd_byte)indx;
2518                       if (h == NULL)
2519                         srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_LITTLE;
2520                       else
2521                         srel->r_type[0] =
2522                           (RELOC_STD_BITS_EXTERN_LITTLE
2523                            | RELOC_STD_BITS_BASEREL_LITTLE
2524                            | RELOC_STD_BITS_RELATIVE_LITTLE
2525                            | (2 << RELOC_STD_BITS_LENGTH_SH_LITTLE));
2526                     }
2527                 }
2528               else
2529                 {
2530                   struct reloc_ext_external *erel;
2531
2532                   erel = (struct reloc_ext_external *) p;
2533                   PUT_WORD (dynobj,
2534                             (*got_offsetp
2535                              + sgot->output_section->vma
2536                              + sgot->output_offset),
2537                             erel->r_address);
2538                   if (bfd_header_big_endian (dynobj))
2539                     {
2540                       erel->r_index[0] = (bfd_byte) (indx >> 16);
2541                       erel->r_index[1] = (bfd_byte) (indx >> 8);
2542                       erel->r_index[2] = (bfd_byte)indx;
2543                       if (h == NULL)
2544                         erel->r_type[0] =
2545                           RELOC_32 << RELOC_EXT_BITS_TYPE_SH_BIG;
2546                       else
2547                         erel->r_type[0] =
2548                           (RELOC_EXT_BITS_EXTERN_BIG
2549                            | (RELOC_GLOB_DAT << RELOC_EXT_BITS_TYPE_SH_BIG));
2550                     }
2551                   else
2552                     {
2553                       erel->r_index[2] = (bfd_byte) (indx >> 16);
2554                       erel->r_index[1] = (bfd_byte) (indx >> 8);
2555                       erel->r_index[0] = (bfd_byte)indx;
2556                       if (h == NULL)
2557                         erel->r_type[0] =
2558                           RELOC_32 << RELOC_EXT_BITS_TYPE_SH_LITTLE;
2559                       else
2560                         erel->r_type[0] =
2561                           (RELOC_EXT_BITS_EXTERN_LITTLE
2562                            | (RELOC_GLOB_DAT
2563                               << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2564                     }
2565                   PUT_WORD (dynobj, 0, erel->r_addend);
2566                 }
2567
2568               ++s->reloc_count;
2569             }
2570
2571           *got_offsetp |= 1;
2572         }
2573
2574       *relocationp = (sgot->vma
2575                       + (*got_offsetp &~ (bfd_vma) 1)
2576                       - sunos_hash_table (info)->got_base);
2577
2578       /* There is nothing else to do for a base relative reloc.  */
2579       return TRUE;
2580     }
2581
2582   if (! sunos_hash_table (info)->dynamic_sections_needed)
2583     return TRUE;
2584   if (! info->shared)
2585     {
2586       if (h == NULL
2587           || h->dynindx == -1
2588           || h->root.root.type != bfd_link_hash_undefined
2589           || (h->flags & SUNOS_DEF_REGULAR) != 0
2590           || (h->flags & SUNOS_DEF_DYNAMIC) == 0
2591           || (h->root.root.u.undef.abfd->flags & DYNAMIC) == 0)
2592         return TRUE;
2593     }
2594   else
2595     {
2596       if (h != NULL
2597           && (h->dynindx == -1
2598               || jmptbl
2599               || strcmp (h->root.root.root.string,
2600                          "__GLOBAL_OFFSET_TABLE_") == 0))
2601         return TRUE;
2602     }
2603
2604   /* It looks like this is a reloc we are supposed to copy.  */
2605
2606   s = bfd_get_section_by_name (dynobj, ".dynrel");
2607   BFD_ASSERT (s != NULL);
2608   BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) < s->size);
2609
2610   p = s->contents + s->reloc_count * obj_reloc_entry_size (dynobj);
2611
2612   /* Copy the reloc over.  */
2613   memcpy (p, reloc, obj_reloc_entry_size (dynobj));
2614
2615   if (h != NULL)
2616     indx = h->dynindx;
2617   else
2618     indx = 0;
2619
2620   /* Adjust the address and symbol index.  */
2621   if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE)
2622     {
2623       struct reloc_std_external *srel;
2624
2625       srel = (struct reloc_std_external *) p;
2626       PUT_WORD (dynobj,
2627                 (GET_WORD (dynobj, srel->r_address)
2628                  + input_section->output_section->vma
2629                  + input_section->output_offset),
2630                 srel->r_address);
2631       if (bfd_header_big_endian (dynobj))
2632         {
2633           srel->r_index[0] = (bfd_byte) (indx >> 16);
2634           srel->r_index[1] = (bfd_byte) (indx >> 8);
2635           srel->r_index[2] = (bfd_byte)indx;
2636         }
2637       else
2638         {
2639           srel->r_index[2] = (bfd_byte) (indx >> 16);
2640           srel->r_index[1] = (bfd_byte) (indx >> 8);
2641           srel->r_index[0] = (bfd_byte)indx;
2642         }
2643       /* FIXME: We may have to change the addend for a PC relative
2644          reloc.  */
2645     }
2646   else
2647     {
2648       struct reloc_ext_external *erel;
2649
2650       erel = (struct reloc_ext_external *) p;
2651       PUT_WORD (dynobj,
2652                 (GET_WORD (dynobj, erel->r_address)
2653                  + input_section->output_section->vma
2654                  + input_section->output_offset),
2655                 erel->r_address);
2656       if (bfd_header_big_endian (dynobj))
2657         {
2658           erel->r_index[0] = (bfd_byte) (indx >> 16);
2659           erel->r_index[1] = (bfd_byte) (indx >> 8);
2660           erel->r_index[2] = (bfd_byte)indx;
2661         }
2662       else
2663         {
2664           erel->r_index[2] = (bfd_byte) (indx >> 16);
2665           erel->r_index[1] = (bfd_byte) (indx >> 8);
2666           erel->r_index[0] = (bfd_byte)indx;
2667         }
2668       if (pcrel && h != NULL)
2669         {
2670           /* Adjust the addend for the change in address.  */
2671           PUT_WORD (dynobj,
2672                     (GET_WORD (dynobj, erel->r_addend)
2673                      - (input_section->output_section->vma
2674                         + input_section->output_offset
2675                         - input_section->vma)),
2676                     erel->r_addend);
2677         }
2678     }
2679
2680   ++s->reloc_count;
2681
2682   if (h != NULL)
2683     *skip = TRUE;
2684
2685   return TRUE;
2686 }
2687
2688 /* Finish up the dynamic linking information.  */
2689
2690 static bfd_boolean
2691 sunos_finish_dynamic_link (bfd *abfd, struct bfd_link_info *info)
2692 {
2693   bfd *dynobj;
2694   asection *o;
2695   asection *s;
2696   asection *sdyn;
2697
2698   if (! sunos_hash_table (info)->dynamic_sections_needed
2699       && ! sunos_hash_table (info)->got_needed)
2700     return TRUE;
2701
2702   dynobj = sunos_hash_table (info)->dynobj;
2703
2704   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2705   BFD_ASSERT (sdyn != NULL);
2706
2707   /* Finish up the .need section.  The linker emulation code filled it
2708      in, but with offsets from the start of the section instead of
2709      real addresses.  Now that we know the section location, we can
2710      fill in the final values.  */
2711   s = bfd_get_section_by_name (dynobj, ".need");
2712   if (s != NULL && s->size != 0)
2713     {
2714       file_ptr filepos;
2715       bfd_byte *p;
2716
2717       filepos = s->output_section->filepos + s->output_offset;
2718       p = s->contents;
2719       while (1)
2720         {
2721           bfd_vma val;
2722
2723           PUT_WORD (dynobj, GET_WORD (dynobj, p) + filepos, p);
2724           val = GET_WORD (dynobj, p + 12);
2725           if (val == 0)
2726             break;
2727           PUT_WORD (dynobj, val + filepos, p + 12);
2728           p += 16;
2729         }
2730     }
2731
2732   /* The first entry in the .got section is the address of the
2733      dynamic information, unless this is a shared library.  */
2734   s = bfd_get_section_by_name (dynobj, ".got");
2735   BFD_ASSERT (s != NULL);
2736   if (info->shared || sdyn->size == 0)
2737     PUT_WORD (dynobj, 0, s->contents);
2738   else
2739     PUT_WORD (dynobj, sdyn->output_section->vma + sdyn->output_offset,
2740               s->contents);
2741
2742   for (o = dynobj->sections; o != NULL; o = o->next)
2743     {
2744       if ((o->flags & SEC_HAS_CONTENTS) != 0
2745           && o->contents != NULL)
2746         {
2747           BFD_ASSERT (o->output_section != NULL
2748                       && o->output_section->owner == abfd);
2749           if (! bfd_set_section_contents (abfd, o->output_section,
2750                                           o->contents,
2751                                           (file_ptr) o->output_offset,
2752                                           o->size))
2753             return FALSE;
2754         }
2755     }
2756
2757   if (sdyn->size > 0)
2758     {
2759       struct external_sun4_dynamic esd;
2760       struct external_sun4_dynamic_link esdl;
2761       file_ptr pos;
2762
2763       /* Finish up the dynamic link information.  */
2764       PUT_WORD (dynobj, (bfd_vma) 3, esd.ld_version);
2765       PUT_WORD (dynobj,
2766                 sdyn->output_section->vma + sdyn->output_offset + sizeof esd,
2767                 esd.ldd);
2768       PUT_WORD (dynobj,
2769                 (sdyn->output_section->vma
2770                  + sdyn->output_offset
2771                  + sizeof esd
2772                  + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE),
2773                 esd.ld);
2774
2775       if (! bfd_set_section_contents (abfd, sdyn->output_section, &esd,
2776                                       (file_ptr) sdyn->output_offset,
2777                                       (bfd_size_type) sizeof esd))
2778         return FALSE;
2779
2780       PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_loaded);
2781
2782       s = bfd_get_section_by_name (dynobj, ".need");
2783       if (s == NULL || s->size == 0)
2784         PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_need);
2785       else
2786         PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2787                   esdl.ld_need);
2788
2789       s = bfd_get_section_by_name (dynobj, ".rules");
2790       if (s == NULL || s->size == 0)
2791         PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_rules);
2792       else
2793         PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2794                   esdl.ld_rules);
2795
2796       s = bfd_get_section_by_name (dynobj, ".got");
2797       BFD_ASSERT (s != NULL);
2798       PUT_WORD (dynobj, s->output_section->vma + s->output_offset,
2799                 esdl.ld_got);
2800
2801       s = bfd_get_section_by_name (dynobj, ".plt");
2802       BFD_ASSERT (s != NULL);
2803       PUT_WORD (dynobj, s->output_section->vma + s->output_offset,
2804                 esdl.ld_plt);
2805       PUT_WORD (dynobj, s->size, esdl.ld_plt_sz);
2806
2807       s = bfd_get_section_by_name (dynobj, ".dynrel");
2808       BFD_ASSERT (s != NULL);
2809       BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
2810                   == s->size);
2811       PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2812                 esdl.ld_rel);
2813
2814       s = bfd_get_section_by_name (dynobj, ".hash");
2815       BFD_ASSERT (s != NULL);
2816       PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2817                 esdl.ld_hash);
2818
2819       s = bfd_get_section_by_name (dynobj, ".dynsym");
2820       BFD_ASSERT (s != NULL);
2821       PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2822                 esdl.ld_stab);
2823
2824       PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_stab_hash);
2825
2826       PUT_WORD (dynobj, (bfd_vma) sunos_hash_table (info)->bucketcount,
2827                 esdl.ld_buckets);
2828
2829       s = bfd_get_section_by_name (dynobj, ".dynstr");
2830       BFD_ASSERT (s != NULL);
2831       PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
2832                 esdl.ld_symbols);
2833       PUT_WORD (dynobj, s->size, esdl.ld_symb_size);
2834
2835       /* The size of the text area is the size of the .text section
2836          rounded up to a page boundary.  FIXME: Should the page size be
2837          conditional on something?  */
2838       PUT_WORD (dynobj,
2839                 BFD_ALIGN (obj_textsec (abfd)->size, 0x2000),
2840                 esdl.ld_text);
2841
2842       pos = sdyn->output_offset;
2843       pos += sizeof esd + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE;
2844       if (! bfd_set_section_contents (abfd, sdyn->output_section, &esdl,
2845                                       pos, (bfd_size_type) sizeof esdl))
2846         return FALSE;
2847
2848       abfd->flags |= DYNAMIC;
2849     }
2850
2851   return TRUE;
2852 }