/src/binutils-gdb/bfd/coff-aarch64.c

Source (jump to first uncovered line)
/* BFD back-end for AArch64 COFF files.
   Copyright (C) 2021-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.  */


#ifndef COFF_WITH_peAArch64
#define COFF_WITH_peAArch64
#endif

#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include "coff/aarch64.h"
#include "coff/internal.h"
#include "coff/pe.h"
#include "libcoff.h"
#include "libiberty.h"

/* For these howto special functions,
   output_bfd == NULL => final link, or objdump -W and other calls to
   bfd_simple_get_relocated_section_contents
   output_bfd != NULL && output_bfd != abfd => ld -r
   output_bfd != NULL && output_bfd == abfd => gas.
   FIXME: ld -r is punted to bfd_perform_relocation.  This won't be
   correct for cases where the addend needs to be adjusted, eg. for
   relocations against section symbols, and the field is split because
   bfd_perform_relocation can't write addends to split relocation fields.  */

static bfd_reloc_status_type
coff_aarch64_rel21_reloc (bfd *abfd,
        arelent *reloc_entry,
        asymbol *symbol,
        void *data,
        asection *input_section,
        bfd *output_bfd,
        char **error_message ATTRIBUTE_UNUSED)
{
  if (output_bfd != NULL && output_bfd != abfd)
    return bfd_reloc_continue;

  if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
          input_section, reloc_entry->address))
    return bfd_reloc_outofrange;

  uint32_t op = bfd_getl32 (data + reloc_entry->address);
  bfd_vma relocation = reloc_entry->addend;
  bfd_reloc_status_type ret = bfd_reloc_ok;
  if (output_bfd == NULL)
    {
      if (bfd_is_und_section (symbol->section))
  {
    if ((symbol->flags & BSF_WEAK) == 0)
      ret = bfd_reloc_undefined;
  }
      else if (!bfd_is_com_section (symbol->section))
  relocation += (symbol->value
           + symbol->section->output_offset
           + symbol->section->output_section->vma);
      bfd_vma addend = ((op >> 3) & 0x1ffffc) | ((op >> 29) & 0x3);
      addend = (addend ^ 0x100000) - 0x100000;
      relocation += addend;
      relocation -= (reloc_entry->address
         + input_section->output_offset
         + input_section->output_section->vma);
      relocation = (bfd_signed_vma) relocation >> reloc_entry->howto->rightshift;
    }
  if (relocation + 0x100000 > 0x1fffff)
    ret = bfd_reloc_overflow;

  op &= 0x9f00001f;
  op |= (relocation & 0x1ffffc) << 3;
  op |= (relocation & 0x3) << 29;

  bfd_putl32 (op, data + reloc_entry->address);

  return ret;
}

static bfd_reloc_status_type
coff_aarch64_po12l_reloc (bfd *abfd,
        arelent *reloc_entry,
        asymbol *symbol ATTRIBUTE_UNUSED,
        void *data,
        asection *input_section,
        bfd *output_bfd,
        char **error_message ATTRIBUTE_UNUSED)
{
  if (output_bfd != NULL && output_bfd != abfd)
    return bfd_reloc_continue;

  if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
          input_section, reloc_entry->address))
    return bfd_reloc_outofrange;

  uint32_t op = bfd_getl32 (data + reloc_entry->address);
  bfd_vma relocation = reloc_entry->addend & 0xfff;
  int shift;

  if ((op & 0xff800000) == 0x3d800000)
    {
      /* LDR / STR with q register */
      shift = 4;
    }
  else
    {
      /* top two bits represent how much addend should be shifted */
      shift = op >> 30;
    }

  bfd_reloc_status_type ret = bfd_reloc_ok;
  if (output_bfd == NULL)
    {
      if (bfd_is_und_section (symbol->section))
  {
    if ((symbol->flags & BSF_WEAK) == 0)
      ret = bfd_reloc_undefined;
  }
      else if (!bfd_is_com_section (symbol->section))
  relocation += (symbol->value
           + symbol->section->output_offset
           + symbol->section->output_section->vma);
      bfd_vma addend = (op >> 10) & 0xfff;
      addend <<= shift;
      relocation += addend;
    }

  if (relocation & ((1 << shift) - 1))
    ret = bfd_reloc_overflow;

  op &= 0xffc003ff;
  op |= (relocation >> shift << 10) & 0x3ffc00;

  bfd_putl32 (op, data + reloc_entry->address);

  return ret;
}

