mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2025-02-05 12:53:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

* elf32-m32r.c (m32r_elf_create_dynamic_sections): Fix pointer

Browse Source 
aliasing warning.  Remove trailing whitespace throughout file.
This commit is contained in:
Alan Modra 2004-03-16 01:49:30 +00:00
parent fdd12ef3c6
commit 419783084d
2 changed files with 150 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
bfd/ChangeLog
View File

@ -1,3 +1,8 @@
2004-03-16 Alan Modra <amodra@bigpond.net.au>
* elf32-m32r.c (m32r_elf_create_dynamic_sections): Fix pointer
aliasing warning. Remove trailing whitespace throughout file.
2004-03-15 John David Anglin <dave.anglin@nrc-cnrc.gc.ca> 2004-03-15 John David Anglin <dave.anglin@nrc-cnrc.gc.ca>
* elf-hppa.h (elf_hppa_relocate_section): Pass input_bfd instead of * elf-hppa.h (elf_hppa_relocate_section): Pass input_bfd instead of

289
bfd/elf32-m32r.c
View File

@ -1,5 +1,5 @@
/* M32R-specific support for 32-bit ELF. /* M32R-specific support for 32-bit ELF.
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc. Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library. This file is part of BFD, the Binary File Descriptor library.
@ -93,11 +93,11 @@ static bfd_boolean m32r_elf_create_dynamic_sections
static bfd_boolean m32r_elf_finish_dynamic_sections static bfd_boolean m32r_elf_finish_dynamic_sections
PARAMS ((bfd *, struct bfd_link_info *)); PARAMS ((bfd *, struct bfd_link_info *));
static bfd_boolean m32r_elf_finish_dynamic_symbol static bfd_boolean m32r_elf_finish_dynamic_symbol
PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
Elf_Internal_Sym *)); Elf_Internal_Sym *));
static bfd_boolean allocate_dynrelocs static bfd_boolean allocate_dynrelocs
PARAMS ((struct elf_link_hash_entry *, PTR)); PARAMS ((struct elf_link_hash_entry *, PTR));
static bfd_boolean readonly_dynrelocs static bfd_boolean readonly_dynrelocs
@ -122,39 +122,39 @@ static bfd_boolean m32r_elf_fake_sections
/* Use RELA. But use REL to link old objects for backwords compatibility. */ /* Use RELA. But use REL to link old objects for backwords compatibility. */
/* Functions for the M32R ELF linker. */ /* Functions for the M32R ELF linker. */
/* The name of the dynamic interpreter. This is put in the .interp /* The name of the dynamic interpreter. This is put in the .interp
section. */ section. */
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
/* The nop opcode we use. */ /* The nop opcode we use. */
#define M32R_NOP 0x7000f000 #define M32R_NOP 0x7000f000
#define PLT_EMPTY 0x10101010 /* RIE -> RIE */ #define PLT_EMPTY 0x10101010 /* RIE -> RIE */
/* The size in bytes of an entry in the procedure linkage table. */ /* The size in bytes of an entry in the procedure linkage table. */
#define PLT_ENTRY_SIZE 20 #define PLT_ENTRY_SIZE 20
#define PLT_HEADER_SIZE 20 #define PLT_HEADER_SIZE 20
/* The first one entries in a procedure linkage table are reserved, /* The first one entries in a procedure linkage table are reserved,
and the initial contents are unimportant (we zero them out). and the initial contents are unimportant (we zero them out).
Subsequent entries look like this. */ Subsequent entries look like this. */
#define PLT0_ENTRY_WORD0 0xd6c00000 /* seth r6, #high(.got+4) */ #define PLT0_ENTRY_WORD0 0xd6c00000 /* seth r6, #high(.got+4) */
#define PLT0_ENTRY_WORD1 0x86e60000 /* or3 r6, r6, #low(.got)+4) */ #define PLT0_ENTRY_WORD1 0x86e60000 /* or3 r6, r6, #low(.got)+4) */
#define PLT0_ENTRY_WORD2 0x24e626c6 /* ld r4, @r6+ -> ld r6, @r6 */ #define PLT0_ENTRY_WORD2 0x24e626c6 /* ld r4, @r6+ -> ld r6, @r6 */
#define PLT0_ENTRY_WORD3 0x1fc6f000 /* jmp r6 || pnop */ #define PLT0_ENTRY_WORD3 0x1fc6f000 /* jmp r6 || pnop */
#define PLT0_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */ #define PLT0_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */
#define PLT0_PIC_ENTRY_WORD0 0xa4cc0004 /* ld r4, @(4,r12) */ #define PLT0_PIC_ENTRY_WORD0 0xa4cc0004 /* ld r4, @(4,r12) */
#define PLT0_PIC_ENTRY_WORD1 0xa6cc0008 /* ld r6, @(8,r12) */ #define PLT0_PIC_ENTRY_WORD1 0xa6cc0008 /* ld r6, @(8,r12) */
#define PLT0_PIC_ENTRY_WORD2 0x1fc6f000 /* jmp r6 || nop */ #define PLT0_PIC_ENTRY_WORD2 0x1fc6f000 /* jmp r6 || nop */
#define PLT0_PIC_ENTRY_WORD3 PLT_EMPTY /* RIE -> RIE */ #define PLT0_PIC_ENTRY_WORD3 PLT_EMPTY /* RIE -> RIE */
#define PLT0_PIC_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */ #define PLT0_PIC_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */
#define PLT_ENTRY_WORD0 0xe6000000 /* ld24 r6, .name_in_GOT */ #define PLT_ENTRY_WORD0 0xe6000000 /* ld24 r6, .name_in_GOT */
#define PLT_ENTRY_WORD1 0x06acf000 /* add r6, r12 || nop */ #define PLT_ENTRY_WORD1 0x06acf000 /* add r6, r12 || nop */
#define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT) */ #define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT) */
@ -1248,7 +1248,7 @@ static const struct m32r_reloc_map m32r_reloc_map[] =
{ BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA }, { BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA },
{ BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT }, { BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT },
{ BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY }, { BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY },
{ BFD_RELOC_M32R_GOT24, R_M32R_GOT24 }, { BFD_RELOC_M32R_GOT24, R_M32R_GOT24 },
{ BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL }, { BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL },
{ BFD_RELOC_M32R_COPY, R_M32R_COPY }, { BFD_RELOC_M32R_COPY, R_M32R_COPY },
@ -1596,7 +1596,7 @@ m32r_elf_link_hash_newfunc (entry, table, string)
{ {
struct elf_m32r_link_hash_entry *ret = struct elf_m32r_link_hash_entry *ret =
(struct elf_m32r_link_hash_entry *) entry; (struct elf_m32r_link_hash_entry *) entry;
/* Allocate the structure if it has not already been allocated by a /* Allocate the structure if it has not already been allocated by a
subclass. */ subclass. */
if (ret == (struct elf_m32r_link_hash_entry *) NULL) if (ret == (struct elf_m32r_link_hash_entry *) NULL)
@ -1605,7 +1605,7 @@ m32r_elf_link_hash_newfunc (entry, table, string)
sizeof (struct elf_m32r_link_hash_entry))); sizeof (struct elf_m32r_link_hash_entry)));
if (ret == (struct elf_m32r_link_hash_entry *) NULL) if (ret == (struct elf_m32r_link_hash_entry *) NULL)
return (struct bfd_hash_entry *) ret; return (struct bfd_hash_entry *) ret;
/* Call the allocation method of the superclass. */ /* Call the allocation method of the superclass. */
ret = ((struct elf_m32r_link_hash_entry *) ret = ((struct elf_m32r_link_hash_entry *)
_bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
@ -1613,13 +1613,13 @@ m32r_elf_link_hash_newfunc (entry, table, string)
if (ret != (struct elf_m32r_link_hash_entry *) NULL) if (ret != (struct elf_m32r_link_hash_entry *) NULL)
{ {
struct elf_m32r_link_hash_entry *eh; struct elf_m32r_link_hash_entry *eh;
eh = (struct elf_m32r_link_hash_entry *) ret; eh = (struct elf_m32r_link_hash_entry *) ret;
eh->dyn_relocs = NULL; eh->dyn_relocs = NULL;
// eh->gotplt_refcount = 0; // eh->gotplt_refcount = 0;
/* eh->pcrel_relocs_copied = NULL; FIXME */ /* eh->pcrel_relocs_copied = NULL; FIXME */
} }
return (struct bfd_hash_entry *) ret; return (struct bfd_hash_entry *) ret;
} }
@ -1632,18 +1632,18 @@ m32r_elf_link_hash_table_create (abfd)
{ {
struct elf_m32r_link_hash_table *ret; struct elf_m32r_link_hash_table *ret;
bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table); bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
ret = (struct elf_m32r_link_hash_table *) bfd_malloc (amt); ret = (struct elf_m32r_link_hash_table *) bfd_malloc (amt);
if (ret == (struct elf_m32r_link_hash_table *) NULL) if (ret == (struct elf_m32r_link_hash_table *) NULL)
return NULL; return NULL;
if (! _bfd_elf_link_hash_table_init (&ret->root, abfd, if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
m32r_elf_link_hash_newfunc)) m32r_elf_link_hash_newfunc))
{ {
free (ret); free (ret);
return NULL; return NULL;
} }
ret->sgot = NULL; ret->sgot = NULL;
ret->sgotplt = NULL; ret->sgotplt = NULL;
ret->srelgot = NULL; ret->srelgot = NULL;
@ -1652,7 +1652,7 @@ m32r_elf_link_hash_table_create (abfd)
ret->sdynbss = NULL; ret->sdynbss = NULL;
ret->srelbss = NULL; ret->srelbss = NULL;
ret->sym_sec.abfd = NULL; ret->sym_sec.abfd = NULL;
return &ret->root.root; return &ret->root.root;
} }
@ -1730,13 +1730,14 @@ m32r_elf_create_dynamic_sections (abfd, info)
{ {
/* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
.plt section. */ .plt section. */
struct elf_link_hash_entry *h = NULL; struct bfd_link_hash_entry *bh = NULL;
struct elf_link_hash_entry *h;
if (! (_bfd_generic_link_add_one_symbol if (! (_bfd_generic_link_add_one_symbol
(info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
(bfd_vma) 0, (const char *) NULL, FALSE, (bfd_vma) 0, (const char *) NULL, FALSE,
get_elf_backend_data (abfd)->collect, get_elf_backend_data (abfd)->collect, &bh)))
(struct bfd_link_hash_entry **) &h)))
return FALSE; return FALSE;
h = (struct elf_link_hash_entry *) bh;
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR; h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
h->type = STT_OBJECT; h->type = STT_OBJECT;
@ -1827,33 +1828,33 @@ m32r_elf_create_dynamic_sections (abfd, info)
static void m32r_elf_copy_indirect_symbol (const struct elf_backend_data *, static void m32r_elf_copy_indirect_symbol (const struct elf_backend_data *,
struct elf_link_hash_entry *, struct elf_link_hash_entry *,
struct elf_link_hash_entry *); struct elf_link_hash_entry *);
static void static void
m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed, m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
struct elf_link_hash_entry *dir, struct elf_link_hash_entry *dir,
struct elf_link_hash_entry *ind) struct elf_link_hash_entry *ind)
{ {
struct elf_m32r_link_hash_entry *edir, *eind; struct elf_m32r_link_hash_entry *edir, *eind;
edir = (struct elf_m32r_link_hash_entry *) dir; edir = (struct elf_m32r_link_hash_entry *) dir;
eind = (struct elf_m32r_link_hash_entry *) ind; eind = (struct elf_m32r_link_hash_entry *) ind;
if (eind->dyn_relocs != NULL) if (eind->dyn_relocs != NULL)
{ {
if (edir->dyn_relocs != NULL) if (edir->dyn_relocs != NULL)
{ {
struct elf_m32r_dyn_relocs **pp; struct elf_m32r_dyn_relocs **pp;
struct elf_m32r_dyn_relocs *p; struct elf_m32r_dyn_relocs *p;
if (ind->root.type == bfd_link_hash_indirect) if (ind->root.type == bfd_link_hash_indirect)
abort (); abort ();
/* Add reloc counts against the weak sym to the strong sym /* Add reloc counts against the weak sym to the strong sym
list. Merge any entries against the same section. */ list. Merge any entries against the same section. */
for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
{ {
struct elf_m32r_dyn_relocs *q; struct elf_m32r_dyn_relocs *q;
for (q = edir->dyn_relocs; q != NULL; q = q->next) for (q = edir->dyn_relocs; q != NULL; q = q->next)
if (q->sec == p->sec) if (q->sec == p->sec)
{ {
@ -1867,11 +1868,11 @@ m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
} }
*pp = edir->dyn_relocs; *pp = edir->dyn_relocs;
} }
edir->dyn_relocs = eind->dyn_relocs; edir->dyn_relocs = eind->dyn_relocs;
eind->dyn_relocs = NULL; eind->dyn_relocs = NULL;
} }
// if (ind->root.type == bfd_link_hash_indirect // if (ind->root.type == bfd_link_hash_indirect
// && dir->got.refcount <= 0) // && dir->got.refcount <= 0)
// { // {
@ -1887,7 +1888,7 @@ m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
dynamic object, but we're not including those sections. We have to dynamic object, but we're not including those sections. We have to
change the definition to something the rest of the link can change the definition to something the rest of the link can
understand. */ understand. */
static bfd_boolean static bfd_boolean
m32r_elf_adjust_dynamic_symbol (info, h) m32r_elf_adjust_dynamic_symbol (info, h)
struct bfd_link_info *info; struct bfd_link_info *info;
@ -1903,9 +1904,9 @@ m32r_elf_adjust_dynamic_symbol (info, h)
#ifdef DEBUG_PIC #ifdef DEBUG_PIC
printf("m32r_elf_adjust_dynamic_symbol()\n"); printf("m32r_elf_adjust_dynamic_symbol()\n");
#endif #endif
dynobj = elf_hash_table (info)->dynobj; dynobj = elf_hash_table (info)->dynobj;
/* Make sure we know what is going on here. */ /* Make sure we know what is going on here. */
BFD_ASSERT (dynobj != NULL BFD_ASSERT (dynobj != NULL
&& ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
@ -1917,7 +1918,7 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
&& (h->elf_link_hash_flags && (h->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR) == 0))); & ELF_LINK_HASH_DEF_REGULAR) == 0)));
/* If this is a function, put it in the procedure linkage table. We /* If this is a function, put it in the procedure linkage table. We
will fill in the contents of the procedure linkage table later, will fill in the contents of the procedure linkage table later,
when we know the address of the .got section. */ when we know the address of the .got section. */
@ -1943,7 +1944,7 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
} }
else else
h->plt.offset = (bfd_vma) -1; h->plt.offset = (bfd_vma) -1;
/* If this is a weak symbol, and there is a real definition, the /* If this is a weak symbol, and there is a real definition, the
processor independent code will have arranged for us to see the processor independent code will have arranged for us to see the
real definition first, and we can just use the same value. */ real definition first, and we can just use the same value. */
@ -1955,17 +1956,17 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
h->root.u.def.value = h->weakdef->root.u.def.value; h->root.u.def.value = h->weakdef->root.u.def.value;
return TRUE; return TRUE;
} }
/* This is a reference to a symbol defined by a dynamic object which /* This is a reference to a symbol defined by a dynamic object which
is not a function. */ is not a function. */
/* If we are creating a shared library, we must presume that the /* If we are creating a shared library, we must presume that the
only references to the symbol are via the global offset table. only references to the symbol are via the global offset table.
For such cases we need not do anything here; the relocations will For such cases we need not do anything here; the relocations will
be handled correctly by relocate_section. */ be handled correctly by relocate_section. */
if (info->shared) if (info->shared)
return TRUE; return TRUE;
/* If there are no references to this symbol that do not use the /* If there are no references to this symbol that do not use the
GOT, we don't need to generate a copy reloc. */ GOT, we don't need to generate a copy reloc. */
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0) if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
@ -2004,11 +2005,11 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
determine the address it must put in the global offset table, so determine the address it must put in the global offset table, so
both the dynamic object and the regular object will refer to the both the dynamic object and the regular object will refer to the
same memory location for the variable. */ same memory location for the variable. */
htab = m32r_elf_hash_table (info); htab = m32r_elf_hash_table (info);
s = htab->sdynbss; s = htab->sdynbss;
BFD_ASSERT (s != NULL); BFD_ASSERT (s != NULL);
/* We must generate a R_M32R_COPY reloc to tell the dynamic linker /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
to copy the initial value out of the dynamic object and into the to copy the initial value out of the dynamic object and into the
runtime process image. We need to remember the offset into the runtime process image. We need to remember the offset into the
@ -2016,19 +2017,19 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
{ {
asection *srel; asection *srel;
srel = htab->srelbss; srel = htab->srelbss;
BFD_ASSERT (srel != NULL); BFD_ASSERT (srel != NULL);
srel->_raw_size += sizeof (Elf32_External_Rela); srel->_raw_size += sizeof (Elf32_External_Rela);
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
} }
/* We need to figure out the alignment required for this symbol. I /* We need to figure out the alignment required for this symbol. I
have no idea how ELF linkers handle this. */ have no idea how ELF linkers handle this. */
power_of_two = bfd_log2 (h->size); power_of_two = bfd_log2 (h->size);
if (power_of_two > 3) if (power_of_two > 3)
power_of_two = 3; power_of_two = 3;
/* Apply the required alignment. */ /* Apply the required alignment. */
s->_raw_size = BFD_ALIGN (s->_raw_size, s->_raw_size = BFD_ALIGN (s->_raw_size,
(bfd_size_type) (1 << power_of_two)); (bfd_size_type) (1 << power_of_two));
@ -2037,14 +2038,14 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
if (! bfd_set_section_alignment (dynobj, s, power_of_two)) if (! bfd_set_section_alignment (dynobj, s, power_of_two))
return FALSE; return FALSE;
} }
/* Define the symbol as being at this point in the section. */ /* Define the symbol as being at this point in the section. */
h->root.u.def.section = s; h->root.u.def.section = s;
h->root.u.def.value = s->_raw_size; h->root.u.def.value = s->_raw_size;
/* Increment the section size to make room for the symbol. */ /* Increment the section size to make room for the symbol. */
s->_raw_size += h->size; s->_raw_size += h->size;
return TRUE; return TRUE;
} }
@ -2061,7 +2062,7 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
/* Allocate space in .plt, .got and associated reloc sections for /* Allocate space in .plt, .got and associated reloc sections for
dynamic relocs. */ dynamic relocs. */
static bfd_boolean static bfd_boolean
allocate_dynrelocs (h, inf) allocate_dynrelocs (h, inf)
struct elf_link_hash_entry *h; struct elf_link_hash_entry *h;
@ -2071,19 +2072,19 @@ allocate_dynrelocs (h, inf)
struct elf_m32r_link_hash_table *htab; struct elf_m32r_link_hash_table *htab;
struct elf_m32r_link_hash_entry *eh; struct elf_m32r_link_hash_entry *eh;
struct elf_m32r_dyn_relocs *p; struct elf_m32r_dyn_relocs *p;
if (h->root.type == bfd_link_hash_indirect) if (h->root.type == bfd_link_hash_indirect)
return TRUE; return TRUE;
if (h->root.type == bfd_link_hash_warning) if (h->root.type == bfd_link_hash_warning)
/* When warning symbols are created, they **replace** the "real" /* When warning symbols are created, they **replace** the "real"
entry in the hash table, thus we never get to see the real entry in the hash table, thus we never get to see the real
symbol in a hash traversal. So look at it now. */ symbol in a hash traversal. So look at it now. */
h = (struct elf_link_hash_entry *) h->root.u.i.link; h = (struct elf_link_hash_entry *) h->root.u.i.link;
info = (struct bfd_link_info *) inf; info = (struct bfd_link_info *) inf;
htab = m32r_elf_hash_table (info); htab = m32r_elf_hash_table (info);
eh = (struct elf_m32r_link_hash_entry *) h; eh = (struct elf_m32r_link_hash_entry *) h;
// if ((h->got.refcount > 0 // if ((h->got.refcount > 0
// || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) // || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
@ -2095,7 +2096,7 @@ allocate_dynrelocs (h, inf)
// if (h->plt.refcount >= eh->gotplt_refcount) // if (h->plt.refcount >= eh->gotplt_refcount)
// h->plt.refcount -= eh->gotplt_refcount; // h->plt.refcount -= eh->gotplt_refcount;
// } // }
if (htab->root.dynamic_sections_created if (htab->root.dynamic_sections_created
&& h->plt.refcount > 0) && h->plt.refcount > 0)
{ {
@ -2107,18 +2108,18 @@ allocate_dynrelocs (h, inf)
if (! bfd_elf32_link_record_dynamic_symbol (info, h)) if (! bfd_elf32_link_record_dynamic_symbol (info, h))
return FALSE; return FALSE;
} }
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h)) if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
{ {
asection *s = htab->splt; asection *s = htab->splt;
/* If this is the first .plt entry, make room for the special /* If this is the first .plt entry, make room for the special
first entry. */ first entry. */
if (s->_raw_size == 0) if (s->_raw_size == 0)
s->_raw_size += PLT_ENTRY_SIZE; s->_raw_size += PLT_ENTRY_SIZE;
h->plt.offset = s->_raw_size; h->plt.offset = s->_raw_size;
/* If this symbol is not defined in a regular file, and we are /* If this symbol is not defined in a regular file, and we are
not generating a shared library, then set the symbol to this not generating a shared library, then set the symbol to this
location in the .plt. This is required to make function location in the .plt. This is required to make function
@ -2130,14 +2131,14 @@ allocate_dynrelocs (h, inf)
h->root.u.def.section = s; h->root.u.def.section = s;
h->root.u.def.value = h->plt.offset; h->root.u.def.value = h->plt.offset;
} }
/* Make room for this entry. */ /* Make room for this entry. */
s->_raw_size += PLT_ENTRY_SIZE; s->_raw_size += PLT_ENTRY_SIZE;
/* We also need to make an entry in the .got.plt section, which /* We also need to make an entry in the .got.plt section, which
will be placed in the .got section by the linker script. */ will be placed in the .got section by the linker script. */
htab->sgotplt->_raw_size += 4; htab->sgotplt->_raw_size += 4;
/* We also need to make an entry in the .rel.plt section. */ /* We also need to make an entry in the .rel.plt section. */
htab->srelplt->_raw_size += sizeof (Elf32_External_Rela); htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
} }
@ -2152,12 +2153,12 @@ allocate_dynrelocs (h, inf)
h->plt.offset = (bfd_vma) -1; h->plt.offset = (bfd_vma) -1;
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
} }
if (h->got.refcount > 0) if (h->got.refcount > 0)
{ {
asection *s; asection *s;
bfd_boolean dyn; bfd_boolean dyn;
/* Make sure this symbol is output as a dynamic symbol. /* Make sure this symbol is output as a dynamic symbol.
Undefined weak syms won't yet be marked as dynamic. */ Undefined weak syms won't yet be marked as dynamic. */
if (h->dynindx == -1 if (h->dynindx == -1
@ -2166,7 +2167,7 @@ allocate_dynrelocs (h, inf)
if (! bfd_elf32_link_record_dynamic_symbol (info, h)) if (! bfd_elf32_link_record_dynamic_symbol (info, h))
return FALSE; return FALSE;
} }
s = htab->sgot; s = htab->sgot;
h->got.offset = s->_raw_size; h->got.offset = s->_raw_size;
@ -2177,10 +2178,10 @@ allocate_dynrelocs (h, inf)
} }
else else
h->got.offset = (bfd_vma) -1; h->got.offset = (bfd_vma) -1;
if (eh->dyn_relocs == NULL) if (eh->dyn_relocs == NULL)
return TRUE; return TRUE;
/* In the shared -Bsymbolic case, discard space allocated for /* In the shared -Bsymbolic case, discard space allocated for
dynamic pc-relative relocs against symbols which turn out to be dynamic pc-relative relocs against symbols which turn out to be
defined in regular objects. For the normal shared case, discard defined in regular objects. For the normal shared case, discard
@ -2210,7 +2211,7 @@ allocate_dynrelocs (h, inf)
/* For the non-shared case, discard space for relocs against /* For the non-shared case, discard space for relocs against
symbols which turn out to need copy relocs or are not symbols which turn out to need copy relocs or are not
dynamic. */ dynamic. */
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
&& (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
@ -2226,29 +2227,29 @@ allocate_dynrelocs (h, inf)
if (! bfd_elf32_link_record_dynamic_symbol (info, h)) if (! bfd_elf32_link_record_dynamic_symbol (info, h))
return FALSE; return FALSE;
} }
/* If that succeeded, we know we'll be keeping all the /* If that succeeded, we know we'll be keeping all the
relocs. */ relocs. */
if (h->dynindx != -1) if (h->dynindx != -1)
goto keep; goto keep;
} }
eh->dyn_relocs = NULL; eh->dyn_relocs = NULL;
keep: ; keep: ;
} }
/* Finally, allocate space. */ /* Finally, allocate space. */
for (p = eh->dyn_relocs; p != NULL; p = p->next) for (p = eh->dyn_relocs; p != NULL; p = p->next)
{ {
asection *sreloc = elf_section_data (p->sec)->sreloc; asection *sreloc = elf_section_data (p->sec)->sreloc;
sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela); sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
} }
return TRUE; return TRUE;
} }
/* Find any dynamic relocs that apply to read-only sections. */ /* Find any dynamic relocs that apply to read-only sections. */
static bfd_boolean static bfd_boolean
readonly_dynrelocs (h, inf) readonly_dynrelocs (h, inf)
struct elf_link_hash_entry *h; struct elf_link_hash_entry *h;
@ -2279,7 +2280,7 @@ readonly_dynrelocs (h, inf)
} }
/* Set the sizes of the dynamic sections. */ /* Set the sizes of the dynamic sections. */
static bfd_boolean static bfd_boolean
m32r_elf_size_dynamic_sections (output_bfd, info) m32r_elf_size_dynamic_sections (output_bfd, info)
bfd *output_bfd ATTRIBUTE_UNUSED; bfd *output_bfd ATTRIBUTE_UNUSED;
@ -2541,7 +2542,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
dynobj = htab->root.dynobj; dynobj = htab->root.dynobj;
local_got_offsets = elf_local_got_offsets (input_bfd); local_got_offsets = elf_local_got_offsets (input_bfd);
sgot = htab->sgot; sgot = htab->sgot;
splt = htab->splt; splt = htab->splt;
sreloc = NULL; sreloc = NULL;
@ -2681,7 +2682,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
section symbol winds up in the output section. */ section symbol winds up in the output section. */
if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
rel->r_addend += sec->output_offset + sym->st_value; rel->r_addend += sec->output_offset + sym->st_value;
continue; continue;
} }
} }
@ -2744,7 +2745,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
|| r_type == R_M32R_26_PCREL_RELA) || r_type == R_M32R_26_PCREL_RELA)
&& ((input_section->flags & SEC_ALLOC) != 0 && ((input_section->flags & SEC_ALLOC) != 0
/* DWARF will emit R_M32R_16(24,32) relocations /* DWARF will emit R_M32R_16(24,32) relocations
in its sections against symbols defined in its sections against symbols defined
externally in shared libraries. We can't do externally in shared libraries. We can't do
anything with them here. */ anything with them here. */
|| ((input_section->flags & SEC_DEBUGGING) != 0 || ((input_section->flags & SEC_DEBUGGING) != 0
@ -2781,7 +2782,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
if (! ((*info->callbacks->undefined_symbol) if (! ((*info->callbacks->undefined_symbol)
(info, h->root.root.string, input_bfd, (info, h->root.root.string, input_bfd,
input_section, offset, input_section, offset,
(!info->shared (!info->shared
|| ELF_ST_VISIBILITY (h->other))))) || ELF_ST_VISIBILITY (h->other)))))
return FALSE; return FALSE;
relocation = 0; relocation = 0;
@ -2806,7 +2807,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
case R_M32R_GOTPC_HI_ULO: case R_M32R_GOTPC_HI_ULO:
case R_M32R_GOTPC_HI_SLO: case R_M32R_GOTPC_HI_SLO:
case R_M32R_GOTPC_LO: case R_M32R_GOTPC_LO:
{ {
/* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
bl .+4 bl .+4
@ -2821,7 +2822,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
relocation -= (input_section->output_section->vma relocation -= (input_section->output_section->vma
+ input_section->output_offset + input_section->output_offset
+ rel->r_offset); + rel->r_offset);
if ((r_type == R_M32R_GOTPC_HI_SLO) if ((r_type == R_M32R_GOTPC_HI_SLO)
&& ((relocation + rel->r_addend) & 0x8000)) && ((relocation + rel->r_addend) & 0x8000))
rel->r_addend += 0x10000; rel->r_addend += 0x10000;
@ -2829,18 +2830,18 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
} }
case R_M32R_GOT16_HI_ULO: case R_M32R_GOT16_HI_ULO:
case R_M32R_GOT16_HI_SLO: case R_M32R_GOT16_HI_SLO:
case R_M32R_GOT16_LO: case R_M32R_GOT16_LO:
/* Fall through. */ /* Fall through. */
case R_M32R_GOT24: case R_M32R_GOT24:
/* Relocation is to the entry for this symbol in the global /* Relocation is to the entry for this symbol in the global
offset table. */ offset table. */
BFD_ASSERT (sgot != NULL); BFD_ASSERT (sgot != NULL);
if (h != NULL) if (h != NULL)
{ {
bfd_boolean dyn; bfd_boolean dyn;
bfd_vma off; bfd_vma off;
off = h->got.offset; off = h->got.offset;
BFD_ASSERT (off != (bfd_vma) -1); BFD_ASSERT (off != (bfd_vma) -1);
@ -2860,7 +2861,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
offset must always be a multiple of 4, we use the offset must always be a multiple of 4, we use the
least significant bit to record whether we have least significant bit to record whether we have
initialized it already. initialized it already.
When doing a dynamic link, we create a .rela.got When doing a dynamic link, we create a .rela.got
relocation entry to initialize the value. This relocation entry to initialize the value. This
is done in the finish_dynamic_symbol routine. */ is done in the finish_dynamic_symbol routine. */
@ -2873,19 +2874,19 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
h->got.offset |= 1; h->got.offset |= 1;
} }
} }
relocation = sgot->output_offset + off; relocation = sgot->output_offset + off;
} }
else else
{ {
bfd_vma off; bfd_vma off;
bfd_byte *loc; bfd_byte *loc;
BFD_ASSERT (local_got_offsets != NULL BFD_ASSERT (local_got_offsets != NULL
&& local_got_offsets[r_symndx] != (bfd_vma) -1); && local_got_offsets[r_symndx] != (bfd_vma) -1);
off = local_got_offsets[r_symndx]; off = local_got_offsets[r_symndx];
/* The offset must always be a multiple of 4. We use /* The offset must always be a multiple of 4. We use
the least significant bit to record whether we have the least significant bit to record whether we have
already processed this entry. */ already processed this entry. */
@ -2894,17 +2895,17 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
else else
{ {
bfd_put_32 (output_bfd, relocation, sgot->contents + off); bfd_put_32 (output_bfd, relocation, sgot->contents + off);
if (info->shared) if (info->shared)
{ {
asection *srelgot; asection *srelgot;
Elf_Internal_Rela outrel; Elf_Internal_Rela outrel;
/* We need to generate a R_M32R_RELATIVE reloc /* We need to generate a R_M32R_RELATIVE reloc
for the dynamic linker. */ for the dynamic linker. */
srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
BFD_ASSERT (srelgot != NULL); BFD_ASSERT (srelgot != NULL);
outrel.r_offset = (sgot->output_section->vma outrel.r_offset = (sgot->output_section->vma
+ sgot->output_offset + sgot->output_offset
+ off); + off);
@ -2915,10 +2916,10 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc); bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
++srelgot->reloc_count; ++srelgot->reloc_count;
} }
local_got_offsets[r_symndx] |= 1; local_got_offsets[r_symndx] |= 1;
} }
relocation = sgot->output_offset + off; relocation = sgot->output_offset + off;
} }
if ((r_type == R_M32R_GOT16_HI_SLO) if ((r_type == R_M32R_GOT16_HI_SLO)
@ -2926,11 +2927,11 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
rel->r_addend += 0x10000; rel->r_addend += 0x10000;
break; break;
case R_M32R_26_PLTREL: case R_M32R_26_PLTREL:
/* Relocation is to the entry for this symbol in the /* Relocation is to the entry for this symbol in the
procedure linkage table. */ procedure linkage table. */
/* The native assembler will generate a 26_PLTREL reloc /* The native assembler will generate a 26_PLTREL reloc
for a local symbol if you assemble a call from one for a local symbol if you assemble a call from one
section to another when using -K pic. */ section to another when using -K pic. */
@ -2950,12 +2951,12 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
using -Bsymbolic. */ using -Bsymbolic. */
break; break;
} }
relocation = (splt->output_section->vma relocation = (splt->output_section->vma
+ splt->output_offset + splt->output_offset
+ h->plt.offset); + h->plt.offset);
break; break;
case R_M32R_HI16_SLO_RELA: case R_M32R_HI16_SLO_RELA:
{ {
if ((relocation + rel->r_addend) & 0x8000) if ((relocation + rel->r_addend) & 0x8000)
@ -2986,34 +2987,34 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
Elf_Internal_Rela outrel; Elf_Internal_Rela outrel;
bfd_boolean skip, relocate; bfd_boolean skip, relocate;
bfd_byte *loc; bfd_byte *loc;
/* When generating a shared object, these relocations /* When generating a shared object, these relocations
are copied into the output file to be resolved at run are copied into the output file to be resolved at run
time. */ time. */
if (sreloc == NULL) if (sreloc == NULL)
{ {
const char *name; const char *name;
name = (bfd_elf_string_from_elf_section name = (bfd_elf_string_from_elf_section
(input_bfd, (input_bfd,
elf_elfheader (input_bfd)->e_shstrndx, elf_elfheader (input_bfd)->e_shstrndx,
elf_section_data (input_section)->rel_hdr.sh_name)); elf_section_data (input_section)->rel_hdr.sh_name));
if (name == NULL) if (name == NULL)
return FALSE; return FALSE;
BFD_ASSERT (strncmp (name, ".rela", 5) == 0 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
&& strcmp (bfd_get_section_name (input_bfd, && strcmp (bfd_get_section_name (input_bfd,
input_section), input_section),
name + 5) == 0); name + 5) == 0);
sreloc = bfd_get_section_by_name (dynobj, name); sreloc = bfd_get_section_by_name (dynobj, name);
BFD_ASSERT (sreloc != NULL); BFD_ASSERT (sreloc != NULL);
} }
skip = FALSE; skip = FALSE;
relocate = FALSE; relocate = FALSE;
outrel.r_offset = _bfd_elf_section_offset (output_bfd, outrel.r_offset = _bfd_elf_section_offset (output_bfd,
info, info,
input_section, input_section,
@ -3024,7 +3025,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
skip = TRUE, relocate = TRUE; skip = TRUE, relocate = TRUE;
outrel.r_offset += (input_section->output_section->vma outrel.r_offset += (input_section->output_section->vma
+ input_section->output_offset); + input_section->output_offset);
if (skip) if (skip)
memset (&outrel, 0, sizeof outrel); memset (&outrel, 0, sizeof outrel);
else if (r_type == R_M32R_18_PCREL_RELA else if (r_type == R_M32R_18_PCREL_RELA
@ -3068,7 +3069,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
continue; continue;
} }
break; break;
case (int) R_M32R_10_PCREL : case (int) R_M32R_10_PCREL :
r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section, r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
contents, offset, contents, offset,
@ -3238,11 +3239,11 @@ m32r_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
struct elf_m32r_link_hash_table *htab; struct elf_m32r_link_hash_table *htab;
bfd *dynobj; bfd *dynobj;
bfd_byte *loc; bfd_byte *loc;
#ifdef DEBUG_PIC #ifdef DEBUG_PIC
printf("m32r_elf_finish_dynamic_symbol()\n"); printf("m32r_elf_finish_dynamic_symbol()\n");
#endif #endif
htab = m32r_elf_hash_table (info); htab = m32r_elf_hash_table (info);
dynobj = htab->root.dynobj; dynobj = htab->root.dynobj;
@ -3255,12 +3256,12 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
bfd_vma plt_index; bfd_vma plt_index;
bfd_vma got_offset; bfd_vma got_offset;
Elf_Internal_Rela rela; Elf_Internal_Rela rela;
/* This symbol has an entry in the procedure linkage table. Set /* This symbol has an entry in the procedure linkage table. Set
it up. */ it up. */
BFD_ASSERT (h->dynindx != -1); BFD_ASSERT (h->dynindx != -1);
splt = htab->splt; splt = htab->splt;
sgot = htab->sgotplt; sgot = htab->sgotplt;
srela = htab->srelplt; srela = htab->srelplt;
@ -3321,7 +3322,7 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
+ (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)), + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
splt->contents + h->plt.offset + 16); splt->contents + h->plt.offset + 16);
} }
/* Fill in the entry in the global offset table. */ /* Fill in the entry in the global offset table. */
bfd_put_32 (output_bfd, bfd_put_32 (output_bfd,
(splt->output_section->vma (splt->output_section->vma
@ -3339,7 +3340,7 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
loc = srela->contents; loc = srela->contents;
loc += plt_index * sizeof(Elf32_External_Rela); loc += plt_index * sizeof(Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
{ {
/* Mark the symbol as undefined, rather than as defined in /* Mark the symbol as undefined, rather than as defined in
@ -3353,18 +3354,18 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
asection *sgot; asection *sgot;
asection *srela; asection *srela;
Elf_Internal_Rela rela; Elf_Internal_Rela rela;
/* This symbol has an entry in the global offset table. Set it /* This symbol has an entry in the global offset table. Set it
up. */ up. */
sgot = htab->sgot; sgot = htab->sgot;
srela = htab->srelgot; srela = htab->srelgot;
BFD_ASSERT (sgot != NULL && srela != NULL); BFD_ASSERT (sgot != NULL && srela != NULL);
rela.r_offset = (sgot->output_section->vma rela.r_offset = (sgot->output_section->vma
+ sgot->output_offset + sgot->output_offset
+ (h->got.offset &~ 1)); + (h->got.offset &~ 1));
/* If this is a -Bsymbolic link, and the symbol is defined /* If this is a -Bsymbolic link, and the symbol is defined
locally, we just want to emit a RELATIVE reloc. Likewise if locally, we just want to emit a RELATIVE reloc. Likewise if
the symbol was forced to be local because of a version file. the symbol was forced to be local because of a version file.
@ -3388,28 +3389,28 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT); rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
rela.r_addend = 0; rela.r_addend = 0;
} }
loc = srela->contents; loc = srela->contents;
loc += srela->reloc_count * sizeof(Elf32_External_Rela); loc += srela->reloc_count * sizeof(Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
++srela->reloc_count; ++srela->reloc_count;
} }
if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
{ {
asection *s; asection *s;
Elf_Internal_Rela rela; Elf_Internal_Rela rela;
/* This symbols needs a copy reloc. Set it up. */ /* This symbols needs a copy reloc. Set it up. */
BFD_ASSERT (h->dynindx != -1 BFD_ASSERT (h->dynindx != -1
&& (h->root.type == bfd_link_hash_defined && (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)); || h->root.type == bfd_link_hash_defweak));
s = bfd_get_section_by_name (h->root.u.def.section->owner, s = bfd_get_section_by_name (h->root.u.def.section->owner,
".rela.bss"); ".rela.bss");
BFD_ASSERT (s != NULL); BFD_ASSERT (s != NULL);
rela.r_offset = (h->root.u.def.value rela.r_offset = (h->root.u.def.value
+ h->root.u.def.section->output_section->vma + h->root.u.def.section->output_section->vma
+ h->root.u.def.section->output_offset); + h->root.u.def.section->output_offset);
@ -3420,18 +3421,18 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
++s->reloc_count; ++s->reloc_count;
} }
/* Mark some specially defined symbols as absolute. */ /* Mark some specially defined symbols as absolute. */
if (strcmp (h->root.root.string, "_DYNAMIC") == 0 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
|| strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
sym->st_shndx = SHN_ABS; sym->st_shndx = SHN_ABS;
return TRUE; return TRUE;
} }
/* Finish up the dynamic sections. */ /* Finish up the dynamic sections. */
static bfd_boolean static bfd_boolean
m32r_elf_finish_dynamic_sections (output_bfd, info) m32r_elf_finish_dynamic_sections (output_bfd, info)
bfd *output_bfd; bfd *output_bfd;
@ -3445,20 +3446,20 @@ m32r_elf_finish_dynamic_sections (output_bfd, info)
#ifdef DEBUG_PIC #ifdef DEBUG_PIC
printf("m32r_elf_finish_dynamic_sections()\n"); printf("m32r_elf_finish_dynamic_sections()\n");
#endif #endif
htab = m32r_elf_hash_table (info); htab = m32r_elf_hash_table (info);
dynobj = htab->root.dynobj; dynobj = htab->root.dynobj;
sgot = htab->sgotplt; sgot = htab->sgotplt;
sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
if (htab->root.dynamic_sections_created) if (htab->root.dynamic_sections_created)
{ {
asection *splt; asection *splt;
Elf32_External_Dyn *dyncon, *dynconend; Elf32_External_Dyn *dyncon, *dynconend;
BFD_ASSERT (sgot != NULL && sdyn != NULL); BFD_ASSERT (sgot != NULL && sdyn != NULL);
dyncon = (Elf32_External_Dyn *) sdyn->contents; dyncon = (Elf32_External_Dyn *) sdyn->contents;
dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
@ -3467,9 +3468,9 @@ printf("m32r_elf_finish_dynamic_sections()\n");
Elf_Internal_Dyn dyn; Elf_Internal_Dyn dyn;
const char *name; const char *name;
asection *s; asection *s;
bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
switch (dyn.d_tag) switch (dyn.d_tag)
{ {
default: default:
@ -3477,7 +3478,7 @@ printf("m32r_elf_finish_dynamic_sections()\n");
case DT_PLTGOT: case DT_PLTGOT:
name = ".got"; name = ".got";
s = htab->sgot->output_section; s = htab->sgot->output_section;
goto get_vma; goto get_vma;
case DT_JMPREL: case DT_JMPREL:
name = ".rela.plt"; name = ".rela.plt";
@ -3520,7 +3521,7 @@ printf("m32r_elf_finish_dynamic_sections()\n");
break; break;
} }
} }
/* Fill in the first entry in the procedure linkage table. */ /* Fill in the first entry in the procedure linkage table. */
splt = htab->splt; splt = htab->splt;
if (splt && splt->_raw_size > 0) if (splt && splt->_raw_size > 0)
@ -3541,7 +3542,7 @@ printf("m32r_elf_finish_dynamic_sections()\n");
bfd_put_32 (output_bfd, bfd_put_32 (output_bfd,
PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff), PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
splt->contents); splt->contents);
bfd_put_32 (output_bfd, bfd_put_32 (output_bfd,
PLT0_ENTRY_WORD1 | (addr & 0xffff), PLT0_ENTRY_WORD1 | (addr & 0xffff),
splt->contents + 4); splt->contents + 4);
bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8); bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
@ -3568,7 +3569,7 @@ printf("m32r_elf_finish_dynamic_sections()\n");
elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
} }
return TRUE; return TRUE;
} }
@ -4473,7 +4474,7 @@ m32r_elf_check_relocs (abfd, info, sec, relocs)
{ {
case R_M32R_GOT16_HI_ULO: case R_M32R_GOT16_HI_ULO:
case R_M32R_GOT16_HI_SLO: case R_M32R_GOT16_HI_SLO:
case R_M32R_GOT16_LO: case R_M32R_GOT16_LO:
case R_M32R_GOT24: case R_M32R_GOT24:
if (h != NULL) if (h != NULL)
@ -4507,7 +4508,7 @@ m32r_elf_check_relocs (abfd, info, sec, relocs)
because this might be a case of linking PIC code without because this might be a case of linking PIC code without
linking in any dynamic objects, in which case we don't linking in any dynamic objects, in which case we don't
need to generate a procedure linkage table after all. */ need to generate a procedure linkage table after all. */
/* If this is a local symbol, we resolve it directly without /* If this is a local symbol, we resolve it directly without
creating a procedure linkage table entry. */ creating a procedure linkage table entry. */
if (h == NULL) if (h == NULL)
@ -4583,23 +4584,23 @@ m32r_elf_check_relocs (abfd, info, sec, relocs)
if (sreloc == NULL) if (sreloc == NULL)
{ {
const char *name; const char *name;
name = (bfd_elf_string_from_elf_section name = (bfd_elf_string_from_elf_section
(abfd, (abfd,
elf_elfheader (abfd)->e_shstrndx, elf_elfheader (abfd)->e_shstrndx,
elf_section_data (sec)->rel_hdr.sh_name)); elf_section_data (sec)->rel_hdr.sh_name));
if (name == NULL) if (name == NULL)
return FALSE; return FALSE;
BFD_ASSERT (strncmp (name, ".rela", 5) == 0 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
&& strcmp (bfd_get_section_name (abfd, sec), && strcmp (bfd_get_section_name (abfd, sec),
name + 5) == 0); name + 5) == 0);
sreloc = bfd_get_section_by_name (dynobj, name); sreloc = bfd_get_section_by_name (dynobj, name);
if (sreloc == NULL) if (sreloc == NULL)
{ {
flagword flags; flagword flags;
sreloc = bfd_make_section (dynobj, name); sreloc = bfd_make_section (dynobj, name);
flags = (SEC_HAS_CONTENTS | SEC_READONLY flags = (SEC_HAS_CONTENTS | SEC_READONLY
| SEC_IN_MEMORY | SEC_LINKER_CREATED); | SEC_IN_MEMORY | SEC_LINKER_CREATED);
@ -4612,7 +4613,7 @@ m32r_elf_check_relocs (abfd, info, sec, relocs)
} }
elf_section_data (sec)->sreloc = sreloc; elf_section_data (sec)->sreloc = sreloc;
} }
/* If this is a global symbol, we count the number of /* If this is a global symbol, we count the number of
relocations we need for this symbol. */ relocations we need for this symbol. */
if (h != NULL) if (h != NULL)