/* BFD backend for SunOS binaries.
- Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
+ Copyright (C) 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
-#define ARCH 32
#define TARGETNAME "a.out-sunos-big"
#define MY(OP) CAT(sunos_big_,OP)
static boolean sunos_read_dynamic_info PARAMS ((bfd *));
static long sunos_get_dynamic_symtab_upper_bound PARAMS ((bfd *));
+static boolean sunos_slurp_dynamic_symtab PARAMS ((bfd *));
static long sunos_canonicalize_dynamic_symtab PARAMS ((bfd *, asymbol **));
static long sunos_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
static long sunos_canonicalize_dynamic_reloc
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
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 *));
+ 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,
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, boolean *));
+ struct aout_link_hash_entry *, PTR, bfd_byte *, boolean *,
+ bfd_vma *));
static boolean sunos_finish_dynamic_link
PARAMS ((bfd *, struct bfd_link_info *));
/* Dynamic information. */
struct internal_sun4_dynamic_link dyninfo;
/* Number of dynamic symbols. */
- long dynsym_count;
+ unsigned long dynsym_count;
/* Read in nlists for dynamic symbols. */
struct external_nlist *dynsym;
/* asymbol structures for dynamic symbols. */
/* Read in dynamic string table. */
char *dynstr;
/* Number of dynamic relocs. */
- long dynrel_count;
+ unsigned long dynrel_count;
/* Read in dynamic relocs. This may be reloc_std_external or
reloc_ext_external. */
PTR dynrel;
{
struct sunos_dynamic_info *info;
asection *dynsec;
- file_ptr dynoff;
+ bfd_vma dynoff;
struct external_sun4_dynamic dyninfo;
unsigned long dynver;
struct external_sun4_dynamic_link linkinfo;
info = ((struct sunos_dynamic_info *)
bfd_zalloc (abfd, sizeof (struct sunos_dynamic_info)));
if (!info)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
info->valid = false;
info->dynsym = NULL;
info->dynstr = NULL;
else
dynsec = obj_datasec (abfd);
dynoff -= bfd_get_section_vma (abfd, dynsec);
- if (dynoff < 0 || dynoff > bfd_section_size (abfd, dynsec))
+ if (dynoff > bfd_section_size (abfd, dynsec))
return true;
/* This executable appears to be dynamically linked in a way that we
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
- == info->dyninfo.ld_symbols - info->dyninfo.ld_stab);
+ == (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)
- == info->dyninfo.ld_hash - info->dyninfo.ld_rel);
+ == (unsigned long) (info->dyninfo.ld_hash
+ - info->dyninfo.ld_rel));
info->valid = true;
return (info->dynsym_count + 1) * sizeof (asymbol *);
}
-/* Read in the dynamic symbols. */
+/* Read the external dynamic symbols. */
-static long
-sunos_canonicalize_dynamic_symtab (abfd, storage)
+static boolean
+sunos_slurp_dynamic_symtab (abfd)
bfd *abfd;
- asymbol **storage;
{
struct sunos_dynamic_info *info;
- long i;
/* Get the general dynamic information. */
if (obj_aout_dynamic_info (abfd) == NULL)
{
if (! sunos_read_dynamic_info (abfd))
- return -1;
+ return false;
}
info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
if (! info->valid)
{
bfd_set_error (bfd_error_no_symbols);
- return -1;
+ return false;
}
/* Get the dynamic nlist structures. */
(info->dynsym_count
* EXTERNAL_NLIST_SIZE)));
if (info->dynsym == NULL && info->dynsym_count != 0)
- {
- bfd_set_error (bfd_error_no_memory);
- return -1;
- }
+ 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)
bfd_release (abfd, info->dynsym);
info->dynsym = NULL;
}
- return -1;
+ return false;
}
}
{
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 -1;
- }
+ 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)
bfd_release (abfd, info->dynstr);
info->dynstr = NULL;
}
- return -1;
+ return false;
}
}
+ return true;
+}
+
+/* Read in the dynamic symbols. */
+
+static long
+sunos_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. */
(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;
- }
+ return -1;
if (! aout_32_translate_symbol_table (abfd, info->canonical_dynsym,
info->dynsym, info->dynsym_count,
asymbol **syms;
{
struct sunos_dynamic_info *info;
- long i;
+ unsigned long i;
/* Get the general dynamic information. */
if (obj_aout_dynamic_info (abfd) == (PTR) NULL)
(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;
- }
+ 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
* sizeof (arelent))));
if (info->canonical_dynrel == NULL && info->dynrel_count != 0)
- {
- bfd_set_error (bfd_error_no_memory);
- return -1;
- }
+ return -1;
to = info->canonical_dynrel;
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);
+ NAME(aout,swap_ext_reloc_in) (abfd, p, to, syms,
+ info->dynsym_count);
}
else
{
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);
+ NAME(aout,swap_std_reloc_in) (abfd, p, to, syms,
+ info->dynsym_count);
}
}
#define SPARC_PLT_ENTRY_SIZE (12)
-static bfd_byte sparc_plt_first_entry[SPARC_PLT_ENTRY_SIZE] =
+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,
/* 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
#define M68K_PLT_ENTRY_SIZE (8)
-static bfd_byte m68k_plt_first_entry[M68K_PLT_ENTRY_SIZE] =
+static const bfd_byte m68k_plt_first_entry[M68K_PLT_ENTRY_SIZE] =
{
/* jmps @# */
0x4e, 0xf9,
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. */
{
struct aout_link_hash_table root;
- /* The first dynamic object found during the link. */
+ /* 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. */
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;
- }
+ return (struct bfd_hash_entry *) ret;
/* Call the allocation method of the superclass. */
ret = ((struct sunos_link_hash_entry *)
/* Set local fields. */
ret->dynindx = -1;
ret->dynstr_index = -1;
+ ret->got_offset = 0;
+ ret->plt_offset = 0;
ret->flags = 0;
}
struct sunos_link_hash_table *ret;
ret = ((struct sunos_link_hash_table *)
- malloc (sizeof (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;
- }
+ return (struct bfd_link_hash_table *) NULL;
if (! NAME(aout,link_hash_table_init) (&ret->root, abfd,
sunos_link_hash_newfunc))
{
- free (ret);
+ 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;
}
static boolean sunos_scan_dynamic_symbol
PARAMS ((struct sunos_link_hash_entry *, PTR));
-/* Add dynamic symbols during a link. This is called by the a.out
- backend linker when it encounters an object with the DYNAMIC flag
- set. */
+/* Create the dynamic sections needed if we are linking against a
+ dynamic object, or if we are linking PIC compiled code. ABFD is a
+ bfd we can attach the dynamic sections to. The linker script will
+ look for these special sections names and put them in the right
+ place in the output file. See include/aout/sun4.h for more details
+ of the dynamic linking information. */
static boolean
-sunos_add_dynamic_symbols (abfd, info)
+sunos_create_dynamic_sections (abfd, info, needed)
bfd *abfd;
struct bfd_link_info *info;
+ boolean needed;
{
asection *s;
- /* We do not want to include the sections in a dynamic object in the
- output file. We hack by simply clobbering the list of sections
- in the BFD. This could be handled more cleanly by, say, a new
- section flag; the existing SEC_NEVER_LOAD flag is not the one we
- want, because that one still implies that the section takes up
- space in the output file. */
- abfd->sections = NULL;
-
- /* The native linker seems to just ignore dynamic objects when -r is
- used. */
- if (info->relocateable)
- return true;
-
- /* There's no hope of using a dynamic object which does not exactly
- match the format of the output file. */
- if (info->hash->creator != abfd->xvec)
- {
- bfd_set_error (bfd_error_invalid_operation);
- return false;
- }
-
- /* If this is the first dynamic object, create some new sections to
- hold dynamic linking information. We need to put these sections
- somewhere, and the first dynamic object is as good a place as
- any. The linker script will look for these special section names
- and put them in the right place in the output file. See
- include/aout/sun4.h for more details of the dynamic linking
- information. */
- if (sunos_hash_table (info)->dynobj == NULL)
+ if (! sunos_hash_table (info)->dynamic_sections_created)
{
flagword flags;
- asection *sdyn;
sunos_hash_table (info)->dynobj = abfd;
-
+
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
/* The .dynamic section holds the basic dynamic information: the
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, flags)
|| ! bfd_set_section_alignment (abfd, s, 2))
- return false;
- sdyn = s;
-
- /* The .need section holds the list of names of shared objets
- which must be included at runtime. The address of this
- section is put in the ld_need field. */
- s = bfd_make_section (abfd, ".need");
- if (s == NULL
- || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
- || ! bfd_set_section_alignment (abfd, s, 2))
- return false;
-
- /* The .rules section holds the path to search for shared
- objects. The address of this section is put in the ld_rules
- field. */
- s = bfd_make_section (abfd, ".rules");
- if (s == NULL
- || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
- || ! bfd_set_section_alignment (abfd, s, 2))
return false;
- /* The .got section holds the global offset table. I don't
- really know how this works, actually. It seems to only be
- used for PIC code. The address minus four is put in the
- ld_got field. */
+ /* The .got section holds the global offset table. The address
+ is put in the ld_got field. */
s = bfd_make_section (abfd, ".got");
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, flags)
|| ! bfd_set_section_alignment (abfd, s, 2))
return false;
- s->_raw_size = BYTES_IN_WORD;
/* The .plt section holds the procedure linkage table. The
address is put in the ld_plt field. */
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
|| ! bfd_set_section_alignment (abfd, s, 2))
return false;
+
+ sunos_hash_table (info)->dynamic_sections_created = true;
+ }
+
+ if (needed && ! sunos_hash_table (info)->dynamic_sections_needed)
+ {
+ bfd *dynobj;
+
+ dynobj = sunos_hash_table (info)->dynobj;
+
+ s = bfd_get_section_by_name (dynobj, ".got");
+ s->_raw_size = BYTES_IN_WORD;
+
+ sunos_hash_table (info)->dynamic_sections_needed = true;
+ }
+
+ return true;
+}
+
+/* Add dynamic symbols during a link. This is called by the a.out
+ backend linker when it encounters an object with the DYNAMIC flag
+ set. */
+
+static boolean
+sunos_add_dynamic_symbols (abfd, info, symsp, sym_countp, stringsp)
+ bfd *abfd;
+ struct bfd_link_info *info;
+ struct external_nlist **symsp;
+ bfd_size_type *sym_countp;
+ char **stringsp;
+{
+ asection *s;
+ bfd *dynobj;
+ struct sunos_dynamic_info *dinfo;
+ unsigned long need;
+
+ /* We do not want to include the sections in a dynamic object in the
+ output file. We hack by simply clobbering the list of sections
+ in the BFD. This could be handled more cleanly by, say, a new
+ section flag; the existing SEC_NEVER_LOAD flag is not the one we
+ want, because that one still implies that the section takes up
+ space in the output file. */
+ abfd->sections = NULL;
+
+ /* The native linker seems to just ignore dynamic objects when -r is
+ used. */
+ if (info->relocateable)
+ return true;
+
+ /* There's no hope of using a dynamic object which does not exactly
+ match the format of the output file. */
+ if (info->hash->creator != abfd->xvec)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return false;
+ }
+
+ /* Make sure we have all the required information. */
+ if (! sunos_create_dynamic_sections (abfd, info, true))
+ return false;
+
+ /* Make sure we have a .need and a .rules sections. These are only
+ needed if there really is a dynamic object in the link, so they
+ are not added by sunos_create_dynamic_sections. */
+ dynobj = sunos_hash_table (info)->dynobj;
+ if (bfd_get_section_by_name (dynobj, ".need") == NULL)
+ {
+ /* The .need section holds the list of names of shared objets
+ which must be included at runtime. The address of this
+ section is put in the ld_need field. */
+ s = bfd_make_section (dynobj, ".need");
+ if (s == NULL
+ || ! bfd_set_section_flags (dynobj, s,
+ (SEC_ALLOC
+ | SEC_LOAD
+ | SEC_HAS_CONTENTS
+ | SEC_IN_MEMORY
+ | SEC_READONLY))
+ || ! bfd_set_section_alignment (dynobj, s, 2))
+ return false;
+ }
+
+ if (bfd_get_section_by_name (dynobj, ".rules") == NULL)
+ {
+ /* The .rules section holds the path to search for shared
+ objects. The address of this section is put in the ld_rules
+ field. */
+ s = bfd_make_section (dynobj, ".rules");
+ if (s == NULL
+ || ! bfd_set_section_flags (dynobj, s,
+ (SEC_ALLOC
+ | SEC_LOAD
+ | SEC_HAS_CONTENTS
+ | SEC_IN_MEMORY
+ | SEC_READONLY))
+ || ! bfd_set_section_alignment (dynobj, s, 2))
+ return false;
+ }
+
+ /* Pick up the dynamic symbols and return them to the caller. */
+ if (! sunos_slurp_dynamic_symtab (abfd))
+ return false;
+
+ dinfo = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
+ *symsp = dinfo->dynsym;
+ *sym_countp = dinfo->dynsym_count;
+ *stringsp = dinfo->dynstr;
+
+ /* Record information about any other objects needed by this one. */
+ need = dinfo->dyninfo.ld_need;
+ while (need != 0)
+ {
+ bfd_byte buf[16];
+ unsigned long name, flags;
+ unsigned short major_vno, minor_vno;
+ struct bfd_link_needed_list *needed, **pp;
+ bfd_byte b;
+
+ if (bfd_seek (abfd, need, SEEK_SET) != 0
+ || bfd_read (buf, 1, 16, abfd) != 16)
+ return false;
+
+ /* For the format of an ld_need entry, see aout/sun4.h. We
+ should probably define structs for this manipulation. */
+
+ name = bfd_get_32 (abfd, buf);
+ flags = bfd_get_32 (abfd, buf + 4);
+ major_vno = bfd_get_16 (abfd, buf + 8);
+ minor_vno = bfd_get_16 (abfd, buf + 10);
+ need = bfd_get_32 (abfd, buf + 12);
+
+ needed = (struct bfd_link_needed_list *) bfd_alloc (abfd, sizeof (struct bfd_link_needed_list));
+ if (needed == NULL)
+ return false;
+ needed->by = abfd;
+
+ /* We return the name as [-l]name[.maj][.min]. */
+
+ if ((flags & 0x80000000) != 0)
+ bfd_alloc_grow (abfd, "-l", 2);
+ if (bfd_seek (abfd, name, SEEK_SET) != 0)
+ return false;
+ do
+ {
+ if (bfd_read (&b, 1, 1, abfd) != 1)
+ return false;
+ bfd_alloc_grow (abfd, &b, 1);
+ }
+ while (b != '\0');
+ if (major_vno != 0)
+ {
+ char verbuf[30];
+
+ sprintf (verbuf, ".%d", major_vno);
+ bfd_alloc_grow (abfd, verbuf, strlen (verbuf));
+ if (minor_vno != 0)
+ {
+ sprintf (verbuf, ".%d", minor_vno);
+ bfd_alloc_grow (abfd, verbuf, strlen (verbuf));
+ }
+ }
+ needed->name = bfd_alloc_finish (abfd);
+ if (needed->name == NULL)
+ return false;
+
+ needed->next = NULL;
+
+ for (pp = &sunos_hash_table (info)->needed;
+ *pp != NULL;
+ pp = &(*pp)->next)
+ ;
+ *pp = needed;
}
return true;
struct sunos_link_hash_entry *h;
int new_flag;
+ if (! sunos_hash_table (info)->dynamic_sections_created)
+ {
+ /* We must create the dynamic sections while reading the input
+ files, even though at this point we don't know if any of the
+ sections will be needed. This will ensure that the dynamic
+ sections are mapped to the right output section. It does no
+ harm to create these sections if they are not needed. */
+ if (! sunos_create_dynamic_sections (abfd, info, false))
+ return false;
+ }
+
h = sunos_link_hash_lookup (sunos_hash_table (info), name, true, copy,
false);
if (h == NULL)
if (hashp != NULL)
*hashp = (struct bfd_link_hash_entry *) h;
- /* Treat a common symbol in a dynamic object as an undefined symbol.
- We don't want to allocate space in .bss for it. */
+ /* Treat a common symbol in a dynamic object as defined in the .bss
+ section of the dynamic object. We don't want to allocate space
+ for it in our process image. */
if ((abfd->flags & DYNAMIC) != 0
- && section == &bfd_com_section)
- section = &bfd_und_section;
+ && bfd_is_com_section (section))
+ section = obj_bsssec (abfd);
- if (section != &bfd_und_section
+ if (! bfd_is_und_section (section)
&& h->root.root.type != bfd_link_hash_new
- && h->root.root.type != bfd_link_hash_undefined)
+ && h->root.root.type != bfd_link_hash_undefined
+ && h->root.root.type != bfd_link_hash_defweak)
{
/* We are defining the symbol, and it is already defined. This
is a potential multiple definition error. */
We do not want this new definition to override the
existing definition, so we pretend it is just a
reference. */
- section = &bfd_und_section;
+ section = bfd_und_section_ptr;
}
- else if ((h->root.root.type == bfd_link_hash_defined
- && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
- || (h->root.root.type == bfd_link_hash_common
- && ((h->root.root.u.c.section->owner->flags & DYNAMIC)
- != 0)))
+ else if (h->root.root.type == bfd_link_hash_defined
+ && h->root.root.u.def.section->owner != NULL
+ && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
{
/* The existing definition is from a dynamic object. We
want to override it with the definition we just found.
Clobber the existing definition. */
h->root.root.type = bfd_link_hash_new;
}
+ else if (h->root.root.type == bfd_link_hash_common
+ && (h->root.root.u.c.p->section->owner->flags & DYNAMIC) != 0)
+ {
+ /* The existing definition is from a dynamic object. We
+ want to override it with the definition we just found.
+ Clobber the existing definition. We can't set it to new,
+ because it is on the undefined list. */
+ h->root.root.type = bfd_link_hash_undefined;
+ h->root.root.u.undef.abfd = h->root.root.u.c.p->section->owner;
+ }
}
/* Do the usual procedure for adding a symbol. */
hashp))
return false;
- /* Set a flag in the hash table entry indicating the type of
- reference or definition we just found. Keep a count of the
- number of dynamic symbols we find. A dynamic symbol is one which
- is referenced or defined by both a regular object and a shared
- object. */
- if ((abfd->flags & DYNAMIC) == 0)
+ if (abfd->xvec == info->hash->creator)
{
- if (section == &bfd_und_section)
- new_flag = SUNOS_REF_REGULAR;
- else
- new_flag = SUNOS_DEF_REGULAR;
- }
- else
- {
- if (section == &bfd_und_section)
- new_flag = SUNOS_REF_DYNAMIC;
+ /* Set a flag in the hash table entry indicating the type of
+ reference or definition we just found. Keep a count of the
+ number of dynamic symbols we find. A dynamic symbol is one
+ which is referenced or defined by both a regular object and a
+ shared object. */
+ if ((abfd->flags & DYNAMIC) == 0)
+ {
+ if (bfd_is_und_section (section))
+ new_flag = SUNOS_REF_REGULAR;
+ else
+ new_flag = SUNOS_DEF_REGULAR;
+ }
else
- new_flag = SUNOS_DEF_DYNAMIC;
- }
- h->flags |= new_flag;
+ {
+ if (bfd_is_und_section (section))
+ new_flag = SUNOS_REF_DYNAMIC;
+ else
+ new_flag = SUNOS_DEF_DYNAMIC;
+ }
+ h->flags |= new_flag;
- if (h->dynindx == -1
- && (h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
- {
- ++sunos_hash_table (info)->dynsymcount;
- h->dynindx = -2;
+ if (h->dynindx == -1
+ && (h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
+ {
+ ++sunos_hash_table (info)->dynsymcount;
+ h->dynindx = -2;
+ }
}
return true;
}
+/* Return the list of objects needed by BFD. */
+
+/*ARGSUSED*/
+struct bfd_link_needed_list *
+bfd_sunos_get_needed_list (abfd, info)
+ bfd *abfd;
+ struct bfd_link_info *info;
+{
+ if (info->hash->creator != &MY(vec))
+ return NULL;
+ return sunos_hash_table (info)->needed;
+}
+
/* Record an assignment made to a symbol by a linker script. We need
this in case some dynamic object refers to this symbol. */
{
struct sunos_link_hash_entry *h;
+ if (output_bfd->xvec != &MY(vec))
+ return true;
+
/* This is called after we have examined all the input objects. If
the symbol does not exist, it merely means that no object refers
to it, and we can just ignore it at this point. */
if (h == NULL)
return true;
- h->flags |= SUNOS_DEF_REGULAR;
-
- if (h->dynindx == -1)
+ /* In a shared library, the __DYNAMIC symbol does not appear in the
+ dynamic symbol table. */
+ if (! info->shared || strcmp (name, "__DYNAMIC") != 0)
{
- ++sunos_hash_table (info)->dynsymcount;
- h->dynindx = -2;
+ h->flags |= SUNOS_DEF_REGULAR;
+
+ if (h->dynindx == -1)
+ {
+ ++sunos_hash_table (info)->dynsymcount;
+ h->dynindx = -2;
+ }
}
return true;
{
bfd *dynobj;
size_t dynsymcount;
+ struct sunos_link_hash_entry *h;
asection *s;
size_t bucketcount;
size_t hashalloc;
*sneedptr = NULL;
*srulesptr = NULL;
+ if (output_bfd->xvec != &MY(vec))
+ return true;
+
+ /* Look through all the input BFD's and read their relocs. It would
+ be better if we didn't have to do this, but there is no other way
+ to determine the number of dynamic relocs we need, and, more
+ importantly, there is no other way to know which symbols should
+ get an entry in the procedure linkage table. */
+ for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+ {
+ if ((sub->flags & DYNAMIC) == 0
+ && sub->xvec == output_bfd->xvec)
+ {
+ if (! sunos_scan_relocs (info, sub, obj_textsec (sub),
+ exec_hdr (sub)->a_trsize)
+ || ! sunos_scan_relocs (info, sub, obj_datasec (sub),
+ exec_hdr (sub)->a_drsize))
+ return false;
+ }
+ }
+
dynobj = sunos_hash_table (info)->dynobj;
dynsymcount = sunos_hash_table (info)->dynsymcount;
- /* If there were no dynamic objects in the link, there is nothing to
- do here. */
- if (dynobj == NULL)
+ /* If there were no dynamic objects in the link, and we don't need
+ to build a global offset table, there is nothing to do here. */
+ if (! sunos_hash_table (info)->dynamic_sections_needed)
return true;
+ /* If __GLOBAL_OFFSET_TABLE_ was mentioned, define it. */
+ h = sunos_link_hash_lookup (sunos_hash_table (info),
+ "__GLOBAL_OFFSET_TABLE_", false, false, false);
+ if (h != NULL && (h->flags & SUNOS_REF_REGULAR) != 0)
+ {
+ h->flags |= SUNOS_DEF_REGULAR;
+ if (h->dynindx == -1)
+ {
+ ++sunos_hash_table (info)->dynsymcount;
+ h->dynindx = -2;
+ }
+ h->root.root.type = bfd_link_hash_defined;
+ h->root.root.u.def.section = bfd_get_section_by_name (dynobj, ".got");
+ h->root.root.u.def.value = 0;
+ }
+
/* The .dynamic section is always the same size. */
s = bfd_get_section_by_name (dynobj, ".dynamic");
BFD_ASSERT (s != NULL);
s->_raw_size = dynsymcount * sizeof (struct external_nlist);
s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
if (s->contents == NULL && s->_raw_size != 0)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
/* The number of buckets is just the number of symbols divided by
- four. The compute the final size of the hash table, we must
+ four. To compute the final size of the hash table, we must
actually compute the hash table. Normally we need exactly as
many entries in the hash table as there are dynamic symbols, but
if some of the buckets are not used we will need additional
- entries. In the worse case, every symbol will hash to the same
+ entries. In the worst case, every symbol will hash to the same
bucket, and we will need BUCKETCOUNT - 1 extra entries. */
if (dynsymcount >= 4)
bucketcount = dynsymcount / 4;
hashalloc = (dynsymcount + bucketcount - 1) * HASH_ENTRY_SIZE;
s->contents = (bfd_byte *) bfd_alloc (dynobj, hashalloc);
if (s->contents == NULL && dynsymcount > 0)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
memset (s->contents, 0, hashalloc);
for (i = 0; i < bucketcount; i++)
PUT_WORD (output_bfd, (bfd_vma) -1, s->contents + i * HASH_ENTRY_SIZE);
sunos_hash_table (info)->bucketcount = bucketcount;
- /* Look through all the input BFD's and read their relocs. It would
- be better if we didn't have to do this, but there is no other way
- to determine the number of dynamic relocs we need, and, more
- importantly, there is no other way to know which symbols should
- get an entry in the procedure linkage table. */
- for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
- {
- if ((sub->flags & DYNAMIC) == 0)
- {
- if (! sunos_scan_relocs (info, sub, obj_textsec (sub),
- exec_hdr (sub)->a_trsize)
- || ! sunos_scan_relocs (info, sub, obj_datasec (sub),
- exec_hdr (sub)->a_drsize))
- return false;
- }
- }
-
/* Scan all the symbols, place them in the dynamic symbol table, and
build the dynamic hash table. We reuse dynsymcount as a counter
for the number of symbols we have added so far. */
bfd_byte *contents;
add = 8 - (s->_raw_size & 7);
- contents = (bfd_byte *) realloc (s->contents, s->_raw_size + add);
+ contents = (bfd_byte *) realloc (s->contents,
+ (size_t) (s->_raw_size + add));
if (contents == NULL)
{
bfd_set_error (bfd_error_no_memory);
return false;
}
- memset (contents + s->_raw_size, 0, add);
+ memset (contents + s->_raw_size, 0, (size_t) add);
s->contents = contents;
s->_raw_size += add;
}
{
s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
if (s->contents == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
/* Fill in the first entry in the table. */
switch (bfd_get_arch (dynobj))
{
s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
if (s->contents == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
}
/* We use the reloc_count field to keep track of how many of the
relocs we have output so far. */
s = bfd_get_section_by_name (dynobj, ".got");
s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
if (s->contents == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
*sdynptr = bfd_get_section_by_name (dynobj, ".dynamic");
*sneedptr = bfd_get_section_by_name (dynobj, ".need");
return true;
if (! info->keep_memory)
- relocs = free_relocs = malloc (rel_size);
+ relocs = free_relocs = malloc ((size_t) rel_size);
else
{
- aout_section_data (sec) =
- ((struct aout_section_data_struct *)
- bfd_alloc (abfd, sizeof (struct aout_section_data_struct)));
- if (aout_section_data (sec) == NULL)
+ struct aout_section_data_struct *n;
+
+ n = ((struct aout_section_data_struct *)
+ bfd_alloc (abfd, sizeof (struct aout_section_data_struct)));
+ if (n == NULL)
relocs = NULL;
else
- relocs = aout_section_data (sec)->relocs = malloc (rel_size);
+ {
+ set_aout_section_data (sec, n);
+ relocs = malloc ((size_t) rel_size);
+ aout_section_data (sec)->relocs = relocs;
+ }
}
if (relocs == NULL)
{
bfd_size_type rel_size;
{
bfd *dynobj;
- asection *splt;
- asection *srel;
+ asection *splt = NULL;
+ asection *srel = NULL;
struct sunos_link_hash_entry **sym_hashes;
const struct reloc_std_external *rel, *relend;
return false;
}
- dynobj = sunos_hash_table (info)->dynobj;
- splt = bfd_get_section_by_name (dynobj, ".plt");
- srel = bfd_get_section_by_name (dynobj, ".dynrel");
- BFD_ASSERT (splt != NULL && srel != NULL);
+ dynobj = NULL;
+
sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
relend = relocs + rel_size / RELOC_STD_SIZE;
/* Get the symbol index. */
if (abfd->xvec->header_byteorder_big_p)
- {
- r_index = ((rel->r_index[0] << 16)
- | (rel->r_index[1] << 8)
- | rel->r_index[2]);
- }
+ r_index = ((rel->r_index[0] << 16)
+ | (rel->r_index[1] << 8)
+ | rel->r_index[2]);
else
- {
- r_index = ((rel->r_index[2] << 16)
- | (rel->r_index[1] << 8)
- | rel->r_index[0]);
- }
+ r_index = ((rel->r_index[2] << 16)
+ | (rel->r_index[1] << 8)
+ | rel->r_index[0]);
/* Get the hash table entry. */
h = sym_hashes[r_index];
/* At this point common symbols have already been allocated, so
we don't have to worry about them. We need to consider that
we may have already seen this symbol and marked it undefined;
- if the symbols is really undefined, then SUNOS_DEF_DYNAMIC
+ if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
will be zero. */
if (h->root.root.type != bfd_link_hash_defined
+ && h->root.root.type != bfd_link_hash_defweak
&& h->root.root.type != bfd_link_hash_undefined)
continue;
|| (h->flags & SUNOS_DEF_REGULAR) != 0)
continue;
+ if (dynobj == NULL)
+ {
+ if (! sunos_create_dynamic_sections (abfd, info, true))
+ return false;
+ dynobj = sunos_hash_table (info)->dynobj;
+ splt = bfd_get_section_by_name (dynobj, ".plt");
+ srel = bfd_get_section_by_name (dynobj, ".dynrel");
+ BFD_ASSERT (splt != NULL && srel != NULL);
+ }
+
BFD_ASSERT ((h->flags & SUNOS_REF_REGULAR) != 0);
- BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
- ? (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0
- : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0);
+ BFD_ASSERT (h->plt_offset != 0
+ || ((h->root.root.type == bfd_link_hash_defined
+ || h->root.root.type == bfd_link_hash_defweak)
+ ? (h->root.root.u.def.section->owner->flags
+ & DYNAMIC) != 0
+ : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0));
/* This reloc is against a symbol defined only by a dynamic
object. */
already done so. We change the definition of the symbol
to the .plt section; this will cause relocs against it to
be handled correctly. */
- if (h->root.root.u.def.section != splt)
+ if (h->plt_offset == 0)
{
if (splt->_raw_size == 0)
splt->_raw_size = M68K_PLT_ENTRY_SIZE;
- h->root.root.u.def.section = splt;
- h->root.root.u.def.value = splt->_raw_size;
+ h->plt_offset = splt->_raw_size;
+
+ if ((h->flags & SUNOS_DEF_REGULAR) == 0)
+ {
+ h->root.root.u.def.section = splt;
+ h->root.root.u.def.value = splt->_raw_size;
+ }
+
splt->_raw_size += M68K_PLT_ENTRY_SIZE;
- /* We will also need a dynamic reloc entry. */
- srel->_raw_size += RELOC_STD_SIZE;
+ /* We may also need a dynamic reloc entry. */
+ if ((h->flags & SUNOS_DEF_REGULAR) == 0)
+ srel->_raw_size += RELOC_STD_SIZE;
}
}
}
need to figure out what to do for each reloc against a dynamic
symbol. If the reloc is a WDISP30, and the symbol is in the .text
section, an entry is made in the procedure linkage table.
- Otherwise, we must preserve the reloc as a dynamic reloc. FIXME:
- We should also handle the PIC relocs here by building global offset
- table entries. */
+ Otherwise, we must preserve the reloc as a dynamic reloc. */
static boolean
sunos_scan_ext_relocs (info, abfd, sec, relocs, rel_size)
bfd_size_type rel_size;
{
bfd *dynobj;
- asection *splt;
- asection *srel;
struct sunos_link_hash_entry **sym_hashes;
const struct reloc_ext_external *rel, *relend;
+ asection *splt = NULL;
+ asection *sgot = NULL;
+ asection *srel = NULL;
/* We only know how to handle SPARC plt entries. */
if (bfd_get_arch (abfd) != bfd_arch_sparc)
return false;
}
- dynobj = sunos_hash_table (info)->dynobj;
- splt = bfd_get_section_by_name (dynobj, ".plt");
- srel = bfd_get_section_by_name (dynobj, ".dynrel");
- BFD_ASSERT (splt != NULL && srel != NULL);
+ dynobj = NULL;
+
sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
relend = relocs + rel_size / RELOC_EXT_SIZE;
for (rel = relocs; rel < relend; rel++)
{
- int r_index;
+ unsigned int r_index;
+ int r_extern;
int r_type;
- struct sunos_link_hash_entry *h;
+ struct sunos_link_hash_entry *h = NULL;
- /* We only want relocs against external symbols. */
+ /* Swap in the reloc information. */
if (abfd->xvec->header_byteorder_big_p)
{
- if ((rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG) == 0)
- continue;
+ r_index = ((rel->r_index[0] << 16)
+ | (rel->r_index[1] << 8)
+ | rel->r_index[2]);
+ r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
+ r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
+ >> RELOC_EXT_BITS_TYPE_SH_BIG);
}
else
{
- if ((rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE) == 0)
- continue;
+ r_index = ((rel->r_index[2] << 16)
+ | (rel->r_index[1] << 8)
+ | rel->r_index[0]);
+ r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
+ r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
+ >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
}
- /* Get the symbol index and reloc type. */
- if (abfd->xvec->header_byteorder_big_p)
+ if (r_extern)
{
- r_index = ((rel->r_index[0] << 16)
- | (rel->r_index[1] << 8)
- | rel->r_index[2]);
- r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
- >> RELOC_EXT_BITS_TYPE_SH_BIG);
+ h = sym_hashes[r_index];
+ if (h == NULL)
+ {
+ /* This should not normally happen, but it will in any
+ case be caught in the relocation phase. */
+ continue;
+ }
}
- else
+
+ /* If this is a base relative reloc, we need to make an entry in
+ the .got section. */
+ if (r_type == RELOC_BASE10
+ || r_type == RELOC_BASE13
+ || r_type == RELOC_BASE22)
{
- r_index = ((rel->r_index[2] << 16)
- | (rel->r_index[1] << 8)
- | rel->r_index[0]);
- r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
- >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
+ if (dynobj == NULL)
+ {
+ if (! sunos_create_dynamic_sections (abfd, info, true))
+ return false;
+ dynobj = sunos_hash_table (info)->dynobj;
+ splt = bfd_get_section_by_name (dynobj, ".plt");
+ sgot = bfd_get_section_by_name (dynobj, ".got");
+ srel = bfd_get_section_by_name (dynobj, ".dynrel");
+ BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
+ }
+
+ if (r_extern)
+ {
+ if (h->got_offset != 0)
+ continue;
+
+ h->got_offset = sgot->_raw_size;
+ }
+ else
+ {
+ if (r_index >= bfd_get_symcount (abfd))
+ {
+ /* This is abnormal, but should be caught in the
+ relocation phase. */
+ continue;
+ }
+
+ if (adata (abfd).local_got_offsets == NULL)
+ {
+ adata (abfd).local_got_offsets =
+ (bfd_vma *) bfd_zalloc (abfd,
+ (bfd_get_symcount (abfd)
+ * sizeof (bfd_vma)));
+ if (adata (abfd).local_got_offsets == NULL)
+ return false;
+ }
+
+ if (adata (abfd).local_got_offsets[r_index] != 0)
+ continue;
+
+ adata (abfd).local_got_offsets[r_index] = sgot->_raw_size;
+ }
+
+ sgot->_raw_size += BYTES_IN_WORD;
+
+ /* If we are making a shared library, or if the symbol is
+ defined by a dynamic object, we will need a dynamic reloc
+ entry. */
+ if (info->shared
+ || (h != NULL
+ && (h->flags & SUNOS_DEF_DYNAMIC) != 0
+ && (h->flags & SUNOS_DEF_REGULAR) == 0))
+ srel->_raw_size += RELOC_EXT_SIZE;
+
+ continue;
}
- /* Get the hash table entry. */
- h = sym_hashes[r_index];
- if (h == NULL)
+ /* Otherwise, we are only interested in relocs against symbols
+ defined in dynamic objects but not in regular objects. We
+ only need to consider relocs against external symbols. */
+ if (! r_extern)
{
- /* This should not normally happen, but it will in any case
- be caught in the relocation phase. */
+ /* But, if we are creating a shared library, we need to
+ generate an absolute reloc. */
+ if (info->shared)
+ {
+ if (dynobj == NULL)
+ {
+ if (! sunos_create_dynamic_sections (abfd, info, true))
+ return false;
+ dynobj = sunos_hash_table (info)->dynobj;
+ splt = bfd_get_section_by_name (dynobj, ".plt");
+ sgot = bfd_get_section_by_name (dynobj, ".got");
+ srel = bfd_get_section_by_name (dynobj, ".dynrel");
+ BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
+ }
+
+ srel->_raw_size += RELOC_EXT_SIZE;
+ }
+
continue;
}
/* At this point common symbols have already been allocated, so
we don't have to worry about them. We need to consider that
we may have already seen this symbol and marked it undefined;
- if the symbols is really undefined, then SUNOS_DEF_DYNAMIC
+ if the symbol is really undefined, then SUNOS_DEF_DYNAMIC
will be zero. */
if (h->root.root.type != bfd_link_hash_defined
+ && h->root.root.type != bfd_link_hash_defweak
&& h->root.root.type != bfd_link_hash_undefined)
continue;
- if ((h->flags & SUNOS_DEF_DYNAMIC) == 0
- || (h->flags & SUNOS_DEF_REGULAR) != 0)
+ if (r_type != RELOC_JMP_TBL
+ && ! info->shared
+ && ((h->flags & SUNOS_DEF_DYNAMIC) == 0
+ || (h->flags & SUNOS_DEF_REGULAR) != 0))
continue;
- BFD_ASSERT ((h->flags & SUNOS_REF_REGULAR) != 0);
- BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
- ? (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0
- : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0);
+ if (strcmp (h->root.root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
+ continue;
+
+ if (dynobj == NULL)
+ {
+ if (! sunos_create_dynamic_sections (abfd, info, true))
+ return false;
+ dynobj = sunos_hash_table (info)->dynobj;
+ splt = bfd_get_section_by_name (dynobj, ".plt");
+ sgot = bfd_get_section_by_name (dynobj, ".got");
+ srel = bfd_get_section_by_name (dynobj, ".dynrel");
+ BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
+ }
+
+ BFD_ASSERT (r_type == RELOC_JMP_TBL
+ || (h->flags & SUNOS_REF_REGULAR) != 0);
+ BFD_ASSERT (r_type == RELOC_JMP_TBL
+ || info->shared
+ || h->plt_offset != 0
+ || ((h->root.root.type == bfd_link_hash_defined
+ || h->root.root.type == bfd_link_hash_defweak)
+ ? (h->root.root.u.def.section->owner->flags
+ & DYNAMIC) != 0
+ : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0));
/* This reloc is against a symbol defined only by a dynamic
- object. */
+ object, or it is a jump table reloc from PIC compiled code. */
- if (h->root.root.type == bfd_link_hash_undefined)
+ if (r_type != RELOC_JMP_TBL
+ && h->root.root.type == bfd_link_hash_undefined)
{
/* Presumably this symbol was marked as being undefined by
an earlier reloc. */
srel->_raw_size += RELOC_EXT_SIZE;
}
- else if ((h->root.root.u.def.section->flags & SEC_CODE) == 0)
+ else if (r_type != RELOC_JMP_TBL
+ && (h->root.root.u.def.section->flags & SEC_CODE) == 0)
{
bfd *sub;
copied into the dynamic relocs. We mark the symbol as
being undefined. */
srel->_raw_size += RELOC_EXT_SIZE;
- sub = h->root.root.u.def.section->owner;
- h->root.root.type = bfd_link_hash_undefined;
- h->root.root.u.undef.abfd = sub;
+ if ((h->flags & SUNOS_DEF_REGULAR) == 0)
+ {
+ sub = h->root.root.u.def.section->owner;
+ h->root.root.type = bfd_link_hash_undefined;
+ h->root.root.u.undef.abfd = sub;
+ }
}
else
{
already done so. We change the definition of the symbol
to the .plt section; this will cause relocs against it to
be handled correctly. */
- if (h->root.root.u.def.section != splt)
+ if (h->plt_offset == 0)
{
if (splt->_raw_size == 0)
splt->_raw_size = SPARC_PLT_ENTRY_SIZE;
- h->root.root.u.def.section = splt;
- h->root.root.u.def.value = splt->_raw_size;
+ h->plt_offset = splt->_raw_size;
+
+ if ((h->flags & SUNOS_DEF_REGULAR) == 0)
+ {
+ if (h->root.root.type == bfd_link_hash_undefined)
+ h->root.root.type = bfd_link_hash_defined;
+ h->root.root.u.def.section = splt;
+ h->root.root.u.def.value = splt->_raw_size;
+ }
+
splt->_raw_size += SPARC_PLT_ENTRY_SIZE;
- /* We will also need a dynamic reloc entry. */
- srel->_raw_size += RELOC_EXT_SIZE;
+ /* We will also need a dynamic reloc entry, unless this
+ is a JMP_TBL reloc produced by linking PIC compiled
+ code, and we are not making a shared library. */
+ if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
+ srel->_raw_size += RELOC_EXT_SIZE;
}
+
+ /* If we are creating a shared library, we need to copy over
+ any reloc other than a jump table reloc. */
+ if (info->shared && r_type != RELOC_JMP_TBL)
+ srel->_raw_size += RELOC_EXT_SIZE;
}
}
part of the regular symbol table. This is all symbols which are
not defined in a regular object file. For some reason symbols
which are referenced by a regular object and defined by a dynamic
- object do not seem to show up in the regular symbol table. */
- if ((h->flags & SUNOS_DEF_REGULAR) == 0)
+ object do not seem to show up in the regular symbol table. It is
+ possible for a symbol to have only SUNOS_REF_REGULAR set here, it
+ is an undefined symbol which was turned into a common symbol
+ because it was found in an archive object which was not included
+ in the link. */
+ if ((h->flags & SUNOS_DEF_REGULAR) == 0
+ && (h->flags & SUNOS_DEF_DYNAMIC) != 0
+ && strcmp (h->root.root.root.string, "__DYNAMIC") != 0)
h->root.written = true;
/* If this symbol is defined by a dynamic object and referenced by a
&& (h->flags & SUNOS_DEF_DYNAMIC) != 0
&& (h->flags & SUNOS_REF_REGULAR) != 0)
{
- if (h->root.root.type == bfd_link_hash_defined
+ if ((h->root.root.type == bfd_link_hash_defined
+ || h->root.root.type == bfd_link_hash_defweak)
&& ((h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
&& h->root.root.u.def.section->output_section == NULL)
{
BFD_ASSERT (h->dynindx == -2);
+ dynobj = sunos_hash_table (info)->dynobj;
+
h->dynindx = sunos_hash_table (info)->dynsymcount;
++sunos_hash_table (info)->dynsymcount;
regular symbols includes the debugging symbols, which have
long names and are often duplicated in several object files.
There are no debugging symbols in the dynamic symbols. */
- s = bfd_get_section_by_name (sunos_hash_table (info)->dynobj,
- ".dynstr");
+ s = bfd_get_section_by_name (dynobj, ".dynstr");
BFD_ASSERT (s != NULL);
if (s->contents == NULL)
contents = (bfd_byte *) malloc (len + 1);
else
- contents = (bfd_byte *) realloc (s->contents, s->_raw_size + len + 1);
+ contents = (bfd_byte *) realloc (s->contents,
+ (size_t) (s->_raw_size + len + 1));
if (contents == NULL)
{
bfd_set_error (bfd_error_no_memory);
hash &= 0x7fffffff;
hash %= sunos_hash_table (info)->bucketcount;
- dynobj = sunos_hash_table (info)->dynobj;
s = bfd_get_section_by_name (dynobj, ".hash");
BFD_ASSERT (s != NULL);
return true;
}
-
/* Write out a dynamic symbol. This is called by the final traversal
over the symbol table. */
struct aout_link_hash_entry *harg;
{
struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
- boolean plt;
int type;
bfd_vma val;
asection *s;
if (h->dynindx < 0)
return true;
- plt = false;
switch (h->root.root.type)
{
default:
val = 0;
break;
case bfd_link_hash_defined:
+ case bfd_link_hash_defweak:
{
asection *sec;
asection *output_section;
sec = h->root.root.u.def.section;
output_section = sec->output_section;
- BFD_ASSERT (output_section == &bfd_abs_section
+ BFD_ASSERT (bfd_is_abs_section (output_section)
|| output_section->owner == output_bfd);
- if (strcmp (sec->name, ".plt") == 0)
+ if (h->plt_offset != 0
+ && (h->flags & SUNOS_DEF_REGULAR) == 0)
{
- plt = true;
type = N_UNDF | N_EXT;
val = 0;
}
else
{
if (output_section == obj_textsec (output_bfd))
- type = N_TEXT | N_EXT;
+ type = (h->root.root.type == bfd_link_hash_defined
+ ? N_TEXT
+ : N_WEAKT);
else if (output_section == obj_datasec (output_bfd))
- type = N_DATA | N_EXT;
+ type = (h->root.root.type == bfd_link_hash_defined
+ ? N_DATA
+ : N_WEAKD);
else if (output_section == obj_bsssec (output_bfd))
- type = N_BSS | N_EXT;
+ type = (h->root.root.type == bfd_link_hash_defined
+ ? N_BSS
+ : N_WEAKB);
else
- type = N_ABS | N_EXT;
+ type = (h->root.root.type == bfd_link_hash_defined
+ ? N_ABS
+ : N_WEAKA);
+ type |= N_EXT;
val = (h->root.root.u.def.value
+ output_section->vma
+ sec->output_offset);
type = N_UNDF | N_EXT;
val = h->root.root.u.c.size;
break;
- case bfd_link_hash_weak:
+ case bfd_link_hash_undefweak:
type = N_WEAKU;
val = 0;
break;
/* If this symbol is in the procedure linkage table, fill in the
table entry. */
- if (plt)
+ if (h->plt_offset != 0)
{
+ bfd *dynobj;
+ asection *splt;
bfd_byte *p;
asection *s;
bfd_vma r_address;
- p = h->root.root.u.def.section->contents + h->root.root.u.def.value;
+ dynobj = sunos_hash_table (info)->dynobj;
+ splt = bfd_get_section_by_name (dynobj, ".plt");
+ p = splt->contents + h->plt_offset;
- s = bfd_get_section_by_name (sunos_hash_table (info)->dynobj, ".dynrel");
- BFD_ASSERT (s != NULL);
+ s = bfd_get_section_by_name (dynobj, ".dynrel");
- r_address = (h->root.root.u.def.section->output_section->vma
- + h->root.root.u.def.section->output_offset
- + h->root.root.u.def.value);
+ r_address = (splt->output_section->vma
+ + splt->output_offset
+ + h->plt_offset);
switch (bfd_get_arch (output_bfd))
{
case bfd_arch_sparc:
- bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD0, p);
- bfd_put_32 (output_bfd,
- (SPARC_PLT_ENTRY_WORD1
- + (((- (h->root.root.u.def.value + 4) >> 2)
- & 0x3fffffff))),
- p + 4);
- bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD2 + s->reloc_count,
- p + 8);
+ if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
+ {
+ bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD0, p);
+ bfd_put_32 (output_bfd,
+ (SPARC_PLT_ENTRY_WORD1
+ + (((- (h->plt_offset + 4) >> 2)
+ & 0x3fffffff))),
+ p + 4);
+ bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD2 + s->reloc_count,
+ p + 8);
+ }
+ else
+ {
+ bfd_vma val;
+
+ val = (h->root.root.u.def.section->output_section->vma
+ + h->root.root.u.def.section->output_offset
+ + h->root.root.u.def.value);
+ bfd_put_32 (output_bfd,
+ SPARC_PLT_PIC_WORD0 + ((val >> 10) & 0x3fffff),
+ p);
+ bfd_put_32 (output_bfd,
+ SPARC_PLT_PIC_WORD1 + (val & 0x3ff),
+ p + 4);
+ bfd_put_32 (output_bfd, SPARC_PLT_PIC_WORD2, p + 8);
+ }
break;
case bfd_arch_m68k:
+ if (! info->shared && (h->flags & SUNOS_DEF_REGULAR) != 0)
+ abort ();
bfd_put_16 (output_bfd, M68K_PLT_ENTRY_WORD0, p);
- bfd_put_32 (output_bfd, (- (h->root.root.u.def.value + 2)), p + 2);
+ bfd_put_32 (output_bfd, (- (h->plt_offset + 2)), p + 2);
bfd_put_16 (output_bfd, s->reloc_count, p + 6);
r_address += 2;
break;
abort ();
}
- /* We also need to add a jump table reloc. */
- p = s->contents + s->reloc_count * obj_reloc_entry_size (output_bfd);
- if (obj_reloc_entry_size (output_bfd) == RELOC_STD_SIZE)
+ /* We also need to add a jump table reloc, unless this is the
+ result of a JMP_TBL reloc from PIC compiled code. */
+ if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0)
{
- struct reloc_std_external *srel;
-
- srel = (struct reloc_std_external *) p;
- PUT_WORD (output_bfd, r_address, srel->r_address);
- if (output_bfd->xvec->header_byteorder_big_p)
+ BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
+ < s->_raw_size);
+ p = s->contents + s->reloc_count * obj_reloc_entry_size (output_bfd);
+ if (obj_reloc_entry_size (output_bfd) == RELOC_STD_SIZE)
{
- srel->r_index[0] = h->dynindx >> 16;
- srel->r_index[1] = h->dynindx >> 8;
- srel->r_index[2] = h->dynindx;
- srel->r_type[0] = (RELOC_STD_BITS_EXTERN_BIG
- | RELOC_STD_BITS_JMPTABLE_BIG);
+ struct reloc_std_external *srel;
+
+ srel = (struct reloc_std_external *) p;
+ PUT_WORD (output_bfd, r_address, srel->r_address);
+ if (output_bfd->xvec->header_byteorder_big_p)
+ {
+ srel->r_index[0] = h->dynindx >> 16;
+ srel->r_index[1] = h->dynindx >> 8;
+ srel->r_index[2] = h->dynindx;
+ srel->r_type[0] = (RELOC_STD_BITS_EXTERN_BIG
+ | RELOC_STD_BITS_JMPTABLE_BIG);
+ }
+ else
+ {
+ srel->r_index[2] = h->dynindx >> 16;
+ srel->r_index[1] = h->dynindx >> 8;
+ srel->r_index[0] = h->dynindx;
+ srel->r_type[0] = (RELOC_STD_BITS_EXTERN_LITTLE
+ | RELOC_STD_BITS_JMPTABLE_LITTLE);
+ }
}
else
{
- srel->r_index[2] = h->dynindx >> 16;
- srel->r_index[1] = h->dynindx >> 8;
- srel->r_index[0] = h->dynindx;
- srel->r_type[0] = (RELOC_STD_BITS_EXTERN_LITTLE
- | RELOC_STD_BITS_JMPTABLE_LITTLE);
+ struct reloc_ext_external *erel;
+
+ erel = (struct reloc_ext_external *) p;
+ PUT_WORD (output_bfd, r_address, erel->r_address);
+ if (output_bfd->xvec->header_byteorder_big_p)
+ {
+ erel->r_index[0] = h->dynindx >> 16;
+ erel->r_index[1] = h->dynindx >> 8;
+ erel->r_index[2] = h->dynindx;
+ erel->r_type[0] =
+ (RELOC_EXT_BITS_EXTERN_BIG
+ | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_BIG));
+ }
+ else
+ {
+ erel->r_index[2] = h->dynindx >> 16;
+ erel->r_index[1] = h->dynindx >> 8;
+ erel->r_index[0] = h->dynindx;
+ erel->r_type[0] =
+ (RELOC_EXT_BITS_EXTERN_LITTLE
+ | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_LITTLE));
+ }
+ PUT_WORD (output_bfd, (bfd_vma) 0, erel->r_addend);
}
- }
- else
- {
- struct reloc_ext_external *erel;
- erel = (struct reloc_ext_external *) p;
- PUT_WORD (output_bfd, r_address, erel->r_address);
- if (output_bfd->xvec->header_byteorder_big_p)
- {
- erel->r_index[0] = h->dynindx >> 16;
- erel->r_index[1] = h->dynindx >> 8;
- erel->r_index[2] = h->dynindx;
- erel->r_type[0] = (RELOC_EXT_BITS_EXTERN_BIG
- | (22 << RELOC_EXT_BITS_TYPE_SH_BIG));
- }
- else
- {
- erel->r_index[2] = h->dynindx >> 16;
- erel->r_index[1] = h->dynindx >> 8;
- erel->r_index[0] = h->dynindx;
- erel->r_type[0] = (RELOC_EXT_BITS_EXTERN_LITTLE
- | (22 << RELOC_EXT_BITS_TYPE_SH_LITTLE));
- }
- PUT_WORD (output_bfd, (bfd_vma) 0, erel->r_addend);
+ ++s->reloc_count;
}
-
- ++s->reloc_count;
}
return true;
/*ARGSUSED*/
static boolean
-sunos_check_dynamic_reloc (info, input_bfd, input_section, harg, reloc, skip)
+sunos_check_dynamic_reloc (info, input_bfd, input_section, harg, reloc,
+ contents, skip, relocationp)
struct bfd_link_info *info;
bfd *input_bfd;
asection *input_section;
struct aout_link_hash_entry *harg;
PTR reloc;
+ bfd_byte *contents;
boolean *skip;
+ bfd_vma *relocationp;
{
struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
bfd *dynobj;
- asection *srel;
+ boolean baserel;
+ boolean jmptbl;
+ asection *s;
bfd_byte *p;
+ long indx;
*skip = false;
dynobj = sunos_hash_table (info)->dynobj;
- if (dynobj == NULL
- || h->dynindx == -1
- || h->root.root.type != bfd_link_hash_undefined
- || (h->flags & SUNOS_DEF_REGULAR) != 0
- || (h->flags & SUNOS_DEF_DYNAMIC) == 0
- || (h->root.root.u.undef.abfd->flags & DYNAMIC) == 0)
+ if (h != NULL && h->plt_offset != 0)
+ {
+ asection *splt;
+
+ /* Redirect the relocation to the PLT entry. */
+ splt = bfd_get_section_by_name (dynobj, ".plt");
+ *relocationp = (splt->output_section->vma
+ + splt->output_offset
+ + h->plt_offset);
+ }
+
+ if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
+ {
+ struct reloc_std_external *srel;
+
+ srel = (struct reloc_std_external *) reloc;
+ if (input_bfd->xvec->header_byteorder_big_p)
+ {
+ baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
+ jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
+ }
+ else
+ {
+ baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
+ jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
+ }
+ }
+ else
+ {
+ struct reloc_ext_external *erel;
+ int r_type;
+
+ erel = (struct reloc_ext_external *) reloc;
+ if (input_bfd->xvec->header_byteorder_big_p)
+ r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
+ >> RELOC_EXT_BITS_TYPE_SH_BIG);
+ else
+ r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
+ >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
+ baserel = (r_type == RELOC_BASE10
+ || r_type == RELOC_BASE13
+ || r_type == RELOC_BASE22);
+ jmptbl = r_type == RELOC_JMP_TBL;
+ }
+
+ if (baserel)
+ {
+ bfd_vma *got_offsetp;
+ asection *sgot;
+
+ if (h != NULL)
+ got_offsetp = &h->got_offset;
+ else if (adata (input_bfd).local_got_offsets == NULL)
+ got_offsetp = NULL;
+ else
+ {
+ struct reloc_std_external *srel;
+ int r_index;
+
+ srel = (struct reloc_std_external *) reloc;
+ if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
+ {
+ if (input_bfd->xvec->header_byteorder_big_p)
+ r_index = ((srel->r_index[0] << 16)
+ | (srel->r_index[1] << 8)
+ | srel->r_index[2]);
+ else
+ r_index = ((srel->r_index[2] << 16)
+ | (srel->r_index[1] << 8)
+ | srel->r_index[0]);
+ }
+ else
+ {
+ struct reloc_ext_external *erel;
+
+ erel = (struct reloc_ext_external *) reloc;
+ if (input_bfd->xvec->header_byteorder_big_p)
+ r_index = ((erel->r_index[0] << 16)
+ | (erel->r_index[1] << 8)
+ | erel->r_index[2]);
+ else
+ r_index = ((erel->r_index[2] << 16)
+ | (erel->r_index[1] << 8)
+ | erel->r_index[0]);
+ }
+
+ got_offsetp = adata (input_bfd).local_got_offsets + r_index;
+ }
+
+ BFD_ASSERT (got_offsetp != NULL && *got_offsetp != 0);
+
+ sgot = bfd_get_section_by_name (dynobj, ".got");
+
+ /* We set the least significant bit to indicate whether we have
+ already initialized the GOT entry. */
+ if ((*got_offsetp & 1) == 0)
+ {
+ if (h == NULL
+ || (! info->shared
+ && ((h->flags & SUNOS_DEF_DYNAMIC) == 0
+ || (h->flags & SUNOS_DEF_REGULAR) != 0)))
+ PUT_WORD (dynobj, *relocationp, sgot->contents + *got_offsetp);
+ else
+ PUT_WORD (dynobj, 0, sgot->contents + *got_offsetp);
+
+ if (info->shared
+ || (h != NULL
+ && (h->flags & SUNOS_DEF_DYNAMIC) != 0
+ && (h->flags & SUNOS_DEF_REGULAR) == 0))
+ {
+ /* We need to create a GLOB_DAT or 32 reloc to tell the
+ dynamic linker to fill in this entry in the table. */
+
+ s = bfd_get_section_by_name (dynobj, ".dynrel");
+ BFD_ASSERT (s != NULL);
+ BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj)
+ < s->_raw_size);
+
+ p = (s->contents
+ + s->reloc_count * obj_reloc_entry_size (dynobj));
+
+ if (h != NULL)
+ indx = h->dynindx;
+ else
+ indx = 0;
+
+ if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE)
+ {
+ struct reloc_std_external *srel;
+
+ srel = (struct reloc_std_external *) p;
+ PUT_WORD (dynobj,
+ (*got_offsetp
+ + sgot->output_section->vma
+ + sgot->output_offset),
+ srel->r_address);
+ if (dynobj->xvec->header_byteorder_big_p)
+ {
+ srel->r_index[0] = indx >> 16;
+ srel->r_index[1] = indx >> 8;
+ srel->r_index[2] = indx;
+ if (h == NULL)
+ srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_BIG;
+ else
+ srel->r_type[0] =
+ (RELOC_STD_BITS_EXTERN_BIG
+ | RELOC_STD_BITS_BASEREL_BIG
+ | RELOC_STD_BITS_RELATIVE_BIG
+ | (2 << RELOC_STD_BITS_LENGTH_SH_BIG));
+ }
+ else
+ {
+ srel->r_index[2] = indx >> 16;
+ srel->r_index[1] = indx >> 8;
+ srel->r_index[0] = indx;
+ if (h == NULL)
+ srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_LITTLE;
+ else
+ srel->r_type[0] =
+ (RELOC_STD_BITS_EXTERN_LITTLE
+ | RELOC_STD_BITS_BASEREL_LITTLE
+ | RELOC_STD_BITS_RELATIVE_LITTLE
+ | (2 << RELOC_STD_BITS_LENGTH_SH_LITTLE));
+ }
+ }
+ else
+ {
+ struct reloc_ext_external *erel;
+
+ erel = (struct reloc_ext_external *) p;
+ PUT_WORD (dynobj,
+ (*got_offsetp
+ + sgot->output_section->vma
+ + sgot->output_offset),
+ erel->r_address);
+ if (dynobj->xvec->header_byteorder_big_p)
+ {
+ erel->r_index[0] = indx >> 16;
+ erel->r_index[1] = indx >> 8;
+ erel->r_index[2] = indx;
+ if (h == NULL)
+ erel->r_type[0] =
+ RELOC_32 << RELOC_EXT_BITS_TYPE_SH_BIG;
+ else
+ erel->r_type[0] =
+ (RELOC_EXT_BITS_EXTERN_BIG
+ | (RELOC_GLOB_DAT << RELOC_EXT_BITS_TYPE_SH_BIG));
+ }
+ else
+ {
+ erel->r_index[2] = indx >> 16;
+ erel->r_index[1] = indx >> 8;
+ erel->r_index[0] = indx;
+ if (h == NULL)
+ erel->r_type[0] =
+ RELOC_32 << RELOC_EXT_BITS_TYPE_SH_LITTLE;
+ else
+ erel->r_type[0] =
+ (RELOC_EXT_BITS_EXTERN_LITTLE
+ | (RELOC_GLOB_DAT
+ << RELOC_EXT_BITS_TYPE_SH_LITTLE));
+ }
+ PUT_WORD (dynobj, 0, erel->r_addend);
+ }
+
+ ++s->reloc_count;
+ }
+
+ *got_offsetp |= 1;
+ }
+
+ *relocationp = sgot->vma + (*got_offsetp &~ 1);
+
+ /* There is nothing else to do for a base relative reloc. */
+ return true;
+ }
+
+ if (! sunos_hash_table (info)->dynamic_sections_needed)
return true;
+ if (! info->shared)
+ {
+ if (h == NULL
+ || h->dynindx == -1
+ || h->root.root.type != bfd_link_hash_undefined
+ || (h->flags & SUNOS_DEF_REGULAR) != 0
+ || (h->flags & SUNOS_DEF_DYNAMIC) == 0
+ || (h->root.root.u.undef.abfd->flags & DYNAMIC) == 0)
+ return true;
+ }
+ else
+ {
+ if (h != NULL
+ && (h->dynindx == -1
+ || jmptbl
+ || strcmp (h->root.root.root.string,
+ "__GLOBAL_OFFSET_TABLE_") == 0))
+ return true;
+ }
- /* It looks this is a reloc we are supposed to copy. */
+ /* It looks like this is a reloc we are supposed to copy. */
- srel = bfd_get_section_by_name (dynobj, ".dynrel");
- BFD_ASSERT (srel != NULL);
+ s = bfd_get_section_by_name (dynobj, ".dynrel");
+ BFD_ASSERT (s != NULL);
+ BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) < s->_raw_size);
- p = srel->contents + srel->reloc_count * obj_reloc_entry_size (dynobj);
+ p = s->contents + s->reloc_count * obj_reloc_entry_size (dynobj);
/* Copy the reloc over. */
memcpy (p, reloc, obj_reloc_entry_size (dynobj));
+ if (h != NULL)
+ indx = h->dynindx;
+ else
+ indx = 0;
+
/* Adjust the address and symbol index. */
if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE)
{
srel->r_address);
if (dynobj->xvec->header_byteorder_big_p)
{
- srel->r_index[0] = h->dynindx >> 16;
- srel->r_index[1] = h->dynindx >> 8;
- srel->r_index[2] = h->dynindx;
+ srel->r_index[0] = indx >> 16;
+ srel->r_index[1] = indx >> 8;
+ srel->r_index[2] = indx;
}
else
{
- srel->r_index[2] = h->dynindx >> 16;
- srel->r_index[1] = h->dynindx >> 8;
- srel->r_index[0] = h->dynindx;
+ srel->r_index[2] = indx >> 16;
+ srel->r_index[1] = indx >> 8;
+ srel->r_index[0] = indx;
}
}
else
erel->r_address);
if (dynobj->xvec->header_byteorder_big_p)
{
- erel->r_index[0] = h->dynindx >> 16;
- erel->r_index[1] = h->dynindx >> 8;
- erel->r_index[2] = h->dynindx;
+ erel->r_index[0] = indx >> 16;
+ erel->r_index[1] = indx >> 8;
+ erel->r_index[2] = indx;
}
else
{
- erel->r_index[2] = h->dynindx >> 16;
- erel->r_index[1] = h->dynindx >> 8;
- erel->r_index[0] = h->dynindx;
+ erel->r_index[2] = indx >> 16;
+ erel->r_index[1] = indx >> 8;
+ erel->r_index[0] = indx;
}
}
- ++srel->reloc_count;
+ ++s->reloc_count;
- *skip = true;
+ if (h != NULL)
+ *skip = true;
return true;
}
struct external_sun4_dynamic esd;
struct external_sun4_dynamic_link esdl;
- dynobj = sunos_hash_table (info)->dynobj;
- if (dynobj == NULL)
+ if (! sunos_hash_table (info)->dynamic_sections_needed)
return true;
+ dynobj = sunos_hash_table (info)->dynobj;
+
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
BFD_ASSERT (sdyn != NULL);
real addresses. Now that we know the section location, we can
fill in the final values. */
s = bfd_get_section_by_name (dynobj, ".need");
- BFD_ASSERT (s != NULL);
- if (s->_raw_size != 0)
+ if (s != NULL && s->_raw_size != 0)
{
file_ptr filepos;
bfd_byte *p;
}
}
- /* The first entry in the .got section is the address of the dynamic
- information. */
+ /* The first entry in the .got section is the address of the
+ dynamic information, unless this is a shared library. */
s = bfd_get_section_by_name (dynobj, ".got");
BFD_ASSERT (s != NULL);
- PUT_WORD (dynobj, sdyn->output_section->vma + sdyn->output_offset,
- s->contents);
+ if (info->shared)
+ PUT_WORD (dynobj, 0, s->contents);
+ else
+ PUT_WORD (dynobj, sdyn->output_section->vma + sdyn->output_offset,
+ s->contents);
for (o = dynobj->sections; o != NULL; o = o->next)
{
PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_loaded);
s = bfd_get_section_by_name (dynobj, ".need");
- BFD_ASSERT (s != NULL);
- if (s->_raw_size == 0)
+ if (s == NULL || s->_raw_size == 0)
PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_need);
else
PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
esdl.ld_need);
s = bfd_get_section_by_name (dynobj, ".rules");
- BFD_ASSERT (s != NULL);
- if (s->_raw_size == 0)
+ if (s == NULL || s->_raw_size == 0)
PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_rules);
else
PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
projects / deliverable / binutils-gdb.git / blobdiff