{ bfd_set_error (bfd_error_no_memory); return -1; }
return -1;
static struct bfd_link_hash_table *sunos_link_hash_table_create  PARAMS ((bfd *));static boolean sunos_create_dynamic_sections  PARAMS ((bfd *, struct bfd_link_info *, boolean));static boolean sunos_add_dynamic_symbols  PARAMS ((bfd *, struct bfd_link_info *, struct external_nlist **,	   bfd_size_type *, char **));static boolean sunos_add_one_symbol  PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,	   bfd_vma, const char *, boolean, boolean,	   struct bfd_link_hash_entry **));static boolean sunos_scan_relocs  PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_size_type));static boolean sunos_scan_std_relocs  PARAMS ((struct bfd_link_info *, bfd *, asection *,	   const struct reloc_std_external *, bfd_size_type));static boolean sunos_scan_ext_relocs  PARAMS ((struct bfd_link_info *, bfd *, asection *,	   const struct reloc_ext_external *, bfd_size_type));static boolean sunos_link_dynamic_object  PARAMS ((struct bfd_link_info *, bfd *));static boolean sunos_write_dynamic_symbol  PARAMS ((bfd *, struct bfd_link_info *, struct aout_link_hash_entry *));static boolean sunos_check_dynamic_reloc  PARAMS ((struct bfd_link_info *, bfd *, asection *,	   struct aout_link_hash_entry *, PTR, bfd_byte *, boolean *,	   bfd_vma *));static boolean sunos_finish_dynamic_link  PARAMS ((bfd *, struct bfd_link_info *));#define MY_get_dynamic_symtab_upper_bound sunos_get_dynamic_symtab_upper_bound#define MY_canonicalize_dynamic_symtab sunos_canonicalize_dynamic_symtab#define MY_get_dynamic_reloc_upper_bound sunos_get_dynamic_reloc_upper_bound#define MY_canonicalize_dynamic_reloc sunos_canonicalize_dynamic_reloc#define MY_bfd_link_hash_table_create sunos_link_hash_table_create#define MY_add_dynamic_symbols sunos_add_dynamic_symbols#define MY_add_one_symbol sunos_add_one_symbol#define MY_link_dynamic_object sunos_link_dynamic_object#define MY_write_dynamic_symbol sunos_write_dynamic_symbol#define MY_check_dynamic_reloc sunos_check_dynamic_reloc#define MY_finish_dynamic_link sunos_finish_dynamic_link/* Include the usual a.out support.  */#include "aoutf1.h"/* SunOS shared library support.  We store a pointer to this structure   in obj_aout_dynamic_info (abfd).  */struct sunos_dynamic_info{  /* Whether we found any dynamic information.  */  boolean valid;  /* Dynamic information.  */  struct internal_sun4_dynamic_link dyninfo;  /* Number of dynamic symbols.  */  unsigned long dynsym_count;  /* Read in nlists for dynamic symbols.  */  struct external_nlist *dynsym;  /* asymbol structures for dynamic symbols.  */  aout_symbol_type *canonical_dynsym;  /* Read in dynamic string table.  */  char *dynstr;  /* Number of dynamic relocs.  */  unsigned long dynrel_count;  /* Read in dynamic relocs.  This may be reloc_std_external or     reloc_ext_external.  */  PTR dynrel;  /* arelent structures for dynamic relocs.  */  arelent *canonical_dynrel;};/* The hash table of dynamic symbols is composed of two word entries.   See include/aout/sun4.h for details.  */#define HASH_ENTRY_SIZE (2 * BYTES_IN_WORD)/* Read in the basic dynamic information.  This locates the __DYNAMIC   structure and uses it to find the dynamic_link structure.  It   creates and saves a sunos_dynamic_info structure.  If it can't find   __DYNAMIC, it sets the valid field of the sunos_dynamic_info   structure to false to avoid doing this work again.  */static booleansunos_read_dynamic_info (abfd)     bfd *abfd;{  struct sunos_dynamic_info *info;  asection *dynsec;  bfd_vma dynoff;  struct external_sun4_dynamic dyninfo;  unsigned long dynver;  struct external_sun4_dynamic_link linkinfo;  if (obj_aout_dynamic_info (abfd) != (PTR) NULL)    return true;  if ((abfd->flags & DYNAMIC) == 0)    {      bfd_set_error (bfd_error_invalid_operation);      return false;    }  info = ((struct sunos_dynamic_info *)	  bfd_zalloc (abfd, sizeof (struct sunos_dynamic_info)));  if (!info)    {      bfd_set_error (bfd_error_no_memory);      return false;    }  info->valid = false;  info->dynsym = NULL;  info->dynstr = NULL;  info->canonical_dynsym = NULL;  info->dynrel = NULL;  info->canonical_dynrel = NULL;  obj_aout_dynamic_info (abfd) = (PTR) info;  /* This code used to look for the __DYNAMIC symbol to locate the dynamic     linking information.     However this inhibits recovering the dynamic symbols from a     stripped object file, so blindly assume that the dynamic linking     information is located at the start of the data section.     We could verify this assumption later by looking through the dynamic     symbols for the __DYNAMIC symbol.  */  if ((abfd->flags & DYNAMIC) == 0)    return true;  if (! bfd_get_section_contents (abfd, obj_datasec (abfd), (PTR) &dyninfo,				  (file_ptr) 0, sizeof dyninfo))    return true;  dynver = GET_WORD (abfd, dyninfo.ld_version);  if (dynver != 2 && dynver != 3)    return true;  dynoff = GET_WORD (abfd, dyninfo.ld);  /* dynoff is a virtual address.  It is probably always in the .data     section, but this code should work even if it moves.  */  if (dynoff < bfd_get_section_vma (abfd, obj_datasec (abfd)))    dynsec = obj_textsec (abfd);  else    dynsec = obj_datasec (abfd);  dynoff -= bfd_get_section_vma (abfd, dynsec);  if (dynoff > bfd_section_size (abfd, dynsec))    return true;  /* This executable appears to be dynamically linked in a way that we     can understand.  */  if (! bfd_get_section_contents (abfd, dynsec, (PTR) &linkinfo, dynoff,				  (bfd_size_type) sizeof linkinfo))    return true;  /* Swap in the dynamic link information.  */  info->dyninfo.ld_loaded = GET_WORD (abfd, linkinfo.ld_loaded);  info->dyninfo.ld_need = GET_WORD (abfd, linkinfo.ld_need);  info->dyninfo.ld_rules = GET_WORD (abfd, linkinfo.ld_rules);  info->dyninfo.ld_got = GET_WORD (abfd, linkinfo.ld_got);  info->dyninfo.ld_plt = GET_WORD (abfd, linkinfo.ld_plt);  info->dyninfo.ld_rel = GET_WORD (abfd, linkinfo.ld_rel);  info->dyninfo.ld_hash = GET_WORD (abfd, linkinfo.ld_hash);  info->dyninfo.ld_stab = GET_WORD (abfd, linkinfo.ld_stab);  info->dyninfo.ld_stab_hash = GET_WORD (abfd, linkinfo.ld_stab_hash);  info->dyninfo.ld_buckets = GET_WORD (abfd, linkinfo.ld_buckets);  info->dyninfo.ld_symbols = GET_WORD (abfd, linkinfo.ld_symbols);  info->dyninfo.ld_symb_size = GET_WORD (abfd, linkinfo.ld_symb_size);  info->dyninfo.ld_text = GET_WORD (abfd, linkinfo.ld_text);  info->dyninfo.ld_plt_sz = GET_WORD (abfd, linkinfo.ld_plt_sz);  /* Reportedly the addresses need to be offset by the size of the     exec header in an NMAGIC file.  */  if (adata (abfd).magic == n_magic)    {      unsigned long exec_bytes_size = adata (abfd).exec_bytes_size;      info->dyninfo.ld_need += exec_bytes_size;      info->dyninfo.ld_rules += exec_bytes_size;      info->dyninfo.ld_rel += exec_bytes_size;      info->dyninfo.ld_hash += exec_bytes_size;      info->dyninfo.ld_stab += exec_bytes_size;      info->dyninfo.ld_symbols += exec_bytes_size;    }  /* The only way to get the size of the symbol information appears to     be to determine the distance between it and the string table.  */  info->dynsym_count = ((info->dyninfo.ld_symbols - info->dyninfo.ld_stab)			/ EXTERNAL_NLIST_SIZE);  BFD_ASSERT (info->dynsym_count * EXTERNAL_NLIST_SIZE	      == (unsigned long) (info->dyninfo.ld_symbols				  - info->dyninfo.ld_stab));  /* Similarly, the relocs end at the hash table.  */  info->dynrel_count = ((info->dyninfo.ld_hash - info->dyninfo.ld_rel)			/ obj_reloc_entry_size (abfd));  BFD_ASSERT (info->dynrel_count * obj_reloc_entry_size (abfd)	      == (unsigned long) (info->dyninfo.ld_hash				  - info->dyninfo.ld_rel));  info->valid = true;  return true;}/* Return the amount of memory required for the dynamic symbols.  */static longsunos_get_dynamic_symtab_upper_bound (abfd)     bfd *abfd;{  struct sunos_dynamic_info *info;  if (! sunos_read_dynamic_info (abfd))    return -1;  info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);  if (! info->valid)    {      bfd_set_error (bfd_error_no_symbols);      return -1;    }  return (info->dynsym_count + 1) * sizeof (asymbol *);}/* Read the external dynamic symbols.  */static booleansunos_slurp_dynamic_symtab (abfd)     bfd *abfd;{  struct sunos_dynamic_info *info;  /* Get the general dynamic information.  */  if (obj_aout_dynamic_info (abfd) == NULL)    {      if (! sunos_read_dynamic_info (abfd))	  return false;    }  info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);  if (! info->valid)    {      bfd_set_error (bfd_error_no_symbols);      return false;    }  /* Get the dynamic nlist structures.  */  if (info->dynsym == (struct external_nlist *) NULL)    {      info->dynsym = ((struct external_nlist *)		      bfd_alloc (abfd,				 (info->dynsym_count				  * EXTERNAL_NLIST_SIZE)));      if (info->dynsym == NULL && info->dynsym_count != 0)	{	  bfd_set_error (bfd_error_no_memory);	  return false;	}      if (bfd_seek (abfd, info->dyninfo.ld_stab, SEEK_SET) != 0	  || (bfd_read ((PTR) info->dynsym, info->dynsym_count,			EXTERNAL_NLIST_SIZE, abfd)	      != info->dynsym_count * EXTERNAL_NLIST_SIZE))	{	  if (info->dynsym != NULL)	    {	      bfd_release (abfd, info->dynsym);	      info->dynsym = NULL;	    }	  return false;	}    }  /* Get the dynamic strings.  */  if (info->dynstr == (char *) NULL)    {      info->dynstr = (char *) bfd_alloc (abfd, info->dyninfo.ld_symb_size);      if (info->dynstr == NULL && info->dyninfo.ld_symb_size != 0)	{	  bfd_set_error (bfd_error_no_memory);	  return false;	}      if (bfd_seek (abfd, info->dyninfo.ld_symbols, SEEK_SET) != 0	  || (bfd_read ((PTR) info->dynstr, 1, info->dyninfo.ld_symb_size,			abfd)	      != info->dyninfo.ld_symb_size))	{	  if (info->dynstr != NULL)	    {	      bfd_release (abfd, info->dynstr);	      info->dynstr = NULL;	    }	  return false;	}    }  return true;}/* Read in the dynamic symbols.  */static longsunos_canonicalize_dynamic_symtab (abfd, storage)     bfd *abfd;     asymbol **storage;{  struct sunos_dynamic_info *info;  unsigned long i;  if (! sunos_slurp_dynamic_symtab (abfd))    return -1;  info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);#ifdef CHECK_DYNAMIC_HASH  /* Check my understanding of the dynamic hash table by making sure     that each symbol can be located in the hash table.  */  {    bfd_size_type table_size;    bfd_byte *table;    bfd_size_type i;    if (info->dyninfo.ld_buckets > info->dynsym_count)      abort ();    table_size = info->dyninfo.ld_stab - info->dyninfo.ld_hash;    table = (bfd_byte *) malloc (table_size);    if (table == NULL && table_size != 0)      abort ();    if (bfd_seek (abfd, info->dyninfo.ld_hash, SEEK_SET) != 0	|| bfd_read ((PTR) table, 1, table_size, abfd) != table_size)      abort ();    for (i = 0; i < info->dynsym_count; i++)      {	unsigned char *name;	unsigned long hash;	name = ((unsigned char *) info->dynstr		+ GET_WORD (abfd, info->dynsym[i].e_strx));	hash = 0;	while (*name != '\0')	  hash = (hash << 1) + *name++;	hash &= 0x7fffffff;	hash %= info->dyninfo.ld_buckets;	while (GET_WORD (abfd, table + hash * HASH_ENTRY_SIZE) != i)	  {	    hash = GET_WORD (abfd,			     table + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD);	    if (hash == 0 || hash >= table_size / HASH_ENTRY_SIZE)	      abort ();	  }      }    free (table);  }#endif /* CHECK_DYNAMIC_HASH */  /* Get the asymbol structures corresponding to the dynamic nlist     structures.  */  if (info->canonical_dynsym == (aout_symbol_type *) NULL)    {      info->canonical_dynsym = ((aout_symbol_type *)				bfd_alloc (abfd,					   (info->dynsym_count					    * sizeof (aout_symbol_type))));      if (info->canonical_dynsym == NULL && info->dynsym_count != 0)	{	  bfd_set_error (bfd_error_no_memory);	  return -1;	}      if (! aout_32_translate_symbol_table (abfd, info->canonical_dynsym,					    info->dynsym, info->dynsym_count,					    info->dynstr,					    info->dyninfo.ld_symb_size,					    true))	{	  if (info->canonical_dynsym != NULL)	    {	      bfd_release (abfd, info->canonical_dynsym);	      info->canonical_dynsym = NULL;	    }	  return -1;	}    }  /* Return pointers to the dynamic asymbol structures.  */  for (i = 0; i < info->dynsym_count; i++)    *storage++ = (asymbol *) (info->canonical_dynsym + i);  *storage = NULL;  return info->dynsym_count;}/* Return the amount of memory required for the dynamic relocs.  */static longsunos_get_dynamic_reloc_upper_bound (abfd)     bfd *abfd;{  struct sunos_dynamic_info *info;  if (! sunos_read_dynamic_info (abfd))    return -1;  info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);  if (! info->valid)    {      bfd_set_error (bfd_error_no_symbols);      return -1;    }  return (info->dynrel_count + 1) * sizeof (arelent *);}/* Read in the dynamic relocs.  */static longsunos_canonicalize_dynamic_reloc (abfd, storage, syms)     bfd *abfd;     arelent **storage;     asymbol **syms;{  struct sunos_dynamic_info *info;  unsigned long i;  /* Get the general dynamic information.  */  if (obj_aout_dynamic_info (abfd) == (PTR) NULL)    {      if (! sunos_read_dynamic_info (abfd))	return -1;    }  info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);  if (! info->valid)    {      bfd_set_error (bfd_error_no_symbols);      return -1;    }  /* Get the dynamic reloc information.  */  if (info->dynrel == NULL)    {      info->dynrel = (PTR) bfd_alloc (abfd,				      (info->dynrel_count				       * obj_reloc_entry_size (abfd)));      if (info->dynrel == NULL && info->dynrel_count != 0)	{	  bfd_set_error (bfd_error_no_memory);	  return -1;	}      if (bfd_seek (abfd, info->dyninfo.ld_rel, SEEK_SET) != 0	  || (bfd_read ((PTR) info->dynrel, info->dynrel_count,			obj_reloc_entry_size (abfd), abfd)	      != info->dynrel_count * obj_reloc_entry_size (abfd)))	{	  if (info->dynrel != NULL)	    {	      bfd_release (abfd, info->dynrel);	      info->dynrel = NULL;	    }	  return -1;	}    }  /* Get the arelent structures corresponding to the dynamic reloc     information.  */  if (info->canonical_dynrel == (arelent *) NULL)    {      arelent *to;      info->canonical_dynrel = ((arelent *)				bfd_alloc (abfd,					   (info->dynrel_count					    * sizeof (arelent))));      if (info->canonical_dynrel == NULL && info->dynrel_count != 0)	{	  bfd_set_error (bfd_error_no_memory);	  return -1;	}            to = info->canonical_dynrel;      if (obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE)	{	  register struct reloc_ext_external *p;	  struct reloc_ext_external *pend;	  p = (struct reloc_ext_external *) info->dynrel;	  pend = p + info->dynrel_count;	  for (; p < pend; p++, to++)	    NAME(aout,swap_ext_reloc_in) (abfd, p, to, syms,					  info->dynsym_count);	}      else	{	  register struct reloc_std_external *p;	  struct reloc_std_external *pend;	  p = (struct reloc_std_external *) info->dynrel;	  pend = p + info->dynrel_count;	  for (; p < pend; p++, to++)	    NAME(aout,swap_std_reloc_in) (abfd, p, to, syms,					  info->dynsym_count);	}    }  /* Return pointers to the dynamic arelent structures.  */  for (i = 0; i < info->dynrel_count; i++)    *storage++ = info->canonical_dynrel + i;  *storage = NULL;  return info->dynrel_count;}/* Code to handle linking of SunOS shared libraries.  *//* A SPARC procedure linkage table entry is 12 bytes.  The first entry   in the table is a jump which is filled in by the runtime linker.   The remaining entries are branches back to the first entry,   followed by an index into the relocation table encoded to look like   a sethi of %g0.  */#define SPARC_PLT_ENTRY_SIZE (12)static const bfd_byte sparc_plt_first_entry[SPARC_PLT_ENTRY_SIZE] ={  /* sethi %hi(0),%g1; address filled in by runtime linker.  */  0x3, 0, 0, 0,  /* jmp %g1; offset filled in by runtime linker.  */  0x81, 0xc0, 0x60, 0,  /* nop */  0x1, 0, 0, 0};/* save %sp, -96, %sp */#define SPARC_PLT_ENTRY_WORD0 0x9de3bfa0/* call; address filled in later.  */#define SPARC_PLT_ENTRY_WORD1 0x40000000/* sethi; reloc index filled in later.  */#define SPARC_PLT_ENTRY_WORD2 0x01000000/* This sequence is used when for the jump table entry to a defined   symbol in a complete executable.  It is used when linking PIC   compiled code which is not being put into a shared library.  *//* sethi <address to be filled in later>, %g1 */#define SPARC_PLT_PIC_WORD0 0x03000000/* jmp %g1 + <address to be filled in later> */#define SPARC_PLT_PIC_WORD1 0x81c06000/* nop */#define SPARC_PLT_PIC_WORD2 0x01000000/* An m68k procedure linkage table entry is 8 bytes.  The first entry   in the table is a jump which is filled in the by the runtime   linker.  The remaining entries are branches back to the first   entry, followed by a two byte index into the relocation table.  */#define M68K_PLT_ENTRY_SIZE (8)static const bfd_byte m68k_plt_first_entry[M68K_PLT_ENTRY_SIZE] ={  /* jmps @# */  0x4e, 0xf9,  /* Filled in by runtime linker with a magic address.  */  0, 0, 0, 0,  /* Not used?  */  0, 0};/* bsrl */#define M68K_PLT_ENTRY_WORD0 (0x61ff)/* Remaining words filled in later.  *//* An entry in the SunOS linker hash table.  */struct sunos_link_hash_entry{  struct aout_link_hash_entry root;  /* If this is a dynamic symbol, this is its index into the dynamic     symbol table.  This is initialized to -1.  As the linker looks at     the input files, it changes this to -2 if it will be added to the     dynamic symbol table.  After all the input files have been seen,     the linker will know whether to build a dynamic symbol table; if     it does build one, this becomes the index into the table.  */  long dynindx;  /* If this is a dynamic symbol, this is the index of the name in the     dynamic symbol string table.  */  long dynstr_index;  /* The offset into the global offset table used for this symbol.  If     the symbol does not require a GOT entry, this is 0.  */  bfd_vma got_offset;  /* The offset into the procedure linkage table used for this symbol.     If the symbol does not require a PLT entry, this is 0.  */  bfd_vma plt_offset;  /* Some linker flags.  */  unsigned char flags;  /* Symbol is referenced by a regular object.  */#define SUNOS_REF_REGULAR 01  /* Symbol is defined by a regular object.  */#define SUNOS_DEF_REGULAR 02  /* Symbol is referenced by a dynamic object.  */#define SUNOS_REF_DYNAMIC 010  /* Symbol is defined by a dynamic object.  */#define SUNOS_DEF_DYNAMIC 020};/* The SunOS linker hash table.  */struct sunos_link_hash_table{  struct aout_link_hash_table root;  /* The object which holds the dynamic sections.  */  bfd *dynobj;  /* Whether we have created the dynamic sections.  */  boolean dynamic_sections_created;  /* Whether we need the dynamic sections.  */  boolean dynamic_sections_needed;  /* The number of dynamic symbols.  */  size_t dynsymcount;  /* The number of buckets in the hash table.  */  size_t bucketcount;  /* The list of dynamic objects needed by dynamic objects included in     the link.  */  struct bfd_link_needed_list *needed;};/* Routine to create an entry in an SunOS link hash table.  */static struct bfd_hash_entry *sunos_link_hash_newfunc (entry, table, string)     struct bfd_hash_entry *entry;     struct bfd_hash_table *table;     const char *string;{  struct sunos_link_hash_entry *ret = (struct sunos_link_hash_entry *) entry;  /* Allocate the structure if it has not already been allocated by a     subclass.  */  if (ret == (struct sunos_link_hash_entry *) NULL)    ret = ((struct sunos_link_hash_entry *)	   bfd_hash_allocate (table, sizeof (struct sunos_link_hash_entry)));  if (ret == (struct sunos_link_hash_entry *) NULL)    {      bfd_set_error (bfd_error_no_memory);      return (struct bfd_hash_entry *) ret;    }  /* Call the allocation method of the superclass.  */  ret = ((struct sunos_link_hash_entry *)	 NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,				       table, string));  if (ret != NULL)    {      /* Set local fields.  */      ret->dynindx = -1;      ret->dynstr_index = -1;      ret->got_offset = 0;      ret->plt_offset = 0;      ret->flags = 0;    }  return (struct bfd_hash_entry *) ret;}/* Create a SunOS link hash table.  */static struct bfd_link_hash_table *sunos_link_hash_table_create (abfd)     bfd *abfd;{  struct sunos_link_hash_table *ret;  ret = ((struct sunos_link_hash_table *)	 bfd_alloc (abfd, sizeof (struct sunos_link_hash_table)));  if (ret == (struct sunos_link_hash_table *) NULL)    {      bfd_set_error (bfd_error_no_memory);      return (struct bfd_link_hash_table *) NULL;    }  if (! NAME(aout,link_hash_table_init) (&ret->root, abfd,					 sunos_link_hash_newfunc))    {      bfd_release (abfd, ret);      return (struct bfd_link_hash_table *) NULL;    }  ret->dynobj = NULL;  ret->dynamic_sections_created = false;  ret->dynamic_sections_needed = false;  ret->dynsymcount = 0;  ret->bucketcount = 0;  ret->needed = NULL;  return &ret->root.root;}