static bfd_reloc_status_type
coff_aarch64_addr32nb_reloc (bfd *abfd,
           arelent *reloc_entry,
           asymbol *symbol ATTRIBUTE_UNUSED,
           void *data,
           asection *input_section,
           bfd *output_bfd,
           char **error_message)
{
  if (output_bfd != NULL && output_bfd != abfd)
    return bfd_reloc_continue;

  if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
          input_section, reloc_entry->address))
    return bfd_reloc_outofrange;

  bfd_vma relocation = reloc_entry->addend;
  bfd_reloc_status_type ret = bfd_reloc_ok;
  if (output_bfd == NULL)
    {
      if (bfd_is_und_section (symbol->section))
  {
    if ((symbol->flags & BSF_WEAK) == 0)
      ret = bfd_reloc_undefined;
  }
      else if (!bfd_is_com_section (symbol->section))
  relocation += (symbol->value
           + symbol->section->output_offset
           + symbol->section->output_section->vma);
      bfd_vma addend = bfd_getl_signed_32 (data + reloc_entry->address);
      relocation += addend;
      bfd *obfd = input_section->output_section->owner;
      if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
    && obj_pe (obfd))
  relocation -= pe_data (obfd)->pe_opthdr.ImageBase;
      else
  {
    *error_message = "unsupported";
    return bfd_reloc_dangerous;
  }
    }

  if (relocation + 0x80000000 > 0xffffffff)
    ret = bfd_reloc_overflow;

  bfd_putl32 (relocation, data + reloc_entry->address);

  return ret;
}

static bfd_reloc_status_type
coff_aarch64_secrel_reloc (bfd *abfd,
         arelent *reloc_entry,
         asymbol *symbol ATTRIBUTE_UNUSED,
         void *data,
         asection *input_section,
         bfd *output_bfd,
         char **error_message ATTRIBUTE_UNUSED)
{
  if (output_bfd != NULL && output_bfd != abfd)
    return bfd_reloc_continue;

  if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
          input_section, reloc_entry->address))
    return bfd_reloc_outofrange;

  bfd_vma relocation = reloc_entry->addend;
  bfd_reloc_status_type ret = bfd_reloc_ok;
  if (output_bfd == NULL)
    {
      if (bfd_is_und_section (symbol->section))
  {
    if ((symbol->flags & BSF_WEAK) == 0)
      ret = bfd_reloc_undefined;
  }
      else if (!bfd_is_com_section (symbol->section))
  relocation += (symbol->value
           + symbol->section->output_offset);
      bfd_vma addend = bfd_getl_signed_32 (data + reloc_entry->address);
      relocation += addend;
    }
  if (relocation > 0xffffffff)
    ret = bfd_reloc_overflow;

  bfd_putl32 (relocation, data + reloc_entry->address);

  return ret;
}

