X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Felf32-mep.c;h=f700dfce90d176a8c901f207bfc7401213290431;hb=77b38f6db98e046232ecaac11b61c453965fb75a;hp=4036d1e8d1677e4e8e421755c2909e3c357da0e0;hpb=d93525185ce69a5f63029f41e439e4cc8869e210;p=binutils-gdb.git diff --git a/bfd/elf32-mep.c b/bfd/elf32-mep.c index 4036d1e8d16..f700dfce90d 100644 --- a/bfd/elf32-mep.c +++ b/bfd/elf32-mep.c @@ -1,12 +1,11 @@ /* MeP-specific support for 32-bit ELF. - Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. + Copyright (C) 2001-2022 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,10 +15,11 @@ 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + MA 02110-1301, USA. */ -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "libbfd.h" #include "elf-bfd.h" #include "elf/mep.h" @@ -30,42 +30,39 @@ /* Private relocation functions. */ #define MEPREL(type, size, bits, right, left, pcrel, overflow, mask) \ - {(unsigned)type, right, size, bits, pcrel, left, overflow, mep_reloc, #type, FALSE, 0, mask, 0 } + HOWTO (type, right, size, bits, pcrel, left, overflow, bfd_elf_generic_reloc, #type, false, 0, mask, 0) #define N complain_overflow_dont #define S complain_overflow_signed #define U complain_overflow_unsigned -static bfd_reloc_status_type mep_reloc (bfd *, arelent *, struct bfd_symbol *, - void *, asection *, bfd *, char **); - static reloc_howto_type mep_elf_howto_table [] = { /* type, size, bits, leftshift, rightshift, pcrel, OD/OS/OU, mask. */ - MEPREL (R_MEP_NONE, 0, 0, 0, 0, 0, N, 0), - MEPREL (R_RELC, 0, 0, 0, 0, 0, N, 0), + MEPREL (R_MEP_NONE, 0, 0, 0, 0, 0, N, 0), + MEPREL (R_RELC, 0, 0, 0, 0, 0, N, 0), /* MEPRELOC:HOWTO */ /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h. */ - MEPREL (R_MEP_8, 0, 8, 0, 0, 0, U, 0xff), - MEPREL (R_MEP_16, 1, 16, 0, 0, 0, U, 0xffff), - MEPREL (R_MEP_32, 2, 32, 0, 0, 0, U, 0xffffffff), - MEPREL (R_MEP_PCREL8A2, 1, 8, 1, 1, 1, S, 0x00fe), - MEPREL (R_MEP_PCREL12A2,1, 12, 1, 1, 1, S, 0x0ffe), - MEPREL (R_MEP_PCREL17A2,2, 17, 0, 1, 1, S, 0x0000ffff), - MEPREL (R_MEP_PCREL24A2,2, 24, 0, 1, 1, S, 0x07f0ffff), - MEPREL (R_MEP_PCABS24A2,2, 24, 0, 1, 0, U, 0x07f0ffff), - MEPREL (R_MEP_LOW16, 2, 16, 0, 0, 0, N, 0x0000ffff), - MEPREL (R_MEP_HI16U, 2, 32, 0,16, 0, N, 0x0000ffff), - MEPREL (R_MEP_HI16S, 2, 32, 0,16, 0, N, 0x0000ffff), - MEPREL (R_MEP_GPREL, 2, 16, 0, 0, 0, S, 0x0000ffff), - MEPREL (R_MEP_TPREL, 2, 16, 0, 0, 0, S, 0x0000ffff), - MEPREL (R_MEP_TPREL7, 1, 7, 0, 0, 0, U, 0x007f), - MEPREL (R_MEP_TPREL7A2, 1, 7, 1, 1, 0, U, 0x007e), - MEPREL (R_MEP_TPREL7A4, 1, 7, 2, 2, 0, U, 0x007c), - MEPREL (R_MEP_UIMM24, 2, 24, 0, 0, 0, U, 0x00ffffff), - MEPREL (R_MEP_ADDR24A4, 2, 24, 0, 2, 0, U, 0x00fcffff), - MEPREL (R_MEP_GNU_VTINHERIT,1, 0,16,32, 0, N, 0x0000), - MEPREL (R_MEP_GNU_VTENTRY,1, 0,16,32, 0, N, 0x0000), + MEPREL (R_MEP_8, 1, 8, 0, 0, 0, U, 0xff), + MEPREL (R_MEP_16, 2, 16, 0, 0, 0, U, 0xffff), + MEPREL (R_MEP_32, 4, 32, 0, 0, 0, U, 0xffffffff), + MEPREL (R_MEP_PCREL8A2, 2, 8, 1, 1, 1, S, 0x00fe), + MEPREL (R_MEP_PCREL12A2,2, 12, 1, 1, 1, S, 0x0ffe), + MEPREL (R_MEP_PCREL17A2,4, 17, 0, 1, 1, S, 0x0000ffff), + MEPREL (R_MEP_PCREL24A2,4, 24, 0, 1, 1, S, 0x07f0ffff), + MEPREL (R_MEP_PCABS24A2,4, 24, 0, 1, 0, U, 0x07f0ffff), + MEPREL (R_MEP_LOW16, 4, 16, 0, 0, 0, N, 0x0000ffff), + MEPREL (R_MEP_HI16U, 4, 32, 0,16, 0, N, 0x0000ffff), + MEPREL (R_MEP_HI16S, 4, 32, 0,16, 0, N, 0x0000ffff), + MEPREL (R_MEP_GPREL, 4, 16, 0, 0, 0, S, 0x0000ffff), + MEPREL (R_MEP_TPREL, 4, 16, 0, 0, 0, S, 0x0000ffff), + MEPREL (R_MEP_TPREL7, 2, 7, 0, 0, 0, U, 0x007f), + MEPREL (R_MEP_TPREL7A2, 2, 7, 1, 1, 0, U, 0x007e), + MEPREL (R_MEP_TPREL7A4, 2, 7, 2, 2, 0, U, 0x007c), + MEPREL (R_MEP_UIMM24, 4, 24, 0, 0, 0, U, 0x00ffffff), + MEPREL (R_MEP_ADDR24A4, 4, 24, 0, 2, 0, U, 0x00fcffff), + MEPREL (R_MEP_GNU_VTINHERIT,2, 0,16,32, 0, N, 0x0000), + MEPREL (R_MEP_GNU_VTENTRY,2, 0,16,32, 0, N, 0x0000), /* MEPRELOC:END */ }; @@ -75,20 +72,6 @@ static reloc_howto_type mep_elf_howto_table [] = #undef N #undef S #undef U - -static bfd_reloc_status_type -mep_reloc - (bfd * abfd ATTRIBUTE_UNUSED, - arelent * reloc_entry ATTRIBUTE_UNUSED, - struct bfd_symbol * symbol ATTRIBUTE_UNUSED, - void * data ATTRIBUTE_UNUSED, - asection * input_section ATTRIBUTE_UNUSED, - bfd * output_bfd ATTRIBUTE_UNUSED, - char ** error_message ATTRIBUTE_UNUSED) -{ - return bfd_reloc_ok; -} - #define BFD_RELOC_MEP_NONE BFD_RELOC_NONE @@ -153,13 +136,15 @@ mep_reloc_type_lookup default: /* Pacify gcc -Wall. */ - fprintf (stderr, "mep: no reloc for code %d\n", code); + _bfd_error_handler (_("mep: no reloc for code %d"), code); return NULL; } if (mep_elf_howto_table[type].type != type) { - fprintf (stderr, "MeP: howto %d has type %d\n", type, mep_elf_howto_table[type].type); + /* xgettext:c-format */ + _bfd_error_handler (_("MeP: howto %d has type %d"), + type, mep_elf_howto_table[type].type); abort (); } @@ -168,6 +153,20 @@ mep_reloc_type_lookup #undef MAP +static reloc_howto_type * +mep_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) +{ + unsigned int i; + + for (i = 0; + i < sizeof (mep_elf_howto_table) / sizeof (mep_elf_howto_table[0]); + i++) + if (mep_elf_howto_table[i].name != NULL + && strcasecmp (mep_elf_howto_table[i].name, r_name) == 0) + return &mep_elf_howto_table[i]; + + return NULL; +} /* Perform a single relocation. */ @@ -186,7 +185,7 @@ mep_lookup_global if (*cache || *warn) return *cache; - h = bfd_link_hash_lookup (mep_info->hash, name, FALSE, FALSE, TRUE); + h = bfd_link_hash_lookup (mep_info->hash, name, false, false, true); if (h == 0 || h->type != bfd_link_hash_defined) { *warn = ofs + 1; @@ -214,15 +213,14 @@ mep_sdaoff_base (bfd_vma ofs) static bfd_reloc_status_type mep_final_link_relocate - (reloc_howto_type * howto, - bfd * input_bfd, - asection * input_section, - bfd_byte * contents, + (reloc_howto_type * howto, + bfd * input_bfd, + asection * input_section, + bfd_byte * contents, Elf_Internal_Rela * rel, - bfd_vma relocation) + bfd_vma relocation) { unsigned long u; - long s; unsigned char *byte; bfd_vma pc; bfd_reloc_status_type r = bfd_reloc_ok; @@ -243,12 +241,12 @@ mep_final_link_relocate + input_section->output_offset + rel->r_offset); - s = relocation + rel->r_addend; + u = relocation + rel->r_addend; byte = (unsigned char *)contents + rel->r_offset; if (howto->type == R_MEP_PCREL24A2 - && s == 0 + && u == 0 && pc >= 0x800000) { /* This is an unreachable branch to an undefined weak function. @@ -258,9 +256,7 @@ mep_final_link_relocate } if (howto->pc_relative) - s -= pc; - - u = (unsigned long) s; + u -= pc; switch (howto->type) { @@ -282,25 +278,25 @@ mep_final_link_relocate byte[3^e4] = (u & 0xff); break; case R_MEP_PCREL8A2: /* --------7654321- */ - if (-128 > s || s > 127) r = bfd_reloc_overflow; - byte[1^e2] = (byte[1^e2] & 0x01) | (s & 0xfe); + if (u + 128 > 255) r = bfd_reloc_overflow; + byte[1^e2] = (byte[1^e2] & 0x01) | (u & 0xfe); break; case R_MEP_PCREL12A2: /* ----ba987654321- */ - if (-2048 > s || s > 2047) r = bfd_reloc_overflow; - byte[0^e2] = (byte[0^e2] & 0xf0) | ((s >> 8) & 0x0f); - byte[1^e2] = (byte[1^e2] & 0x01) | (s & 0xfe); + if (u + 2048 > 4095) r = bfd_reloc_overflow; + byte[0^e2] = (byte[0^e2] & 0xf0) | ((u >> 8) & 0x0f); + byte[1^e2] = (byte[1^e2] & 0x01) | (u & 0xfe); break; case R_MEP_PCREL17A2: /* ----------------gfedcba987654321 */ - if (-65536 > s || s > 65535) r = bfd_reloc_overflow; - byte[2^e2] = ((s >> 9) & 0xff); - byte[3^e2] = ((s >> 1) & 0xff); + if (u + 65536 > 131071) r = bfd_reloc_overflow; + byte[2^e2] = ((u >> 9) & 0xff); + byte[3^e2] = ((u >> 1) & 0xff); break; case R_MEP_PCREL24A2: /* -----7654321----nmlkjihgfedcba98 */ - if (-8388608 > s || s > 8388607) r = bfd_reloc_overflow; - byte[0^e2] = (byte[0^e2] & 0xf8) | ((s >> 5) & 0x07); - byte[1^e2] = (byte[1^e2] & 0x0f) | ((s << 3) & 0xf0); - byte[2^e2] = ((s >> 16) & 0xff); - byte[3^e2] = ((s >> 8) & 0xff); + if (u + 8388608 > 16777215) r = bfd_reloc_overflow; + byte[0^e2] = (byte[0^e2] & 0xf8) | ((u >> 5) & 0x07); + byte[1^e2] = (byte[1^e2] & 0x0f) | ((u << 3) & 0xf0); + byte[2^e2] = ((u >> 16) & 0xff); + byte[3^e2] = ((u >> 8) & 0xff); break; case R_MEP_PCABS24A2: /* -----7654321----nmlkjihgfedcba98 */ if (u > 16777215) r = bfd_reloc_overflow; @@ -318,20 +314,21 @@ mep_final_link_relocate byte[3^e2] = ((u >> 16) & 0xff); break; case R_MEP_HI16S: /* ----------------vutsrqponmlkjihg */ - byte[2^e2] = ((s >> 24) & 0xff); - byte[3^e2] = ((s >> 16) & 0xff); + u += 0x8000; + byte[2^e2] = ((u >> 24) & 0xff); + byte[3^e2] = ((u >> 16) & 0xff); break; case R_MEP_GPREL: /* ----------------fedcba9876543210 */ - s -= mep_sdaoff_base(rel->r_offset); - if (-32768 > s || s > 32767) r = bfd_reloc_overflow; - byte[2^e2] = ((s >> 8) & 0xff); - byte[3^e2] = (s & 0xff); + u -= mep_sdaoff_base(rel->r_offset); + if (u + 32768 > 65535) r = bfd_reloc_overflow; + byte[2^e2] = ((u >> 8) & 0xff); + byte[3^e2] = (u & 0xff); break; case R_MEP_TPREL: /* ----------------fedcba9876543210 */ - s -= mep_tpoff_base(rel->r_offset); - if (-32768 > s || s > 32767) r = bfd_reloc_overflow; - byte[2^e2] = ((s >> 8) & 0xff); - byte[3^e2] = (s & 0xff); + u -= mep_tpoff_base(rel->r_offset); + if (u + 32768 > 65535) r = bfd_reloc_overflow; + byte[2^e2] = ((u >> 8) & 0xff); + byte[3^e2] = (u & 0xff); break; case R_MEP_TPREL7: /* ---------6543210 */ u -= mep_tpoff_base(rel->r_offset); @@ -374,59 +371,25 @@ mep_final_link_relocate /* Set the howto pointer for a MEP ELF reloc. */ -static void -mep_info_to_howto_rela - (bfd * abfd ATTRIBUTE_UNUSED, - arelent * cache_ptr, - Elf_Internal_Rela * dst) +static bool +mep_info_to_howto_rela (bfd * abfd, + arelent * cache_ptr, + Elf_Internal_Rela * dst) { unsigned int r_type; r_type = ELF32_R_TYPE (dst->r_info); - cache_ptr->howto = & mep_elf_howto_table [r_type]; -} - -/* Look through the relocs for a section during the first phase. - Since we don't do .gots or .plts, we just need to consider the - virtual table relocs for gc. */ - -static bfd_boolean -mep_elf_check_relocs - (bfd * abfd, - struct bfd_link_info * info, - asection * sec, - const Elf_Internal_Rela * relocs) -{ - Elf_Internal_Shdr * symtab_hdr; - struct elf_link_hash_entry ** sym_hashes; - struct elf_link_hash_entry ** sym_hashes_end; - const Elf_Internal_Rela * rel; - const Elf_Internal_Rela * rel_end; - - if (info->relocatable) - return TRUE; - - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; - sym_hashes = elf_sym_hashes (abfd); - sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym); - if (!elf_bad_symtab (abfd)) - sym_hashes_end -= symtab_hdr->sh_info; - - rel_end = relocs + sec->reloc_count; - for (rel = relocs; rel < rel_end; rel++) + if (r_type >= R_MEP_max) { - struct elf_link_hash_entry *h; - unsigned long r_symndx; - - r_symndx = ELF32_R_SYM (rel->r_info); - if (r_symndx < symtab_hdr->sh_info) - h = NULL; - else - h = sym_hashes[r_symndx - symtab_hdr->sh_info]; + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: unsupported relocation type %#x"), + abfd, r_type); + bfd_set_error (bfd_error_bad_value); + return false; } - return TRUE; + cache_ptr->howto = & mep_elf_howto_table [r_type]; + return true; } - /* Relocate a MEP ELF section. There is some attempt to make this function usable for many architectures, @@ -461,21 +424,21 @@ mep_elf_check_relocs section, which means that the addend must be adjusted accordingly. */ -static bfd_boolean +static int mep_elf_relocate_section - (bfd * output_bfd ATTRIBUTE_UNUSED, + (bfd * output_bfd ATTRIBUTE_UNUSED, struct bfd_link_info * info, - bfd * input_bfd, - asection * input_section, - bfd_byte * contents, + bfd * input_bfd, + asection * input_section, + bfd_byte * contents, Elf_Internal_Rela * relocs, - Elf_Internal_Sym * local_syms, - asection ** local_sections) + Elf_Internal_Sym * local_syms, + asection ** local_sections) { - Elf_Internal_Shdr * symtab_hdr; + Elf_Internal_Shdr * symtab_hdr; struct elf_link_hash_entry ** sym_hashes; - Elf_Internal_Rela * rel; - Elf_Internal_Rela * relend; + Elf_Internal_Rela * rel; + Elf_Internal_Rela * relend; symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; sym_hashes = elf_sym_hashes (input_bfd); @@ -485,50 +448,18 @@ mep_elf_relocate_section for (rel = relocs; rel < relend; rel ++) { - reloc_howto_type * howto; - unsigned long r_symndx; - Elf_Internal_Sym * sym; - asection * sec; + reloc_howto_type * howto; + unsigned long r_symndx; + Elf_Internal_Sym * sym; + asection * sec; struct elf_link_hash_entry * h; - bfd_vma relocation; - bfd_reloc_status_type r; - const char * name = NULL; - int r_type; + bfd_vma relocation; + bfd_reloc_status_type r; + const char * name = NULL; + int r_type; r_type = ELF32_R_TYPE (rel->r_info); - r_symndx = ELF32_R_SYM (rel->r_info); - - if (info->relocatable) - { - /* This is a relocatable link. We don't have to change - anything, unless the reloc is against a section symbol, - in which case we have to adjust according to where the - section symbol winds up in the output section. */ - if (r_symndx < symtab_hdr->sh_info) - { - sym = local_syms + r_symndx; - - if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) - { - sec = local_sections [r_symndx]; - rel->r_addend += sec->output_offset + sym->st_value; - } - } - - continue; - } - - /* Is this a complex relocation? */ - if (ELF32_R_TYPE (rel->r_info) == R_RELC) - { - bfd_elf_perform_complex_relocation (output_bfd, info, - input_bfd, input_section, contents, - rel, local_syms, local_sections); - continue; - } - - /* This is a final link. */ howto = mep_elf_howto_table + ELF32_R_TYPE (rel->r_info); h = NULL; sym = NULL; @@ -542,67 +473,33 @@ mep_elf_relocate_section name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name); - name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; -#if 0 - fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n", - sec->name, name, sym->st_name, - sec->output_section->vma, sec->output_offset, - sym->st_value, rel->r_addend); -#endif + name = name == NULL ? bfd_section_name (sec) : name; } else { - h = sym_hashes [r_symndx]; + bool warned, unresolved_reloc, ignored; - while (h->root.type == bfd_link_hash_indirect - || h->root.type == bfd_link_hash_warning) - h = (struct elf_link_hash_entry *) h->root.u.i.link; + RELOC_FOR_GLOBAL_SYMBOL(info, input_bfd, input_section, rel, + r_symndx, symtab_hdr, sym_hashes, + h, sec, relocation, + unresolved_reloc, warned, ignored); name = h->root.root.string; - - if (h->root.type == bfd_link_hash_defined - || h->root.type == bfd_link_hash_defweak) - { - sec = h->root.u.def.section; - relocation = (h->root.u.def.value - + sec->output_section->vma - + sec->output_offset); -#if 0 - fprintf (stderr, - "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n", - sec->name, name, h->root.u.def.value, - sec->output_section->vma, sec->output_offset, relocation); -#endif - } - else if (h->root.type == bfd_link_hash_undefweak) - { -#if 0 - fprintf (stderr, "undefined: sec: %s, name: %s\n", - sec->name, name); -#endif - relocation = 0; - } - else - { - if (! ((*info->callbacks->undefined_symbol) - (info, h->root.root.string, input_bfd, - input_section, rel->r_offset, - (!info->shared && info->unresolved_syms_in_objects == RM_GENERATE_ERROR)))) - return FALSE; -#if 0 - fprintf (stderr, "unknown: name: %s\n", name); -#endif - relocation = 0; - } } - switch (r_type) - { - default: - r = mep_final_link_relocate (howto, input_bfd, input_section, - contents, rel, relocation); - break; - } + if (sec != NULL && discarded_section (sec)) + RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, + rel, 1, relend, howto, 0, contents); + + if (bfd_link_relocatable (info)) + continue; + + if (r_type == R_RELC) + r = bfd_elf_perform_complex_relocation (input_bfd, input_section, + contents, rel, relocation); + else + r = mep_final_link_relocate (howto, input_bfd, input_section, + contents, rel, relocation); if (r != bfd_reloc_ok) { @@ -611,14 +508,14 @@ mep_elf_relocate_section switch (r) { case bfd_reloc_overflow: - r = info->callbacks->reloc_overflow + (*info->callbacks->reloc_overflow) (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0, input_bfd, input_section, rel->r_offset); break; case bfd_reloc_undefined: - r = info->callbacks->undefined_symbol - (info, name, input_bfd, input_section, rel->r_offset, TRUE); + (*info->callbacks->undefined_symbol) + (info, name, input_bfd, input_section, rel->r_offset, true); break; case bfd_reloc_outofrange: @@ -639,132 +536,61 @@ mep_elf_relocate_section } if (msg) - r = info->callbacks->warning - (info, msg, name, input_bfd, input_section, rel->r_offset); - - if (! r) - return FALSE; + (*info->callbacks->warning) (info, msg, name, input_bfd, + input_section, rel->r_offset); } } if (warn_tp) info->callbacks->undefined_symbol - (info, "__tpbase", input_bfd, input_section, warn_tp-1, TRUE); + (info, "__tpbase", input_bfd, input_section, warn_tp-1, true); if (warn_sda) info->callbacks->undefined_symbol - (info, "__sdabase", input_bfd, input_section, warn_sda-1, TRUE); + (info, "__sdabase", input_bfd, input_section, warn_sda-1, true); if (warn_sda || warn_tp) - return FALSE; - - return TRUE; -} - - -/* Update the got entry reference counts for the section being - removed. */ - -static bfd_boolean -mep_elf_gc_sweep_hook - (bfd * abfd ATTRIBUTE_UNUSED, - struct bfd_link_info * info ATTRIBUTE_UNUSED, - asection * sec ATTRIBUTE_UNUSED, - const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED) -{ - return TRUE; -} + return false; -/* Return the section that should be marked against GC for a given - relocation. */ - -static asection * -mep_elf_gc_mark_hook - (asection * sec, - struct bfd_link_info * info ATTRIBUTE_UNUSED, - Elf_Internal_Rela * rel, - struct elf_link_hash_entry * h, - Elf_Internal_Sym * sym) -{ - if (h != NULL) - { - switch (ELF32_R_TYPE (rel->r_info)) - { - default: - switch (h->root.type) - { - case bfd_link_hash_defined: - case bfd_link_hash_defweak: - return h->root.u.def.section; - - case bfd_link_hash_common: - return h->root.u.c.p->section; - - default: - break; - } - } - } - else - { - if (!(elf_bad_symtab (sec->owner) - && ELF_ST_BIND (sym->st_info) != STB_LOCAL) - && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE) - && sym->st_shndx != SHN_COMMON)) - return bfd_section_from_elf_index (sec->owner, sym->st_shndx); - } - - return NULL; + return true; } - /* Function to set the ELF flag bits. */ -static bfd_boolean +static bool mep_elf_set_private_flags (bfd * abfd, flagword flags) { elf_elfheader (abfd)->e_flags = flags; - elf_flags_init (abfd) = TRUE; - return TRUE; -} - -static bfd_boolean -mep_elf_copy_private_bfd_data (bfd * ibfd, bfd * obfd) -{ - if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour - || bfd_get_flavour (obfd) != bfd_target_elf_flavour) - return TRUE; - - elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; - elf_flags_init (obfd) = TRUE; - return TRUE; + elf_flags_init (abfd) = true; + return true; } /* Merge backend specific data from an object file to the output object file when linking. */ -static bfd_boolean -mep_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd) +static bool +mep_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) { + bfd *obfd = info->output_bfd; static bfd *last_ibfd = 0; flagword old_flags, new_flags; flagword old_partial, new_partial; - /* Check if we have the same endianess. */ - if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE) - return FALSE; + /* Check if we have the same endianness. */ + if (!_bfd_generic_verify_endian_match (ibfd, info)) + return false; new_flags = elf_elfheader (ibfd)->e_flags; old_flags = elf_elfheader (obfd)->e_flags; #ifdef DEBUG - _bfd_error_handler ("%B: old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s", + _bfd_error_handler ("%pB: old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s", ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no"); #endif /* First call, no flags set. */ if (!elf_flags_init (obfd)) { - elf_flags_init (obfd) = TRUE; + elf_flags_init (obfd) = true; old_flags = new_flags; } else if ((new_flags | old_flags) & EF_MEP_LIBRARY) @@ -788,9 +614,11 @@ mep_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd) old_flags = (old_flags & ~EF_MEP_CPU_MASK) | new_partial; else { - _bfd_error_handler (_("%B and %B are for different cores"), last_ibfd, ibfd); + /* xgettext:c-format */ + _bfd_error_handler (_("%pB and %pB are for different cores"), + last_ibfd, ibfd); bfd_set_error (bfd_error_invalid_target); - return FALSE; + return false; } /* Make sure they're for the same me_module. Allow basic config to @@ -805,15 +633,17 @@ mep_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd) old_flags = (old_flags & ~EF_MEP_INDEX_MASK) | new_partial; else { - _bfd_error_handler (_("%B and %B are for different configurations"), last_ibfd, ibfd); + /* xgettext:c-format */ + _bfd_error_handler (_("%pB and %pB are for different configurations"), + last_ibfd, ibfd); bfd_set_error (bfd_error_invalid_target); - return FALSE; + return false; } } elf_elfheader (obfd)->e_flags = old_flags; last_ibfd = ibfd; - return TRUE; + return true; } /* This will be edited by the MeP configration tool. */ @@ -821,8 +651,7 @@ static const char * config_names[] = { "basic" /* start-mepcfgtool */ - ,"simple" - ,"fmax" + ,"default" /* end-mepcfgtool */ }; @@ -831,7 +660,7 @@ static const char * core_names[] = "MeP", "MeP-c2", "MeP-c3", "MeP-h1" }; -static bfd_boolean +static bool mep_elf_print_private_bfd_data (bfd * abfd, void * ptr) { FILE * file = (FILE *) ptr; @@ -843,7 +672,7 @@ mep_elf_print_private_bfd_data (bfd * abfd, void * ptr) _bfd_elf_print_private_bfd_data (abfd, ptr); flags = elf_elfheader (abfd)->e_flags; - fprintf (file, _("private flags = 0x%lx"), (long)flags); + fprintf (file, _("private flags = 0x%lx"), (unsigned long) flags); partial_flags = (flags & EF_MEP_CPU_MASK) >> 24; if (partial_flags < ARRAY_SIZE (core_names)) @@ -855,7 +684,7 @@ mep_elf_print_private_bfd_data (bfd * abfd, void * ptr) fputc ('\n', file); - return TRUE; + return true; } /* Return the machine subcode from the ELF e_flags header. */ @@ -869,40 +698,36 @@ elf32_mep_machine (bfd * abfd) case EF_MEP_CPU_C2: return bfd_mach_mep; case EF_MEP_CPU_C3: return bfd_mach_mep; case EF_MEP_CPU_C4: return bfd_mach_mep; + case EF_MEP_CPU_C5: return bfd_mach_mep_c5; case EF_MEP_CPU_H1: return bfd_mach_mep_h1; } return bfd_mach_mep; } -static bfd_boolean +static bool mep_elf_object_p (bfd * abfd) { - /* Irix 5 and 6 is broken. Object file symbol tables are not always - sorted correctly such that local symbols preceed global symbols, - and the sh_info field in the symbol table is not always right. */ - /* This is needed for the RELC support code. */ - elf_bad_symtab (abfd) = TRUE; bfd_default_set_arch_mach (abfd, bfd_arch_mep, elf32_mep_machine (abfd)); - return TRUE; + return true; } -static bfd_boolean -mep_elf_section_flags (flagword * flags, const Elf_Internal_Shdr * hdr) +static bool +mep_elf_section_flags (const Elf_Internal_Shdr *hdr) { if (hdr->sh_flags & SHF_MEP_VLIW) - * flags |= SEC_MEP_VLIW; - return TRUE; + hdr->bfd_section->flags |= SEC_MEP_VLIW; + return true; } -static bfd_boolean -mep_elf_fake_sections (bfd * abfd ATTRIBUTE_UNUSED, +static bool +mep_elf_fake_sections (bfd * abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr * hdr, - asection * sec) + asection * sec) { if (sec->flags & SEC_MEP_VLIW) hdr->sh_flags |= SHF_MEP_VLIW; - return TRUE; + return true; } @@ -910,31 +735,25 @@ mep_elf_fake_sections (bfd * abfd ATTRIBUTE_UNUSED, #define ELF_MACHINE_CODE EM_CYGNUS_MEP #define ELF_MAXPAGESIZE 0x1000 -#define TARGET_BIG_SYM bfd_elf32_mep_vec +#define TARGET_BIG_SYM mep_elf32_vec #define TARGET_BIG_NAME "elf32-mep" -#define TARGET_LITTLE_SYM bfd_elf32_mep_little_vec +#define TARGET_LITTLE_SYM mep_elf32_le_vec #define TARGET_LITTLE_NAME "elf32-mep-little" #define elf_info_to_howto_rel NULL #define elf_info_to_howto mep_info_to_howto_rela #define elf_backend_relocate_section mep_elf_relocate_section -#define elf_backend_gc_mark_hook mep_elf_gc_mark_hook -#define elf_backend_gc_sweep_hook mep_elf_gc_sweep_hook -#define elf_backend_check_relocs mep_elf_check_relocs -#define elf_backend_object_p mep_elf_object_p +#define elf_backend_object_p mep_elf_object_p #define elf_backend_section_flags mep_elf_section_flags #define elf_backend_fake_sections mep_elf_fake_sections -#define elf_backend_can_gc_sections 1 - #define bfd_elf32_bfd_reloc_type_lookup mep_reloc_type_lookup +#define bfd_elf32_bfd_reloc_name_lookup mep_reloc_name_lookup #define bfd_elf32_bfd_set_private_flags mep_elf_set_private_flags -#define bfd_elf32_bfd_copy_private_bfd_data mep_elf_copy_private_bfd_data #define bfd_elf32_bfd_merge_private_bfd_data mep_elf_merge_private_bfd_data #define bfd_elf32_bfd_print_private_bfd_data mep_elf_print_private_bfd_data -/* We use only the RELA entries. */ -#define USE_RELA +#define elf_backend_rela_normal 1 #include "elf32-target.h"