| /* MeP-specific support for 32-bit ELF. |
| Copyright (C) 2001-2024 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 3 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| 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. */ |
| |
| #include "sysdep.h" |
| #include "bfd.h" |
| #include "libbfd.h" |
| #include "elf-bfd.h" |
| #include "elf/mep.h" |
| #include "libiberty.h" |
| |
| /* Forward declarations. */ |
| |
| /* Private relocation functions. */ |
| |
| #define MEPREL(type, size, bits, right, left, pcrel, overflow, mask) \ |
| 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 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), |
| /* MEPRELOC:HOWTO */ |
| /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h. */ |
| 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 */ |
| }; |
| |
| #define VALID_MEP_RELOC(N) ((N) >= 0 \ |
| && (N) < ARRAY_SIZE (mep_elf_howto_table) |
| |
| #undef N |
| #undef S |
| #undef U |
| |
| |
| #define BFD_RELOC_MEP_NONE BFD_RELOC_NONE |
| #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE) |
| #define MAP(n) case BFD_RELOC_MEP_##n: type = R_MEP_##n; break |
| #else |
| #define MAP(n) case BFD_RELOC_MEP_/**/n: type = R_MEP_/**/n; break |
| #endif |
| |
| static reloc_howto_type * |
| mep_reloc_type_lookup |
| (bfd * abfd ATTRIBUTE_UNUSED, |
| bfd_reloc_code_real_type code) |
| { |
| unsigned int type = 0; |
| |
| switch (code) |
| { |
| MAP(NONE); |
| case BFD_RELOC_8: |
| type = R_MEP_8; |
| break; |
| case BFD_RELOC_16: |
| type = R_MEP_16; |
| break; |
| case BFD_RELOC_32: |
| type = R_MEP_32; |
| break; |
| case BFD_RELOC_VTABLE_ENTRY: |
| type = R_MEP_GNU_VTENTRY; |
| break; |
| case BFD_RELOC_VTABLE_INHERIT: |
| type = R_MEP_GNU_VTINHERIT; |
| break; |
| case BFD_RELOC_RELC: |
| type = R_RELC; |
| break; |
| |
| /* MEPRELOC:MAP */ |
| /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h. */ |
| MAP(8); |
| MAP(16); |
| MAP(32); |
| MAP(PCREL8A2); |
| MAP(PCREL12A2); |
| MAP(PCREL17A2); |
| MAP(PCREL24A2); |
| MAP(PCABS24A2); |
| MAP(LOW16); |
| MAP(HI16U); |
| MAP(HI16S); |
| MAP(GPREL); |
| MAP(TPREL); |
| MAP(TPREL7); |
| MAP(TPREL7A2); |
| MAP(TPREL7A4); |
| MAP(UIMM24); |
| MAP(ADDR24A4); |
| MAP(GNU_VTINHERIT); |
| MAP(GNU_VTENTRY); |
| /* MEPRELOC:END */ |
| |
| default: |
| /* Pacify gcc -Wall. */ |
| _bfd_error_handler (_("mep: no reloc for code %d"), code); |
| return NULL; |
| } |
| |
| if (mep_elf_howto_table[type].type != type) |
| { |
| /* xgettext:c-format */ |
| _bfd_error_handler (_("MeP: howto %d has type %d"), |
| type, mep_elf_howto_table[type].type); |
| abort (); |
| } |
| |
| return mep_elf_howto_table + type; |
| } |
| |
| #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. */ |
| |
| static struct bfd_link_info *mep_info; |
| static int warn_tp = 0, warn_sda = 0; |
| |
| static bfd_vma |
| mep_lookup_global |
| (char * name, |
| bfd_vma ofs, |
| bfd_vma * cache, |
| int * warn) |
| { |
| struct bfd_link_hash_entry *h; |
| |
| if (*cache || *warn) |
| return *cache; |
| |
| h = bfd_link_hash_lookup (mep_info->hash, name, false, false, true); |
| if (h == 0 || h->type != bfd_link_hash_defined) |
| { |
| *warn = ofs + 1; |
| return 0; |
| } |
| *cache = (h->u.def.value |
| + h->u.def.section->output_section->vma |
| + h->u.def.section->output_offset); |
| return *cache; |
| } |
| |
| static bfd_vma |
| mep_tpoff_base (bfd_vma ofs) |
| { |
| static bfd_vma cache = 0; |
| return mep_lookup_global ("__tpbase", ofs, &cache, &warn_tp); |
| } |
| |
| static bfd_vma |
| mep_sdaoff_base (bfd_vma ofs) |
| { |
| static bfd_vma cache = 0; |
| return mep_lookup_global ("__sdabase", ofs, &cache, &warn_sda); |
| } |
| |
| static bfd_reloc_status_type |
| mep_final_link_relocate |
| (reloc_howto_type * howto, |
| bfd * input_bfd, |
| asection * input_section, |
| bfd_byte * contents, |
| Elf_Internal_Rela * rel, |
| bfd_vma relocation) |
| { |
| unsigned long u; |
| unsigned char *byte; |
| bfd_vma pc; |
| bfd_reloc_status_type r = bfd_reloc_ok; |
| int e2, e4; |
| |
| if (bfd_big_endian (input_bfd)) |
| { |
| e2 = 0; |
| e4 = 0; |
| } |
| else |
| { |
| e2 = 1; |
| e4 = 3; |
| } |
| |
| pc = (input_section->output_section->vma |
| + input_section->output_offset |
| + rel->r_offset); |
| |
| u = relocation + rel->r_addend; |
| |
| byte = (unsigned char *)contents + rel->r_offset; |
| |
| if (howto->type == R_MEP_PCREL24A2 |
| && u == 0 |
| && pc >= 0x800000) |
| { |
| /* This is an unreachable branch to an undefined weak function. |
| Silently ignore it, since the opcode can't do that but should |
| never be executed anyway. */ |
| return bfd_reloc_ok; |
| } |
| |
| if (howto->pc_relative) |
| u -= pc; |
| |
| switch (howto->type) |
| { |
| /* MEPRELOC:APPLY */ |
| /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h. */ |
| case R_MEP_8: /* 76543210 */ |
| if (u > 255) r = bfd_reloc_overflow; |
| byte[0] = (u & 0xff); |
| break; |
| case R_MEP_16: /* fedcba9876543210 */ |
| if (u > 65535) r = bfd_reloc_overflow; |
| byte[0^e2] = ((u >> 8) & 0xff); |
| byte[1^e2] = (u & 0xff); |
| break; |
| case R_MEP_32: /* vutsrqponmlkjihgfedcba9876543210 */ |
| byte[0^e4] = ((u >> 24) & 0xff); |
| byte[1^e4] = ((u >> 16) & 0xff); |
| byte[2^e4] = ((u >> 8) & 0xff); |
| byte[3^e4] = (u & 0xff); |
| break; |
| case R_MEP_PCREL8A2: /* --------7654321- */ |
| if (u + 128 > 255) r = bfd_reloc_overflow; |
| byte[1^e2] = (byte[1^e2] & 0x01) | (u & 0xfe); |
| break; |
| case R_MEP_PCREL12A2: /* ----ba987654321- */ |
| 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 (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 (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; |
| 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_LOW16: /* ----------------fedcba9876543210 */ |
| byte[2^e2] = ((u >> 8) & 0xff); |
| byte[3^e2] = (u & 0xff); |
| break; |
| case R_MEP_HI16U: /* ----------------vutsrqponmlkjihg */ |
| byte[2^e2] = ((u >> 24) & 0xff); |
| byte[3^e2] = ((u >> 16) & 0xff); |
| break; |
| case R_MEP_HI16S: /* ----------------vutsrqponmlkjihg */ |
| u += 0x8000; |
| byte[2^e2] = ((u >> 24) & 0xff); |
| byte[3^e2] = ((u >> 16) & 0xff); |
| break; |
| case R_MEP_GPREL: /* ----------------fedcba9876543210 */ |
| 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 */ |
| 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); |
| if (u > 127) r = bfd_reloc_overflow; |
| byte[1^e2] = (byte[1^e2] & 0x80) | (u & 0x7f); |
| break; |
| case R_MEP_TPREL7A2: /* ---------654321- */ |
| u -= mep_tpoff_base(rel->r_offset); |
| if (u > 127) r = bfd_reloc_overflow; |
| byte[1^e2] = (byte[1^e2] & 0x81) | (u & 0x7e); |
| break; |
| case R_MEP_TPREL7A4: /* ---------65432-- */ |
| u -= mep_tpoff_base(rel->r_offset); |
| if (u > 127) r = bfd_reloc_overflow; |
| byte[1^e2] = (byte[1^e2] & 0x83) | (u & 0x7c); |
| break; |
| case R_MEP_UIMM24: /* --------76543210nmlkjihgfedcba98 */ |
| if (u > 16777215) r = bfd_reloc_overflow; |
| byte[1^e2] = (u & 0xff); |
| byte[2^e2] = ((u >> 16) & 0xff); |
| byte[3^e2] = ((u >> 8) & 0xff); |
| break; |
| case R_MEP_ADDR24A4: /* --------765432--nmlkjihgfedcba98 */ |
| if (u > 16777215) r = bfd_reloc_overflow; |
| byte[1^e2] = (byte[1^e2] & 0x03) | (u & 0xfc); |
| byte[2^e2] = ((u >> 16) & 0xff); |
| byte[3^e2] = ((u >> 8) & 0xff); |
| break; |
| case R_MEP_GNU_VTINHERIT: /* ---------------- */ |
| break; |
| case R_MEP_GNU_VTENTRY: /* ---------------- */ |
| break; |
| /* MEPRELOC:END */ |
| default: |
| abort (); |
| } |
| |
| return r; |
| } |
| |
| /* Set the howto pointer for a MEP ELF reloc. */ |
| |
| 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); |
| if (r_type >= R_MEP_max) |
| { |
| /* xgettext:c-format */ |
| _bfd_error_handler (_("%pB: unsupported relocation type %#x"), |
| abfd, r_type); |
| bfd_set_error (bfd_error_bad_value); |
| return false; |
| } |
| 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, |
| both USE_REL and USE_RELA ['twould be nice if such a critter existed], |
| if only to serve as a learning tool. |
| |
| The RELOCATE_SECTION function is called by the new ELF backend linker |
| to handle the relocations for a section. |
| |
| The relocs are always passed as Rela structures; if the section |
| actually uses Rel structures, the r_addend field will always be |
| zero. |
| |
| This function is responsible for adjusting the section contents as |
| necessary, and (if using Rela relocs and generating a relocatable |
| output file) adjusting the reloc addend as necessary. |
| |
| This function does not have to worry about setting the reloc |
| address or the reloc symbol index. |
| |
| LOCAL_SYMS is a pointer to the swapped in local symbols. |
| |
| LOCAL_SECTIONS is an array giving the section in the input file |
| corresponding to the st_shndx field of each local symbol. |
| |
| The global hash table entry for the global symbols can be found |
| via elf_sym_hashes (input_bfd). |
| |
| When generating relocatable output, this function must handle |
| STB_LOCAL/STT_SECTION symbols specially. The output symbol is |
| going to be the section symbol corresponding to the output |
| section, which means that the addend must be adjusted |
| accordingly. */ |
| |
| static int |
| mep_elf_relocate_section |
| (bfd * output_bfd ATTRIBUTE_UNUSED, |
| struct bfd_link_info * info, |
| bfd * input_bfd, |
| asection * input_section, |
| bfd_byte * contents, |
| Elf_Internal_Rela * relocs, |
| Elf_Internal_Sym * local_syms, |
| asection ** local_sections) |
| { |
| Elf_Internal_Shdr * symtab_hdr; |
| struct elf_link_hash_entry ** sym_hashes; |
| Elf_Internal_Rela * rel; |
| Elf_Internal_Rela * relend; |
| |
| symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; |
| sym_hashes = elf_sym_hashes (input_bfd); |
| relend = relocs + input_section->reloc_count; |
| |
| mep_info = info; |
| |
| for (rel = relocs; rel < relend; rel ++) |
| { |
| 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; |
| |
| r_type = ELF32_R_TYPE (rel->r_info); |
| r_symndx = ELF32_R_SYM (rel->r_info); |
| howto = mep_elf_howto_table + ELF32_R_TYPE (rel->r_info); |
| h = NULL; |
| sym = NULL; |
| sec = NULL; |
| |
| if (r_symndx < symtab_hdr->sh_info) |
| { |
| sym = local_syms + r_symndx; |
| sec = local_sections [r_symndx]; |
| relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); |
| |
| name = bfd_elf_string_from_elf_section |
| (input_bfd, symtab_hdr->sh_link, sym->st_name); |
| name = name == NULL ? bfd_section_name (sec) : name; |
| } |
| else |
| { |
| bool warned, unresolved_reloc, ignored; |
| |
| 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 (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) |
| { |
| const char * msg = (const char *) NULL; |
| |
| switch (r) |
| { |
| case bfd_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: |
| (*info->callbacks->undefined_symbol) |
| (info, name, input_bfd, input_section, rel->r_offset, true); |
| break; |
| |
| case bfd_reloc_outofrange: |
| msg = _("internal error: out of range error"); |
| break; |
| |
| case bfd_reloc_notsupported: |
| msg = _("internal error: unsupported relocation error"); |
| break; |
| |
| case bfd_reloc_dangerous: |
| msg = _("internal error: dangerous relocation"); |
| break; |
| |
| default: |
| msg = _("internal error: unknown error"); |
| break; |
| } |
| |
| if (msg) |
| (*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); |
| if (warn_sda) |
| info->callbacks->undefined_symbol |
| (info, "__sdabase", input_bfd, input_section, warn_sda-1, true); |
| if (warn_sda || warn_tp) |
| return false; |
| |
| return true; |
| } |
| |
| /* Function to set the ELF flag bits. */ |
| |
| static bool |
| mep_elf_set_private_flags (bfd * abfd, |
| flagword flags) |
| { |
| elf_elfheader (abfd)->e_flags = flags; |
| elf_flags_init (abfd) = true; |
| return true; |
| } |
| |
| /* Merge backend specific data from an object file to the output |
| object file when linking. */ |
| |
| 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 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 ("%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; |
| old_flags = new_flags; |
| } |
| else if ((new_flags | old_flags) & EF_MEP_LIBRARY) |
| { |
| /* Non-library flags trump library flags. The choice doesn't really |
| matter if both OLD_FLAGS and NEW_FLAGS have EF_MEP_LIBRARY set. */ |
| if (old_flags & EF_MEP_LIBRARY) |
| old_flags = new_flags; |
| } |
| else |
| { |
| /* Make sure they're for the same mach. Allow upgrade from the "mep" |
| mach. */ |
| new_partial = (new_flags & EF_MEP_CPU_MASK); |
| old_partial = (old_flags & EF_MEP_CPU_MASK); |
| if (new_partial == old_partial) |
| ; |
| else if (new_partial == EF_MEP_CPU_MEP) |
| ; |
| else if (old_partial == EF_MEP_CPU_MEP) |
| old_flags = (old_flags & ~EF_MEP_CPU_MASK) | new_partial; |
| else |
| { |
| /* 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; |
| } |
| |
| /* Make sure they're for the same me_module. Allow basic config to |
| mix with any other. */ |
| new_partial = (new_flags & EF_MEP_INDEX_MASK); |
| old_partial = (old_flags & EF_MEP_INDEX_MASK); |
| if (new_partial == old_partial) |
| ; |
| else if (new_partial == 0) |
| ; |
| else if (old_partial == 0) |
| old_flags = (old_flags & ~EF_MEP_INDEX_MASK) | new_partial; |
| else |
| { |
| /* 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; |
| } |
| } |
| |
| elf_elfheader (obfd)->e_flags = old_flags; |
| last_ibfd = ibfd; |
| return true; |
| } |
| |
| /* This will be edited by the MeP configration tool. */ |
| static const char * config_names[] = |
| { |
| "basic" |
| /* start-mepcfgtool */ |
| ,"default" |
| /* end-mepcfgtool */ |
| }; |
| |
| static const char * core_names[] = |
| { |
| "MeP", "MeP-c2", "MeP-c3", "MeP-h1" |
| }; |
| |
| static bool |
| mep_elf_print_private_bfd_data (bfd * abfd, void * ptr) |
| { |
| FILE * file = (FILE *) ptr; |
| flagword flags, partial_flags; |
| |
| BFD_ASSERT (abfd != NULL && ptr != NULL); |
| |
| /* Print normal ELF private data. */ |
| _bfd_elf_print_private_bfd_data (abfd, ptr); |
| |
| flags = elf_elfheader (abfd)->e_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)) |
| fprintf (file, " core: %s", core_names[(long)partial_flags]); |
| |
| partial_flags = flags & EF_MEP_INDEX_MASK; |
| if (partial_flags < ARRAY_SIZE (config_names)) |
| fprintf (file, " me_module: %s", config_names[(long)partial_flags]); |
| |
| fputc ('\n', file); |
| |
| return true; |
| } |
| |
| /* Return the machine subcode from the ELF e_flags header. */ |
| |
| static int |
| elf32_mep_machine (bfd * abfd) |
| { |
| switch (elf_elfheader (abfd)->e_flags & EF_MEP_CPU_MASK) |
| { |
| default: break; |
| 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 bool |
| mep_elf_object_p (bfd * abfd) |
| { |
| bfd_default_set_arch_mach (abfd, bfd_arch_mep, elf32_mep_machine (abfd)); |
| return true; |
| } |
| |
| static bool |
| mep_elf_section_flags (const Elf_Internal_Shdr *hdr) |
| { |
| if (hdr->sh_flags & SHF_MEP_VLIW) |
| hdr->bfd_section->flags |= SEC_MEP_VLIW; |
| return true; |
| } |
| |
| static bool |
| mep_elf_fake_sections (bfd * abfd ATTRIBUTE_UNUSED, |
| Elf_Internal_Shdr * hdr, |
| asection * sec) |
| { |
| if (sec->flags & SEC_MEP_VLIW) |
| hdr->sh_flags |= SHF_MEP_VLIW; |
| return true; |
| } |
| |
| |
| #define ELF_ARCH bfd_arch_mep |
| #define ELF_MACHINE_CODE EM_CYGNUS_MEP |
| #define ELF_MAXPAGESIZE 0x1000 |
| |
| #define TARGET_BIG_SYM mep_elf32_vec |
| #define TARGET_BIG_NAME "elf32-mep" |
| |
| #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_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 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_merge_private_bfd_data mep_elf_merge_private_bfd_data |
| #define bfd_elf32_bfd_print_private_bfd_data mep_elf_print_private_bfd_data |
| |
| #define elf_backend_rela_normal 1 |
| |
| #include "elf32-target.h" |