#define coff_aarch64_NULL NULL
#undef HOWTO_INSTALL_ADDEND
#define HOWTO_INSTALL_ADDEND 1
#define HOW(type, right, size, bits, pcrel, left, ovf, func, mask) \
  HOWTO (type, right, size, bits, pcrel, left, complain_overflow_##ovf, \
   coff_aarch64_##func, #type, true, mask, mask, false)

static const reloc_howto_type arm64_reloc_howto_abs
= HOW (IMAGE_REL_ARM64_ABSOLUTE,
       0, 0, 0, false, 0, dont, NULL, 0);

static const reloc_howto_type arm64_reloc_howto_64
= HOW (IMAGE_REL_ARM64_ADDR64,
       0, 8, 64, false, 0, dont, NULL, UINT64_C (-1));

static const reloc_howto_type arm64_reloc_howto_32
= HOW (IMAGE_REL_ARM64_ADDR32,
       0, 4, 32, false, 0, signed, NULL, 0xffffffff);

static const reloc_howto_type arm64_reloc_howto_32_pcrel
= HOW (IMAGE_REL_ARM64_REL32,
       0, 4, 32, true, 0, signed, NULL, 0xffffffff);

static const reloc_howto_type arm64_reloc_howto_branch26
= HOW (IMAGE_REL_ARM64_BRANCH26,
       2, 4, 26, true, 0, signed, NULL, 0x3ffffff);

static const reloc_howto_type arm64_reloc_howto_page21
= HOW (IMAGE_REL_ARM64_PAGEBASE_REL21,
       12, 4, 21, true, 0, signed, rel21_reloc, 0x1fffff);

static const reloc_howto_type arm64_reloc_howto_lo21
= HOW (IMAGE_REL_ARM64_REL21,
       0, 4, 21, true, 0, signed, rel21_reloc, 0x1fffff);

static const reloc_howto_type arm64_reloc_howto_pgoff12l
= HOW (IMAGE_REL_ARM64_PAGEOFFSET_12L,
       0, 4, 12, true, 10, signed, po12l_reloc, 0x3ffc00);

static const reloc_howto_type arm64_reloc_howto_branch19
= HOW (IMAGE_REL_ARM64_BRANCH19,
       2, 4, 19, true, 5, signed, NULL, 0xffffe0);

static const reloc_howto_type arm64_reloc_howto_branch14
= HOW (IMAGE_REL_ARM64_BRANCH14,
       2, 4, 14, true, 5, signed, NULL, 0x7ffe0);

static const reloc_howto_type arm64_reloc_howto_pgoff12a
= HOW (IMAGE_REL_ARM64_PAGEOFFSET_12A,
       0, 4, 12, true, 10, dont, NULL, 0x3ffc00);

static const reloc_howto_type arm64_reloc_howto_32nb
= HOW (IMAGE_REL_ARM64_ADDR32NB,
       0, 4, 32, false, 0, signed, addr32nb_reloc, 0xffffffff);

static const reloc_howto_type arm64_reloc_howto_secrel
= HOW (IMAGE_REL_ARM64_SECREL,
       0, 4, 32, false, 0, dont, secrel_reloc, 0xffffffff);

static const reloc_howto_type arm64_reloc_howto_secidx
= HOW (IMAGE_REL_ARM64_SECTION,
       0, 2, 16, false, 0, dont, NULL, 0xffff);

static const reloc_howto_type* const arm64_howto_table[] = {
     &arm64_reloc_howto_abs,
     &arm64_reloc_howto_64,
     &arm64_reloc_howto_32,
     &arm64_reloc_howto_32_pcrel,
     &arm64_reloc_howto_branch26,
     &arm64_reloc_howto_page21,
     &arm64_reloc_howto_lo21,
     &arm64_reloc_howto_pgoff12l,
     &arm64_reloc_howto_branch19,
     &arm64_reloc_howto_branch14,
     &arm64_reloc_howto_pgoff12a,
     &arm64_reloc_howto_32nb,
     &arm64_reloc_howto_secrel,
     &arm64_reloc_howto_secidx
};

/* No adjustment to addends should be needed.  The actual relocation
   addend is in the section contents.  Unfortunately this means actual
   addends are not shown by objdump -r, but that's true for most
   COFF/PE targets where arelent.addend is an adjustment.  */
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)    \
  cache_ptr->addend = 0;

#ifndef NUM_ELEM
#define NUM_ELEM(a) ((sizeof (a)) / sizeof ((a)[0]))
#endif

