/* Zilog (e)Z80-specific support for 32-bit ELF Copyright (C) 1999-2023 Free Software Foundation, Inc. (Heavily copied from the S12Z port by Sergey Belyashov (sergey.belyashov@gmail.com)) 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 "bfdlink.h" #include "libbfd.h" #include "elf-bfd.h" #include "elf/z80.h" /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */ #define OCTETS_PER_BYTE(ABFD, SEC) 1 typedef const struct { bfd_reloc_code_real_type r_type; reloc_howto_type howto; } bfd_howto_type; #define BFD_EMPTY_HOWTO(rt,x) {rt, EMPTY_HOWTO(x)} #define BFD_HOWTO(rt,a,b,c,d,e,f,g,h,i,j,k,l,m) {rt, HOWTO(a,b,c,d,e,f,g,h,i,j,k,l,m)} static bfd_reloc_status_type z80_elf_16_be_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, void *data, asection *input_section, bfd *output_bfd, char **error_message); static const bfd_howto_type elf_z80_howto_table[] = { /* This reloc does nothing. */ BFD_HOWTO (BFD_RELOC_NONE, R_Z80_NONE, /* type */ 0, /* rightshift */ 0, /* size */ 0, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_NONE", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ false), /* pcrel_offset */ /* A 8 bit relocation */ BFD_HOWTO (BFD_RELOC_8, R_Z80_8, /* type */ 0, /* rightshift */ 1, /* size */ 8, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_imm8", /* name */ false, /* partial_inplace */ 0x00, /* src_mask */ 0xff, /* dst_mask */ false), /* pcrel_offset */ /* A 8 bit index register displacement relocation */ BFD_HOWTO (BFD_RELOC_Z80_DISP8, R_Z80_8_DIS, /* type */ 0, /* rightshift */ 1, /* size */ 8, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_off", /* name */ false, /* partial_inplace */ 0x00, /* src_mask */ 0xff, /* dst_mask */ false), /* pcrel_offset */ /* A 8 bit PC-rel relocation */ BFD_HOWTO (BFD_RELOC_8_PCREL, R_Z80_8_PCREL, /* type */ 0, /* rightshift */ 1, /* size */ 8, /* bitsize */ true, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_jr", /* name */ false, /* partial_inplace */ 0x00, /* src_mask */ 0xff, /* dst_mask */ true), /* pcrel_offset */ /* An 16 bit absolute relocation */ BFD_HOWTO (BFD_RELOC_16, R_Z80_16, /* type */ 0, /* rightshift */ 2, /* size */ 16, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_imm16", /* name */ false, /* partial_inplace */ 0x00000000, /* src_mask */ 0x0000ffff, /* dst_mask */ false), /* pcrel_offset */ /* A 24 bit absolute relocation emitted by ADL mode operands */ BFD_HOWTO (BFD_RELOC_24, R_Z80_24, /* type */ 0, /* rightshift */ 3, /* size */ 24, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_imm24", /* name */ false, /* partial_inplace */ 0x00000000, /* src_mask */ 0x00ffffff, /* dst_mask */ false), /* pcrel_offset */ BFD_HOWTO (BFD_RELOC_32, R_Z80_32, /* type */ 0, /* rightshift */ 4, /* size */ 32, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_imm32", /* name */ false, /* partial_inplace */ 0x00000000, /* src_mask */ 0xffffffff, /* dst_mask */ false), /* pcrel_offset */ /* First (lowest) 8 bits of multibyte relocation */ BFD_HOWTO (BFD_RELOC_Z80_BYTE0, R_Z80_BYTE0, /* type */ 0, /* rightshift */ 1, /* size */ 32, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_byte0", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xff, /* dst_mask */ false), /* pcrel_offset */ /* Second 8 bits of multibyte relocation */ BFD_HOWTO (BFD_RELOC_Z80_BYTE1, R_Z80_BYTE1, /* type */ 8, /* rightshift */ 1, /* size */ 32, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_byte1", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xff, /* dst_mask */ false), /* pcrel_offset */ /* Third 8 bits of multibyte relocation */ BFD_HOWTO (BFD_RELOC_Z80_BYTE2, R_Z80_BYTE2, /* type */ 16, /* rightshift */ 1, /* size */ 32, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_byte2", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xff, /* dst_mask */ false), /* pcrel_offset */ /* Fourth (highest) 8 bits of multibyte relocation */ BFD_HOWTO (BFD_RELOC_Z80_BYTE3, R_Z80_BYTE3, /* type */ 24, /* rightshift */ 1, /* size */ 32, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_byte3", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xff, /* dst_mask */ false), /* pcrel_offset */ /* An 16 bit absolute relocation of lower word of multibyte value */ BFD_HOWTO (BFD_RELOC_Z80_WORD0, R_Z80_WORD0, /* type */ 0, /* rightshift */ 2, /* size */ 32, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_word0", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xffff, /* dst_mask */ false), /* pcrel_offset */ /* An 16 bit absolute relocation of higher word of multibyte value */ BFD_HOWTO (BFD_RELOC_Z80_WORD1, R_Z80_WORD1, /* type */ 16, /* rightshift */ 2, /* size */ 32, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "r_word1", /* name */ false, /* partial_inplace */ 0, /* src_mask */ 0xffff, /* dst_mask */ false), /* pcrel_offset */ /* An 16 bit big endian absolute relocation */ BFD_HOWTO (BFD_RELOC_Z80_16_BE, R_Z80_16_BE, /* type */ 0, /* rightshift */ 2, /* size */ 16, /* bitsize */ false, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ z80_elf_16_be_reloc, /* special_function */ "r_imm16be", /* name */ false, /* partial_inplace */ 0x00000000, /* src_mask */ 0x0000ffff, /* dst_mask */ false), /* pcrel_offset */ }; static reloc_howto_type * z80_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code) { enum { table_size = sizeof (elf_z80_howto_table) / sizeof (elf_z80_howto_table[0]) }; unsigned int i; for (i = 0; i < table_size; i++) { if (elf_z80_howto_table[i].r_type == code) return &elf_z80_howto_table[i].howto; } printf ("%s:%d Not found BFD reloc type %d\n", __FILE__, __LINE__, code); return NULL; } static reloc_howto_type * z80_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) { enum { table_size = sizeof (elf_z80_howto_table) / sizeof (elf_z80_howto_table[0]) }; unsigned int i; for (i = 0; i < table_size; i++) { if (elf_z80_howto_table[i].howto.name != NULL && strcasecmp (elf_z80_howto_table[i].howto.name, r_name) == 0) return &elf_z80_howto_table[i].howto; } printf ("%s:%d Not found ELF reloc name `%s'\n", __FILE__, __LINE__, r_name); return NULL; } static reloc_howto_type * z80_rtype_to_howto (bfd *abfd, unsigned r_type) { enum { table_size = sizeof (elf_z80_howto_table) / sizeof (elf_z80_howto_table[0]) }; unsigned int i; for (i = 0; i < table_size; i++) { if (elf_z80_howto_table[i].howto.type == r_type) return &elf_z80_howto_table[i].howto; } /* xgettext:c-format */ _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, r_type); return NULL; } /* Set the howto pointer for an z80 ELF reloc. */ static bool z80_info_to_howto_rela (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst) { unsigned int r_type = ELF32_R_TYPE (dst->r_info); reloc_howto_type *howto = z80_rtype_to_howto (abfd, r_type); if (howto != NULL) { cache_ptr->howto = howto; return true; } bfd_set_error (bfd_error_bad_value); return false; } static bfd_reloc_status_type z80_elf_final_link_relocate (unsigned long r_type, bfd *input_bfd, bfd *output_bfd ATTRIBUTE_UNUSED, asection *input_section ATTRIBUTE_UNUSED, bfd_byte *contents, bfd_vma offset, bfd_vma value, bfd_vma addend, struct bfd_link_info *info ATTRIBUTE_UNUSED, asection *sym_sec ATTRIBUTE_UNUSED, int is_local ATTRIBUTE_UNUSED) { bool r; reloc_howto_type *howto; switch (r_type) { case R_Z80_16_BE: value += addend; bfd_put_8 (input_bfd, value >> 8, contents + offset + 0); bfd_put_8 (input_bfd, value >> 0, contents + offset + 1); return bfd_reloc_ok; } howto = z80_rtype_to_howto (input_bfd, r_type); if (howto == NULL) return bfd_reloc_notsupported; r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents, offset, value, addend); return r ? bfd_reloc_ok : bfd_reloc_notsupported; } static int z80_elf_relocate_section (bfd *output_bfd, 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, *relend; symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; sym_hashes = elf_sym_hashes (input_bfd); rel = relocs; relend = relocs + input_section->reloc_count; for (; rel < relend; rel++) { unsigned int r_type; unsigned long r_symndx; Elf_Internal_Sym *sym; asection *sec; struct elf_link_hash_entry *h; bfd_vma relocation; /* This is a final link. */ r_symndx = ELF32_R_SYM (rel->r_info); r_type = 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); } else { bool unresolved_reloc, warned, ignored; RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, r_symndx, symtab_hdr, sym_hashes, h, sec, relocation, unresolved_reloc, warned, ignored); } if (sec != NULL && discarded_section (sec)) { /* For relocs against symbols from removed linkonce sections, or sections discarded by a linker script, we just want the section contents cleared. Avoid any special processing. */ reloc_howto_type *howto; howto = z80_rtype_to_howto (input_bfd, r_type); RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, rel, 1, relend, howto, 0, contents); } if (bfd_link_relocatable (info)) continue; z80_elf_final_link_relocate (r_type, input_bfd, output_bfd, input_section, contents, rel->r_offset, relocation, rel->r_addend, info, sec, h == NULL); } return true; } /* The final processing done just before writing out a Z80 ELF object file. This gets the Z80 architecture right based on the machine number. */ static bool z80_elf_final_write_processing (bfd *abfd) { unsigned long val = bfd_get_mach (abfd); switch (val) { default: _bfd_error_handler (_("%pB: unsupported bfd mach %#lx"), abfd, val); /* fall through */ case bfd_mach_z80: case bfd_mach_z80full: case bfd_mach_z80strict: val = EF_Z80_MACH_Z80; break; case bfd_mach_gbz80: val = EF_Z80_MACH_GBZ80; break; case bfd_mach_z80n: val = EF_Z80_MACH_Z80N; break; case bfd_mach_z180: val = EF_Z80_MACH_Z180; break; case bfd_mach_ez80_z80: val = EF_Z80_MACH_EZ80_Z80; break; case bfd_mach_ez80_adl: val = EF_Z80_MACH_EZ80_ADL; break; case bfd_mach_r800: val = EF_Z80_MACH_R800; break; } elf_elfheader (abfd)->e_machine = EM_Z80; elf_elfheader (abfd)->e_flags &= ~EF_Z80_MACH_MSK; elf_elfheader (abfd)->e_flags |= val; return _bfd_elf_final_write_processing (abfd); } /* Set the right machine number. */ static bool z80_elf_object_p (bfd *abfd) { unsigned int mach; if (elf_elfheader (abfd)->e_machine == EM_Z80) { int e_mach = elf_elfheader (abfd)->e_flags & EF_Z80_MACH_MSK; switch (e_mach) { default: _bfd_error_handler (_("%pB: unsupported mach %#x"), abfd, e_mach); /* fall through */ case EF_Z80_MACH_Z80: mach = bfd_mach_z80; break; case EF_Z80_MACH_GBZ80: mach = bfd_mach_gbz80; break; case EF_Z80_MACH_Z180: mach = bfd_mach_z180; break; case EF_Z80_MACH_EZ80_Z80: mach = bfd_mach_ez80_z80; break; case EF_Z80_MACH_EZ80_ADL: mach = bfd_mach_ez80_adl; break; case EF_Z80_MACH_R800: mach = bfd_mach_r800; break; case EF_Z80_MACH_Z80N: mach = bfd_mach_z80n; break; } } else { _bfd_error_handler (_("%pB: unsupported arch %#x"), abfd, elf_elfheader (abfd)->e_machine); mach = bfd_mach_z80; } return bfd_default_set_arch_mach (abfd, bfd_arch_z80, mach); } static bool z80_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name) { return (name[0] == '.' && name[1] == 'L') || _bfd_elf_is_local_label_name (abfd, name); } static bfd_reloc_status_type z80_elf_16_be_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, void *data, asection *input_section, bfd *output_bfd, char **error_message) { bfd_vma val; long x; bfd_size_type octets = (reloc_entry->address * OCTETS_PER_BYTE (abfd, input_section)); /* If this is a relocatable link (output_bfd test tells us), just call the generic function. Any adjustment will be done at final link time. */ if (output_bfd != NULL) return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd, error_message); /* Get symbol value. */ val = 0; if (!bfd_is_com_section (symbol->section)) val = symbol->value; val += symbol->section->output_offset + input_section->output_offset; if (symbol->section->output_section) val += symbol->section->output_section->vma; val += reloc_entry->addend; if (reloc_entry->howto->partial_inplace) { x = bfd_get_8 (abfd, (bfd_byte *) data + octets + 0) * 0x100; x += bfd_get_8 (abfd, (bfd_byte *) data + octets + 1); x &= ~reloc_entry->howto->src_mask; } else x = 0; x |= val & reloc_entry->howto->dst_mask; if (x < -0x8000 || x >= 0x10000) return bfd_reloc_outofrange; bfd_put_8 (abfd, x >> 8, (bfd_byte *) data + octets + 0); bfd_put_8 (abfd, x >> 0, (bfd_byte *) data + octets + 1); return bfd_reloc_ok; } #define ELF_ARCH bfd_arch_z80 #define ELF_MACHINE_CODE EM_Z80 #define ELF_MAXPAGESIZE 0x10000 #define TARGET_LITTLE_SYM z80_elf32_vec #define TARGET_LITTLE_NAME "elf32-z80" #define elf_backend_can_refcount 1 #define elf_backend_can_gc_sections 1 #define elf_backend_stack_align 1 #define elf_backend_rela_normal 1 #define elf_info_to_howto z80_info_to_howto_rela #define elf_info_to_howto_rel z80_info_to_howto_rela #define elf_backend_final_write_processing z80_elf_final_write_processing #define elf_backend_object_p z80_elf_object_p #define elf_backend_relocate_section z80_elf_relocate_section #define bfd_elf32_bfd_reloc_type_lookup z80_reloc_type_lookup #define bfd_elf32_bfd_reloc_name_lookup z80_reloc_name_lookup #define bfd_elf32_bfd_is_local_label_name z80_is_local_label_name #include "elf32-target.h"