mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-12-09 04:21:49 +08:00
Code Issues Packages Projects Releases Wiki Activity
7b9cfd7f3d
binutils-gdb/bfd/coff-aarch64.c
Alan Modra af92590521 Remove bfdwin.c 
In commit b86d3af60f and 0ab0435fe6 I fixed SIGBUS errors found by
oss-fuzz now that --with-mmap defaults to enabled.  It turns out there
are further problems with the aout mmap code: aout_read_minisymbols
returns the external symbol array, which is later freed by nm.c.  If
the array is mmaped you can't free it.  Now this could be fixed by
making aout minisymbols an array of pointers, but I figure there's not
much point in expending effort on that.  So delete the aout mmap
support along with bfdwin.c and get_section_contents_in_window.
2024-04-11 17:05:16 +09:30

1023 lines
27 KiB
C
Raw Blame History

/* 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
};
Reference in New Issue View Git Blame Copy Permalink