#define NUM_RELOCS NUM_ELEM (arm64_howto_table)

#define coff_bfd_reloc_type_lookup    coff_aarch64_reloc_type_lookup
#define coff_bfd_reloc_name_lookup    coff_aarch64_reloc_name_lookup

static reloc_howto_type *
coff_aarch64_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
{
  switch (code)
  {
  case BFD_RELOC_64:
    return &arm64_reloc_howto_64;
  case BFD_RELOC_32:
    return &arm64_reloc_howto_32;
  case BFD_RELOC_32_PCREL:
    return &arm64_reloc_howto_32_pcrel;
  case BFD_RELOC_AARCH64_CALL26:
  case BFD_RELOC_AARCH64_JUMP26:
    return &arm64_reloc_howto_branch26;
  case BFD_RELOC_AARCH64_ADR_HI21_PCREL:
  case BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL:
  case BFD_RELOC_AARCH64_ADR_GOT_PAGE:
    return &arm64_reloc_howto_page21;
  case BFD_RELOC_AARCH64_TSTBR14:
    return &arm64_reloc_howto_branch14;
  case BFD_RELOC_AARCH64_ADR_LO21_PCREL:
    return &arm64_reloc_howto_lo21;
  case BFD_RELOC_AARCH64_ADD_LO12:
    return &arm64_reloc_howto_pgoff12a;
  case BFD_RELOC_AARCH64_LDST8_LO12:
  case BFD_RELOC_AARCH64_LDST16_LO12:
  case BFD_RELOC_AARCH64_LDST32_LO12:
  case BFD_RELOC_AARCH64_LDST64_LO12:
  case BFD_RELOC_AARCH64_LDST128_LO12:
  case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC:
    return &arm64_reloc_howto_pgoff12l;
  case BFD_RELOC_AARCH64_BRANCH19:
    return &arm64_reloc_howto_branch19;
  case BFD_RELOC_RVA:
    return &arm64_reloc_howto_32nb;
  case BFD_RELOC_32_SECREL:
    return &arm64_reloc_howto_secrel;
  case BFD_RELOC_16_SECIDX:
    return &arm64_reloc_howto_secidx;
  default:
    BFD_FAIL ();
    return NULL;
  }

  return NULL;
}

static reloc_howto_type *
coff_aarch64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
          const char *r_name)
{
  unsigned int i;

  for (i = 0; i < NUM_RELOCS; i++)
    if (arm64_howto_table[i]->name != NULL
      && strcasecmp (arm64_howto_table[i]->name, r_name) == 0)
      return arm64_howto_table[i];

  return NULL;
}

#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER  2
#define COFF_PAGE_SIZE            0x1000

static reloc_howto_type *
coff_aarch64_rtype_lookup (unsigned int code)
{
  switch (code)
  {
    case IMAGE_REL_ARM64_ABSOLUTE:
      return &arm64_reloc_howto_abs;
    case IMAGE_REL_ARM64_ADDR64:
      return &arm64_reloc_howto_64;
    case IMAGE_REL_ARM64_ADDR32:
      return &arm64_reloc_howto_32;
    case IMAGE_REL_ARM64_REL32:
      return &arm64_reloc_howto_32_pcrel;
    case IMAGE_REL_ARM64_BRANCH26:
      return &arm64_reloc_howto_branch26;
    case IMAGE_REL_ARM64_PAGEBASE_REL21:
      return &arm64_reloc_howto_page21;
    case IMAGE_REL_ARM64_REL21:
      return &arm64_reloc_howto_lo21;
    case IMAGE_REL_ARM64_PAGEOFFSET_12L:
      return &arm64_reloc_howto_pgoff12l;
    case IMAGE_REL_ARM64_BRANCH19:
      return &arm64_reloc_howto_branch19;
    case IMAGE_REL_ARM64_BRANCH14:
      return &arm64_reloc_howto_branch14;
    case IMAGE_REL_ARM64_PAGEOFFSET_12A:
      return &arm64_reloc_howto_pgoff12a;
    case IMAGE_REL_ARM64_ADDR32NB:
      return &arm64_reloc_howto_32nb;
    case IMAGE_REL_ARM64_SECREL:
      return &arm64_reloc_howto_secrel;
    case IMAGE_REL_ARM64_SECTION:
      return &arm64_reloc_howto_secidx;
    default:
      return NULL;
  }

  return NULL;
}

