/* Zilog (e)Z80-specific support for 32-bit ELF

   Copyright (C) 1999-2025 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"