From: Alan Modra Date: Tue, 16 Mar 2004 01:49:30 +0000 (+0000) Subject: * elf32-m32r.c (m32r_elf_create_dynamic_sections): Fix pointer X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=419783084d0c052f6111401342f791031564ebe4;p=binutils-gdb.git * elf32-m32r.c (m32r_elf_create_dynamic_sections): Fix pointer aliasing warning. Remove trailing whitespace throughout file. --- diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 5bf374577fd..6ea8786e6b7 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,8 @@ +2004-03-16 Alan Modra + + * elf32-m32r.c (m32r_elf_create_dynamic_sections): Fix pointer + aliasing warning. Remove trailing whitespace throughout file. + 2004-03-15 John David Anglin * elf-hppa.h (elf_hppa_relocate_section): Pass input_bfd instead of diff --git a/bfd/elf32-m32r.c b/bfd/elf32-m32r.c index 3edf4a9738f..3f5fbcaeaa1 100644 --- a/bfd/elf32-m32r.c +++ b/bfd/elf32-m32r.c @@ -1,5 +1,5 @@ /* 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. 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 PARAMS ((bfd *, struct bfd_link_info *)); - + static bfd_boolean m32r_elf_finish_dynamic_symbol PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, Elf_Internal_Sym *)); - + static bfd_boolean allocate_dynrelocs PARAMS ((struct elf_link_hash_entry *, PTR)); 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. */ /* Functions for the M32R ELF linker. */ - + /* The name of the dynamic interpreter. This is put in the .interp section. */ - + #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" - + /* The nop opcode we use. */ - + #define M32R_NOP 0x7000f000 - + #define PLT_EMPTY 0x10101010 /* RIE -> RIE */ - + /* The size in bytes of an entry in the procedure linkage table. */ #define PLT_ENTRY_SIZE 20 #define PLT_HEADER_SIZE 20 - + /* The first one entries in a procedure linkage table are reserved, and the initial contents are unimportant (we zero them out). Subsequent entries look like this. */ - + #define PLT0_ENTRY_WORD0 0xd6c00000 /* seth r6, #high(.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_WORD3 0x1fc6f000 /* jmp r6 || pnop */ #define PLT0_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */ - + #define PLT0_PIC_ENTRY_WORD0 0xa4cc0004 /* ld r4, @(4,r12) */ #define PLT0_PIC_ENTRY_WORD1 0xa6cc0008 /* ld r6, @(8,r12) */ #define PLT0_PIC_ENTRY_WORD2 0x1fc6f000 /* jmp r6 || nop */ #define PLT0_PIC_ENTRY_WORD3 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_WORD1 0x06acf000 /* add r6, r12 || nop */ #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_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT }, { BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY }, - + { BFD_RELOC_M32R_GOT24, R_M32R_GOT24 }, { BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL }, { 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 *) entry; - + /* Allocate the structure if it has not already been allocated by a subclass. */ 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))); if (ret == (struct elf_m32r_link_hash_entry *) NULL) return (struct bfd_hash_entry *) ret; - + /* Call the allocation method of the superclass. */ ret = ((struct elf_m32r_link_hash_entry *) _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) { struct elf_m32r_link_hash_entry *eh; - + eh = (struct elf_m32r_link_hash_entry *) ret; eh->dyn_relocs = NULL; // eh->gotplt_refcount = 0; /* eh->pcrel_relocs_copied = NULL; FIXME */ } - + return (struct bfd_hash_entry *) ret; } @@ -1632,18 +1632,18 @@ m32r_elf_link_hash_table_create (abfd) { struct elf_m32r_link_hash_table *ret; bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table); - + ret = (struct elf_m32r_link_hash_table *) bfd_malloc (amt); if (ret == (struct elf_m32r_link_hash_table *) NULL) return NULL; - + if (! _bfd_elf_link_hash_table_init (&ret->root, abfd, m32r_elf_link_hash_newfunc)) { free (ret); return NULL; } - + ret->sgot = NULL; ret->sgotplt = NULL; ret->srelgot = NULL; @@ -1652,7 +1652,7 @@ m32r_elf_link_hash_table_create (abfd) ret->sdynbss = NULL; ret->srelbss = NULL; ret->sym_sec.abfd = NULL; - + 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 .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 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, (bfd_vma) 0, (const char *) NULL, FALSE, - get_elf_backend_data (abfd)->collect, - (struct bfd_link_hash_entry **) &h))) + get_elf_backend_data (abfd)->collect, &bh))) return FALSE; + h = (struct elf_link_hash_entry *) bh; h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR; 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 *, struct elf_link_hash_entry *, struct elf_link_hash_entry *); - + static void m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed, struct elf_link_hash_entry *dir, struct elf_link_hash_entry *ind) { struct elf_m32r_link_hash_entry *edir, *eind; - + edir = (struct elf_m32r_link_hash_entry *) dir; eind = (struct elf_m32r_link_hash_entry *) ind; - + if (eind->dyn_relocs != NULL) { if (edir->dyn_relocs != NULL) { struct elf_m32r_dyn_relocs **pp; struct elf_m32r_dyn_relocs *p; - + if (ind->root.type == bfd_link_hash_indirect) abort (); - + /* Add reloc counts against the weak sym to the strong sym list. Merge any entries against the same section. */ for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) { struct elf_m32r_dyn_relocs *q; - + for (q = edir->dyn_relocs; q != NULL; q = q->next) if (q->sec == p->sec) { @@ -1867,11 +1868,11 @@ m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed, } *pp = edir->dyn_relocs; } - + edir->dyn_relocs = eind->dyn_relocs; eind->dyn_relocs = NULL; } - + // if (ind->root.type == bfd_link_hash_indirect // && 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 change the definition to something the rest of the link can understand. */ - + static bfd_boolean m32r_elf_adjust_dynamic_symbol (info, h) struct bfd_link_info *info; @@ -1903,9 +1904,9 @@ m32r_elf_adjust_dynamic_symbol (info, h) #ifdef DEBUG_PIC printf("m32r_elf_adjust_dynamic_symbol()\n"); #endif - + dynobj = elf_hash_table (info)->dynobj; - + /* Make sure we know what is going on here. */ BFD_ASSERT (dynobj != NULL && ((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 & ELF_LINK_HASH_DEF_REGULAR) == 0))); - + /* If this is a function, put it in the procedure linkage table. We will fill in the contents of the procedure linkage table later, when we know the address of the .got section. */ @@ -1943,7 +1944,7 @@ printf("m32r_elf_adjust_dynamic_symbol()\n"); } else h->plt.offset = (bfd_vma) -1; - + /* If this is a weak symbol, and there is a real definition, the processor independent code will have arranged for us to see the 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; return TRUE; } - + /* This is a reference to a symbol defined by a dynamic object which is not a function. */ - + /* If we are creating a shared library, we must presume that the only references to the symbol are via the global offset table. For such cases we need not do anything here; the relocations will be handled correctly by relocate_section. */ if (info->shared) return TRUE; - + /* If there are no references to this symbol that do not use the GOT, we don't need to generate a copy reloc. */ 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 both the dynamic object and the regular object will refer to the same memory location for the variable. */ - + htab = m32r_elf_hash_table (info); s = htab->sdynbss; BFD_ASSERT (s != NULL); - + /* 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 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) { asection *srel; - + srel = htab->srelbss; BFD_ASSERT (srel != NULL); srel->_raw_size += sizeof (Elf32_External_Rela); h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; } - + /* We need to figure out the alignment required for this symbol. I have no idea how ELF linkers handle this. */ power_of_two = bfd_log2 (h->size); if (power_of_two > 3) power_of_two = 3; - + /* Apply the required alignment. */ s->_raw_size = BFD_ALIGN (s->_raw_size, (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)) return FALSE; } - + /* Define the symbol as being at this point in the section. */ h->root.u.def.section = s; h->root.u.def.value = s->_raw_size; - + /* Increment the section size to make room for the symbol. */ s->_raw_size += h->size; - + return TRUE; } @@ -2061,7 +2062,7 @@ printf("m32r_elf_adjust_dynamic_symbol()\n"); /* Allocate space in .plt, .got and associated reloc sections for dynamic relocs. */ - + static bfd_boolean allocate_dynrelocs (h, inf) 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_entry *eh; struct elf_m32r_dyn_relocs *p; - + if (h->root.type == bfd_link_hash_indirect) return TRUE; - + if (h->root.type == bfd_link_hash_warning) /* When warning symbols are created, they **replace** 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. */ h = (struct elf_link_hash_entry *) h->root.u.i.link; - + info = (struct bfd_link_info *) inf; htab = m32r_elf_hash_table (info); - + eh = (struct elf_m32r_link_hash_entry *) h; // if ((h->got.refcount > 0 // || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) @@ -2095,7 +2096,7 @@ allocate_dynrelocs (h, inf) // if (h->plt.refcount >= eh->gotplt_refcount) // h->plt.refcount -= eh->gotplt_refcount; // } - + if (htab->root.dynamic_sections_created && h->plt.refcount > 0) { @@ -2107,18 +2108,18 @@ allocate_dynrelocs (h, inf) if (! bfd_elf32_link_record_dynamic_symbol (info, h)) return FALSE; } - + if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h)) { asection *s = htab->splt; - + /* If this is the first .plt entry, make room for the special first entry. */ if (s->_raw_size == 0) s->_raw_size += PLT_ENTRY_SIZE; - + h->plt.offset = s->_raw_size; - + /* If this symbol is not defined in a regular file, and we are not generating a shared library, then set the symbol to this 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.value = h->plt.offset; } - + /* Make room for this entry. */ s->_raw_size += PLT_ENTRY_SIZE; - + /* We also need to make an entry in the .got.plt section, which will be placed in the .got section by the linker script. */ htab->sgotplt->_raw_size += 4; - + /* We also need to make an entry in the .rel.plt section. */ htab->srelplt->_raw_size += sizeof (Elf32_External_Rela); } @@ -2152,12 +2153,12 @@ allocate_dynrelocs (h, inf) h->plt.offset = (bfd_vma) -1; h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; } - + if (h->got.refcount > 0) { asection *s; bfd_boolean dyn; - + /* Make sure this symbol is output as a dynamic symbol. Undefined weak syms won't yet be marked as dynamic. */ if (h->dynindx == -1 @@ -2166,7 +2167,7 @@ allocate_dynrelocs (h, inf) if (! bfd_elf32_link_record_dynamic_symbol (info, h)) return FALSE; } - + s = htab->sgot; h->got.offset = s->_raw_size; @@ -2177,10 +2178,10 @@ allocate_dynrelocs (h, inf) } else h->got.offset = (bfd_vma) -1; - + if (eh->dyn_relocs == NULL) return TRUE; - + /* In the shared -Bsymbolic case, discard space allocated for dynamic pc-relative relocs against symbols which turn out to be 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 symbols which turn out to need copy relocs or are not dynamic. */ - + 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_REGULAR) == 0) @@ -2226,29 +2227,29 @@ allocate_dynrelocs (h, inf) if (! bfd_elf32_link_record_dynamic_symbol (info, h)) return FALSE; } - + /* If that succeeded, we know we'll be keeping all the relocs. */ if (h->dynindx != -1) goto keep; } - + eh->dyn_relocs = NULL; - + keep: ; } - + /* Finally, allocate space. */ for (p = eh->dyn_relocs; p != NULL; p = p->next) { asection *sreloc = elf_section_data (p->sec)->sreloc; sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela); } - + return TRUE; } /* Find any dynamic relocs that apply to read-only sections. */ - + static bfd_boolean readonly_dynrelocs (h, inf) struct elf_link_hash_entry *h; @@ -2279,7 +2280,7 @@ readonly_dynrelocs (h, inf) } /* Set the sizes of the dynamic sections. */ - + static bfd_boolean m32r_elf_size_dynamic_sections (output_bfd, info) bfd *output_bfd ATTRIBUTE_UNUSED; @@ -2541,7 +2542,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section, dynobj = htab->root.dynobj; local_got_offsets = elf_local_got_offsets (input_bfd); - + sgot = htab->sgot; splt = htab->splt; 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. */ if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) rel->r_addend += sec->output_offset + sym->st_value; - + continue; } } @@ -2744,7 +2745,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section, || r_type == R_M32R_26_PCREL_RELA) && ((input_section->flags & SEC_ALLOC) != 0 /* 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 anything with them here. */ || ((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) (info, h->root.root.string, input_bfd, input_section, offset, - (!info->shared + (!info->shared || ELF_ST_VISIBILITY (h->other))))) return FALSE; 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_SLO: - case R_M32R_GOTPC_LO: + case R_M32R_GOTPC_LO: { /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation bl .+4 @@ -2821,7 +2822,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section, relocation -= (input_section->output_section->vma + input_section->output_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)) 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_SLO: - case R_M32R_GOT16_LO: + case R_M32R_GOT16_LO: /* Fall through. */ case R_M32R_GOT24: /* Relocation is to the entry for this symbol in the global offset table. */ BFD_ASSERT (sgot != NULL); - + if (h != NULL) { bfd_boolean dyn; bfd_vma off; - + off = h->got.offset; 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 least significant bit to record whether we have initialized it already. - + When doing a dynamic link, we create a .rela.got relocation entry to initialize the value. This 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; } } - + relocation = sgot->output_offset + off; } else { bfd_vma off; bfd_byte *loc; - + BFD_ASSERT (local_got_offsets != NULL && local_got_offsets[r_symndx] != (bfd_vma) -1); - + off = local_got_offsets[r_symndx]; - + /* The offset must always be a multiple of 4. We use the least significant bit to record whether we have already processed this entry. */ @@ -2894,17 +2895,17 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section, else { bfd_put_32 (output_bfd, relocation, sgot->contents + off); - + if (info->shared) { asection *srelgot; Elf_Internal_Rela outrel; - + /* We need to generate a R_M32R_RELATIVE reloc for the dynamic linker. */ srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); BFD_ASSERT (srelgot != NULL); - + outrel.r_offset = (sgot->output_section->vma + sgot->output_offset + 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); ++srelgot->reloc_count; } - + local_got_offsets[r_symndx] |= 1; } - + relocation = sgot->output_offset + off; } 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; break; - + case R_M32R_26_PLTREL: /* Relocation is to the entry for this symbol in the procedure linkage table. */ - + /* The native assembler will generate a 26_PLTREL reloc for a local symbol if you assemble a call from one section to another when using -K pic. */ @@ -2950,12 +2951,12 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section, using -Bsymbolic. */ break; } - + relocation = (splt->output_section->vma + splt->output_offset + h->plt.offset); break; - + case R_M32R_HI16_SLO_RELA: { 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; bfd_boolean skip, relocate; bfd_byte *loc; - + /* When generating a shared object, these relocations are copied into the output file to be resolved at run time. */ - + if (sreloc == NULL) { const char *name; - + name = (bfd_elf_string_from_elf_section (input_bfd, elf_elfheader (input_bfd)->e_shstrndx, elf_section_data (input_section)->rel_hdr.sh_name)); if (name == NULL) return FALSE; - + BFD_ASSERT (strncmp (name, ".rela", 5) == 0 && strcmp (bfd_get_section_name (input_bfd, input_section), name + 5) == 0); - + sreloc = bfd_get_section_by_name (dynobj, name); BFD_ASSERT (sreloc != NULL); } - + skip = FALSE; relocate = FALSE; - + outrel.r_offset = _bfd_elf_section_offset (output_bfd, info, input_section, @@ -3024,7 +3025,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section, skip = TRUE, relocate = TRUE; outrel.r_offset += (input_section->output_section->vma + input_section->output_offset); - + if (skip) memset (&outrel, 0, sizeof outrel); 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; } break; - + case (int) R_M32R_10_PCREL : r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section, contents, offset, @@ -3238,11 +3239,11 @@ m32r_elf_finish_dynamic_symbol (output_bfd, info, h, sym) struct elf_m32r_link_hash_table *htab; bfd *dynobj; bfd_byte *loc; - + #ifdef DEBUG_PIC printf("m32r_elf_finish_dynamic_symbol()\n"); #endif - + htab = m32r_elf_hash_table (info); dynobj = htab->root.dynobj; @@ -3255,12 +3256,12 @@ printf("m32r_elf_finish_dynamic_symbol()\n"); bfd_vma plt_index; bfd_vma got_offset; Elf_Internal_Rela rela; - + /* This symbol has an entry in the procedure linkage table. Set it up. */ - + BFD_ASSERT (h->dynindx != -1); - + splt = htab->splt; sgot = htab->sgotplt; srela = htab->srelplt; @@ -3321,7 +3322,7 @@ printf("m32r_elf_finish_dynamic_symbol()\n"); + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)), splt->contents + h->plt.offset + 16); } - + /* Fill in the entry in the global offset table. */ bfd_put_32 (output_bfd, (splt->output_section->vma @@ -3339,7 +3340,7 @@ printf("m32r_elf_finish_dynamic_symbol()\n"); loc = srela->contents; loc += plt_index * sizeof(Elf32_External_Rela); bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); - + if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) { /* Mark the symbol as undefined, rather than as defined in @@ -3353,18 +3354,18 @@ printf("m32r_elf_finish_dynamic_symbol()\n"); asection *sgot; asection *srela; Elf_Internal_Rela rela; - + /* This symbol has an entry in the global offset table. Set it up. */ - + sgot = htab->sgot; srela = htab->srelgot; BFD_ASSERT (sgot != NULL && srela != NULL); - + rela.r_offset = (sgot->output_section->vma + sgot->output_offset + (h->got.offset &~ 1)); - + /* If this is a -Bsymbolic link, and the symbol is defined locally, we just want to emit a RELATIVE reloc. Likewise if 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_addend = 0; } - + loc = srela->contents; loc += srela->reloc_count * sizeof(Elf32_External_Rela); bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); ++srela->reloc_count; } - + if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) { asection *s; Elf_Internal_Rela rela; - + /* This symbols needs a copy reloc. Set it up. */ - + BFD_ASSERT (h->dynindx != -1 && (h->root.type == bfd_link_hash_defined || h->root.type == bfd_link_hash_defweak)); - + s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss"); BFD_ASSERT (s != NULL); - + rela.r_offset = (h->root.u.def.value + h->root.u.def.section->output_section->vma + 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); ++s->reloc_count; } - + /* Mark some specially defined symbols as absolute. */ if (strcmp (h->root.root.string, "_DYNAMIC") == 0 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) sym->st_shndx = SHN_ABS; - + return TRUE; } /* Finish up the dynamic sections. */ - + static bfd_boolean m32r_elf_finish_dynamic_sections (output_bfd, info) bfd *output_bfd; @@ -3445,20 +3446,20 @@ m32r_elf_finish_dynamic_sections (output_bfd, info) #ifdef DEBUG_PIC printf("m32r_elf_finish_dynamic_sections()\n"); #endif - + htab = m32r_elf_hash_table (info); dynobj = htab->root.dynobj; sgot = htab->sgotplt; sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); - + if (htab->root.dynamic_sections_created) { asection *splt; Elf32_External_Dyn *dyncon, *dynconend; - + BFD_ASSERT (sgot != NULL && sdyn != NULL); - + dyncon = (Elf32_External_Dyn *) sdyn->contents; dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); @@ -3467,9 +3468,9 @@ printf("m32r_elf_finish_dynamic_sections()\n"); Elf_Internal_Dyn dyn; const char *name; asection *s; - + bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); - + switch (dyn.d_tag) { default: @@ -3477,7 +3478,7 @@ printf("m32r_elf_finish_dynamic_sections()\n"); case DT_PLTGOT: name = ".got"; - s = htab->sgot->output_section; + s = htab->sgot->output_section; goto get_vma; case DT_JMPREL: name = ".rela.plt"; @@ -3520,7 +3521,7 @@ printf("m32r_elf_finish_dynamic_sections()\n"); break; } } - + /* Fill in the first entry in the procedure linkage table. */ splt = htab->splt; if (splt && splt->_raw_size > 0) @@ -3541,7 +3542,7 @@ printf("m32r_elf_finish_dynamic_sections()\n"); bfd_put_32 (output_bfd, PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff), splt->contents); - bfd_put_32 (output_bfd, + bfd_put_32 (output_bfd, PLT0_ENTRY_WORD1 | (addr & 0xffff), splt->contents + 4); 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; } - + 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_SLO: - case R_M32R_GOT16_LO: + case R_M32R_GOT16_LO: case R_M32R_GOT24: 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 linking in any dynamic objects, in which case we don't need to generate a procedure linkage table after all. */ - + /* If this is a local symbol, we resolve it directly without creating a procedure linkage table entry. */ if (h == NULL) @@ -4583,23 +4584,23 @@ m32r_elf_check_relocs (abfd, info, sec, relocs) if (sreloc == NULL) { const char *name; - + name = (bfd_elf_string_from_elf_section (abfd, elf_elfheader (abfd)->e_shstrndx, elf_section_data (sec)->rel_hdr.sh_name)); if (name == NULL) return FALSE; - + BFD_ASSERT (strncmp (name, ".rela", 5) == 0 && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0); - + sreloc = bfd_get_section_by_name (dynobj, name); if (sreloc == NULL) { flagword flags; - + sreloc = bfd_make_section (dynobj, name); flags = (SEC_HAS_CONTENTS | SEC_READONLY | SEC_IN_MEMORY | SEC_LINKER_CREATED); @@ -4612,7 +4613,7 @@ m32r_elf_check_relocs (abfd, info, sec, relocs) } elf_section_data (sec)->sreloc = sreloc; } - + /* If this is a global symbol, we count the number of relocations we need for this symbol. */ if (h != NULL)