#define RTYPE2HOWTO(cache_ptr, dst)         \
  ((cache_ptr)->howto = coff_aarch64_rtype_lookup((dst)->r_type))

static reloc_howto_type *
coff_aarch64_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
           asection *sec ATTRIBUTE_UNUSED,
           struct internal_reloc *rel,
           struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
           struct internal_syment *sym ATTRIBUTE_UNUSED,
           bfd_vma *addendp)
{
  reloc_howto_type *howto = coff_aarch64_rtype_lookup (rel->r_type);

  /* Cancel out code in _bfd_coff_generic_relocate_section.  */
  *addendp = 0;

  return howto;
}

#define coff_rtype_to_howto coff_aarch64_rtype_to_howto

#define SELECT_RELOC(x,howto) { (x).r_type = (howto)->type; }

#ifndef bfd_pe_print_pdata
#define bfd_pe_print_pdata      NULL
#endif

#ifdef COFF_WITH_PE
/* Return TRUE if this relocation should
   appear in the output .reloc section.  */

static bool
in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED,
            reloc_howto_type * howto)
{
  return !howto->pc_relative;
}
#endif

static bool
coff_pe_aarch64_relocate_section (bfd *output_bfd,
          struct bfd_link_info *info,
          bfd *input_bfd,
          asection *input_section,
          bfd_byte *contents,
          struct internal_reloc *relocs,
          struct internal_syment *syms,
          asection **sections)
{
  struct internal_reloc *rel;
  struct internal_reloc *relend;

  if (bfd_link_relocatable (info))
    return true;

  rel = relocs;
  relend = rel + input_section->reloc_count;

  /* The addend for a relocation is stored in the immediate bits of each
     opcode.  So for each relocation, we need to extract the immediate value,
     use this to calculate what it should be for the symbol, and rewrite the
     opcode into the section stream.  */

  for (; rel < relend; rel++)
    {
      long symndx;
      struct coff_link_hash_entry *h;
      bfd_vma sym_value;
      asection *sec = NULL;
      uint64_t dest_vma;

      /* skip trivial relocations */
      if (rel->r_type == IMAGE_REL_ARM64_ADDR32
    || rel->r_type == IMAGE_REL_ARM64_ADDR64
    || rel->r_type == IMAGE_REL_ARM64_ABSOLUTE)
  continue;

      symndx = rel->r_symndx;
      sym_value = syms[symndx].n_value;

      h = obj_coff_sym_hashes (input_bfd)[symndx];

      if (h && h->root.type == bfd_link_hash_defined)
  {
    sec = h->root.u.def.section;
    sym_value = h->root.u.def.value;
  }
      else
  {
    sec = sections[symndx];
  }

      if (!sec)
  continue;

      if (bfd_is_und_section (sec))
  continue;

      if (discarded_section (sec))
  continue;

      dest_vma = sec->output_section->vma + sec->output_offset + sym_value;

      if (symndx < 0
    || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
  continue;

      /* All the relocs handled below operate on 4 bytes.  */
      if (input_section->size < rel->r_vaddr
    || input_section->size - rel->r_vaddr < 4)
  {
    _bfd_error_handler
      /* xgettext: c-format */
      (_("%pB: bad reloc address %#" PRIx64 " in section `%pA'"),
       input_bfd, (uint64_t) rel->r_vaddr, input_section);
    continue;
  }

      switch (rel->r_type)
  {
  case IMAGE_REL_ARM64_ADDR32NB:
    {
      uint64_t val;
      int32_t addend;

      addend = bfd_getl32 (contents + rel->r_vaddr);

      dest_vma += addend;

      val = dest_vma;
      val -= pe_data (output_bfd)->pe_opthdr.ImageBase;

      if (val > 0xffffffff)
        (*info->callbacks->reloc_overflow)
    (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
    "IMAGE_REL_ARM64_ADDR32NB", addend, input_bfd,
    input_section, rel->r_vaddr - input_section->vma);

      bfd_putl32 (val, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_BRANCH26:
    {
      uint64_t cur_vma;
      uint32_t opcode;
      int64_t addend, val;

      opcode = bfd_getl32 (contents + rel->r_vaddr);

      addend = (opcode & 0x3ffffff) << 2;

      if (addend & 0x8000000)
        addend |= 0xfffffffff0000000;

      dest_vma += addend;
      cur_vma = input_section->output_section->vma
          + input_section->output_offset
          + rel->r_vaddr;

      val = (dest_vma >> 2) - (cur_vma >> 2);

      if (val > 0x1ffffff || val < -0x2000000)
        (*info->callbacks->reloc_overflow)
    (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
    "IMAGE_REL_ARM64_BRANCH26", addend, input_bfd,
    input_section, rel->r_vaddr - input_section->vma);

      opcode &= 0xfc000000;
      opcode |= val & 0x3ffffff;

      bfd_putl32 (opcode, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_BRANCH19:
    {
      uint64_t cur_vma;
      uint32_t opcode;
      int64_t addend, val;

      opcode = bfd_getl32 (contents + rel->r_vaddr);

      addend = (opcode & 0xffffe0) >> 3;

      if (addend & 0x100000)
        addend |= 0xffffffffffe00000;

      dest_vma += addend;
      cur_vma = input_section->output_section->vma
          + input_section->output_offset
          + rel->r_vaddr;

      val = (dest_vma >> 2) - (cur_vma >> 2);

      if (val > 0x3ffff || val < -0x40000)
        (*info->callbacks->reloc_overflow)
    (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
    "IMAGE_REL_ARM64_BRANCH19", addend, input_bfd,
    input_section, rel->r_vaddr - input_section->vma);

      opcode &= 0xff00001f;
      opcode |= (val & 0x7ffff) << 5;

      bfd_putl32 (opcode, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_BRANCH14:
    {
      uint64_t cur_vma;
      uint32_t opcode;
      int64_t addend, val;

      opcode = bfd_getl32 (contents + rel->r_vaddr);

      addend = (opcode & 0x7ffe0) >> 3;

      if (addend & 0x8000)
        addend |= 0xffffffffffff0000;

      dest_vma += addend;
      cur_vma = input_section->output_section->vma
          + input_section->output_offset
          + rel->r_vaddr;

      val = (dest_vma >> 2) - (cur_vma >> 2);

      if (val > 0x1fff || val < -0x2000)
        (*info->callbacks->reloc_overflow)
    (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
    "IMAGE_REL_ARM64_BRANCH14", addend, input_bfd,
    input_section, rel->r_vaddr - input_section->vma);

      opcode &= 0xfff8001f;
      opcode |= (val & 0x3fff) << 5;

      bfd_putl32 (opcode, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_PAGEBASE_REL21:
    {
      uint64_t cur_vma;
      uint32_t opcode;
      int64_t addend, val;

      opcode = bfd_getl32 (contents + rel->r_vaddr);

      addend = ((opcode & 0xffffe0) >> 3)
         | ((opcode & 0x60000000) >> 29);

      if (addend & 0x100000)
        addend |= 0xffffffffffe00000;

      dest_vma += addend;
      cur_vma = input_section->output_section->vma
          + input_section->output_offset
          + rel->r_vaddr;

      val = (dest_vma >> 12) - (cur_vma >> 12);

      if (val > 0xfffff || val < -0x100000)
        (*info->callbacks->reloc_overflow)
    (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
    "IMAGE_REL_ARM64_PAGEBASE_REL21", addend, input_bfd,
    input_section, rel->r_vaddr - input_section->vma);

      opcode &= 0x9f00001f;
      opcode |= (val & 0x3) << 29;
      opcode |= (val & 0x1ffffc) << 3;

      bfd_putl32 (opcode, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_REL21:
    {
      uint64_t cur_vma;
      uint32_t opcode;
      int64_t addend, val;

      opcode = bfd_getl32 (contents + rel->r_vaddr);

      addend = ((opcode & 0xffffe0) >> 3)
         | ((opcode & 0x60000000) >> 29);

      if (addend & 0x100000)
        addend |= 0xffffffffffe00000;

      dest_vma += addend;
      cur_vma = input_section->output_section->vma
          + input_section->output_offset
          + rel->r_vaddr;

      val = dest_vma - cur_vma;

      if (val > 0xfffff || val < -0x100000)
        (*info->callbacks->reloc_overflow)
    (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
    "IMAGE_REL_ARM64_REL21", addend, input_bfd,
    input_section, rel->r_vaddr - input_section->vma);

      opcode &= 0x9f00001f;
      opcode |= (val & 0x3) << 29;
      opcode |= (val & 0x1ffffc) << 3;

      bfd_putl32 (opcode, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_REL32:
    {
      uint64_t cur_vma;
      int64_t addend, val;

      addend = bfd_getl32 (contents + rel->r_vaddr);

      if (addend & 0x80000000)
        addend |= 0xffffffff00000000;

      dest_vma += addend;
      cur_vma = input_section->output_section->vma
          + input_section->output_offset
          + rel->r_vaddr;

      val = dest_vma - cur_vma;

      if (val > 0xffffffff || val < -0x100000000)
        (*info->callbacks->reloc_overflow)
    (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
    "IMAGE_REL_ARM64_REL32", addend, input_bfd,
    input_section, rel->r_vaddr - input_section->vma);

      bfd_putl32 (val, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_PAGEOFFSET_12L:
    {
      uint32_t opcode, val;
      uint8_t shift;
      int32_t addend;

      opcode = bfd_getl32 (contents + rel->r_vaddr);

      addend = (opcode & 0x3ffc00) >> 10;

      if ((opcode & 0xff800000) == 0x3d800000)
        {
    /* LDR / STR with q register */
    shift = 4;
        }
      else
        {
    /* top two bits represent how much addend should be shifted */
    shift = opcode >> 30;
        }

      addend <<= shift;

      dest_vma += addend;

      /* only interested in bottom 12 bits */
      val = dest_vma & 0xfff;

      if (val & ((1 << shift) - 1))
        (*info->callbacks->reloc_overflow)
    (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
    "IMAGE_REL_ARM64_PAGEOFFSET_12L", addend, input_bfd,
    input_section, rel->r_vaddr - input_section->vma);

      val >>= shift;

      opcode &= 0xffc003ff;
      opcode |= val << 10;

      bfd_putl32 (opcode, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_PAGEOFFSET_12A:
    {
      uint32_t opcode, val;
      int32_t addend;

      opcode = bfd_getl32 (contents + rel->r_vaddr);

      addend = (opcode & 0x3ffc00) >> 10;

      dest_vma += addend;

      /* only interested in bottom 12 bits */
      val = dest_vma & 0xfff;

      opcode &= 0xffc003ff;
      opcode |= val << 10;

      bfd_putl32 (opcode, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_SECREL:
    {
      uint64_t val;
      int32_t addend;

      addend = bfd_getl32 (contents + rel->r_vaddr);

      val = sec->output_offset + sym_value + addend;

      if (val > 0xffffffff)
        (*info->callbacks->reloc_overflow)
    (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
    "IMAGE_REL_ARM64_SECREL", addend, input_bfd,
    input_section, rel->r_vaddr - input_section->vma);

      bfd_putl32 (val, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  case IMAGE_REL_ARM64_SECTION:
    {
      uint16_t idx = 0, i = 1;
      asection *s;

      s = output_bfd->sections;
      while (s)
        {
    if (s == sec->output_section)
      {
        idx = i;
        break;
      }

    i++;
    s = s->next;
        }


      bfd_putl16 (idx, contents + rel->r_vaddr);
      rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;

      break;
    }

  default:
    info->callbacks->einfo (_("%F%P: Unhandled relocation type %u\n"),
          rel->r_type);
    BFD_FAIL ();
    return false;
  }
    }

  return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
               input_section, contents,
               relocs, syms, sections);
}

#define coff_relocate_section coff_pe_aarch64_relocate_section

#include "coffcode.h"

/* Prevent assertion in md_apply_fix by forcing use_rela_p on for new
   sections.  */
static bool
coff_aarch64_new_section_hook (bfd *abfd, asection *section)
{
  if (!coff_new_section_hook (abfd, section))
    return false;

  section->use_rela_p = 1;

  return true;
}

#define coff_aarch64_close_and_cleanup coff_close_and_cleanup
#define coff_aarch64_bfd_free_cached_info coff_bfd_free_cached_info
#define coff_aarch64_get_section_contents coff_get_section_contents

/* Target vectors.  */
const bfd_target
#ifdef TARGET_SYM
  TARGET_SYM =
#else
# error "target symbol name not specified"
#endif
{
#ifdef TARGET_NAME
  TARGET_NAME,
#else
# error "target name not specified"
#endif
  bfd_target_coff_flavour,
  BFD_ENDIAN_LITTLE,    /* Data byte order is little.  */
  BFD_ENDIAN_LITTLE,    /* Header byte order is little.  */

  (HAS_RELOC | EXEC_P   /* Object flags.  */
   | HAS_LINENO | HAS_DEBUG
   | HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | BFD_COMPRESS | BFD_DECOMPRESS),

  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* Section flags.  */
#if defined(COFF_WITH_PE)
   | SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY | SEC_DEBUGGING
#endif
   | SEC_CODE | SEC_DATA | SEC_EXCLUDE ),

#ifdef TARGET_UNDERSCORE
  TARGET_UNDERSCORE,    /* Leading underscore.  */
#else
  0,        /* Leading underscore.  */
#endif
  '/',        /* Ar_pad_char.  */
  15,       /* Ar_max_namelen.  */
  0,        /* match priority.  */
  TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */

  /* Data conversion functions.  */
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
  /* Header conversion functions.  */
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Hdrs.  */

  /* Note that we allow an object file to be treated as a core file as well.  */
  {       /* bfd_check_format.  */
    _bfd_dummy_target,
    coff_object_p,
    bfd_generic_archive_p,
    coff_object_p
  },
  {       /* bfd_set_format.  */
    _bfd_bool_bfd_false_error,
    coff_mkobject,
    _bfd_generic_mkarchive,
    _bfd_bool_bfd_false_error
  },
  {       /* bfd_write_contents.  */
    _bfd_bool_bfd_false_error,
    coff_write_object_contents,
    _bfd_write_archive_contents,
    _bfd_bool_bfd_false_error
  },

  BFD_JUMP_TABLE_GENERIC (coff_aarch64),
  BFD_JUMP_TABLE_COPY (coff),
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
  BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
  BFD_JUMP_TABLE_SYMBOLS (coff),
  BFD_JUMP_TABLE_RELOCS (coff),
  BFD_JUMP_TABLE_WRITE (coff),
  BFD_JUMP_TABLE_LINK (coff),
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),

  NULL,

  COFF_SWAP_TABLE
};

Coverage Report

Created: 2024-05-21 06:29