#ifndef COFF_WITH_pex64
#define COFF_WITH_pex64
#endif
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "coff/x86_64.h"
#include "coff/internal.h"
#include "coff/pe.h"
#include "libcoff.h"
#include "libiberty.h"
#define BADMAG(x) AMD64BADMAG(x)
#ifdef COFF_WITH_pex64
# undef AOUTSZ
# define AOUTSZ PEPAOUTSZ
# define PEAOUTHDR PEPAOUTHDR
#endif
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
#define COFF_PAGE_SIZE 0x1000
static bfd_reloc_status_type
coff_amd64_reloc (bfd *abfd,
arelent *reloc_entry,
asymbol *symbol,
void * data,
asection *input_section ATTRIBUTE_UNUSED,
bfd *output_bfd,
char **error_message ATTRIBUTE_UNUSED)
{
symvalue diff;
#if !defined(COFF_WITH_PE)
if (output_bfd == NULL)
return bfd_reloc_continue;
#endif
if (bfd_is_com_section (symbol->section))
{
#if !defined(COFF_WITH_PE)
diff = symbol->value + reloc_entry->addend;
#else
diff = reloc_entry->addend;
#endif
}
else
{
#if defined(COFF_WITH_PE)
if (output_bfd == NULL)
{
reloc_howto_type *howto = reloc_entry->howto;
if(howto->pc_relative && howto->pcrel_offset)
diff = -(1 << howto->size);
else if(symbol->flags & BSF_WEAK)
diff = reloc_entry->addend - symbol->value;
else
diff = -reloc_entry->addend;
}
else
#endif
diff = reloc_entry->addend;
}
#if defined(COFF_WITH_PE)
if (reloc_entry->howto->type == R_AMD64_IMAGEBASE
&& output_bfd != NULL
&& bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
diff -= pe_data (output_bfd)->pe_opthdr.ImageBase;
#endif
#define DOIT(x) \
x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
if (diff != 0)
{
reloc_howto_type *howto = reloc_entry->howto;
unsigned char *addr = (unsigned char *) data + reloc_entry->address;
switch (howto->size)
{
case 0:
{
char x = bfd_get_8 (abfd, addr);
DOIT (x);
bfd_put_8 (abfd, x, addr);
}
break;
case 1:
{
short x = bfd_get_16 (abfd, addr);
DOIT (x);
bfd_put_16 (abfd, (bfd_vma) x, addr);
}
break;
case 2:
{
long x = bfd_get_32 (abfd, addr);
DOIT (x);
bfd_put_32 (abfd, (bfd_vma) x, addr);
}
break;
case 4:
{
long long x = bfd_get_64 (abfd, addr);
DOIT (x);
bfd_put_64 (abfd, (bfd_vma) x, addr);
}
break;
default:
abort ();
}
}
return bfd_reloc_continue;
}
#if defined(COFF_WITH_PE)
static bfd_boolean
in_reloc_p (bfd *abfd ATTRIBUTE_UNUSED, reloc_howto_type *howto)
{
return ! howto->pc_relative && howto->type != R_AMD64_IMAGEBASE;
}
#endif
#ifndef PCRELOFFSET
#define PCRELOFFSET TRUE
#endif
static reloc_howto_type howto_table[] =
{
EMPTY_HOWTO (0),
HOWTO (R_AMD64_DIR64,
0,
4,
64,
FALSE,
0,
complain_overflow_bitfield,
coff_amd64_reloc,
"R_X86_64_64",
TRUE,
0xffffffffffffffffll,
0xffffffffffffffffll,
TRUE),
HOWTO (R_AMD64_DIR32,
0,
2,
32,
FALSE,
0,
complain_overflow_bitfield,
coff_amd64_reloc,
"R_X86_64_32",
TRUE,
0xffffffff,
0xffffffff,
TRUE),
HOWTO (R_AMD64_IMAGEBASE,
0,
2,
32,
FALSE,
0,
complain_overflow_bitfield,
coff_amd64_reloc,
"rva32",
TRUE,
0xffffffff,
0xffffffff,
FALSE),
HOWTO (R_AMD64_PCRLONG,
0,
2,
32,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"R_X86_64_PC32",
TRUE,
0xffffffff,
0xffffffff,
PCRELOFFSET),
HOWTO (R_AMD64_PCRLONG_1,
0,
2,
32,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"DISP32+1",
TRUE,
0xffffffff,
0xffffffff,
PCRELOFFSET),
HOWTO (R_AMD64_PCRLONG_2,
0,
2,
32,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"DISP32+2",
TRUE,
0xffffffff,
0xffffffff,
PCRELOFFSET),
HOWTO (R_AMD64_PCRLONG_3,
0,
2,
32,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"DISP32+3",
TRUE,
0xffffffff,
0xffffffff,
PCRELOFFSET),
HOWTO (R_AMD64_PCRLONG_4,
0,
2,
32,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"DISP32+4",
TRUE,
0xffffffff,
0xffffffff,
PCRELOFFSET),
HOWTO (R_AMD64_PCRLONG_5,
0,
2,
32,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"DISP32+5",
TRUE,
0xffffffff,
0xffffffff,
PCRELOFFSET),
EMPTY_HOWTO (10),
#if defined(COFF_WITH_PE)
HOWTO (R_AMD64_SECREL,
0,
2,
32,
FALSE,
0,
complain_overflow_bitfield,
coff_amd64_reloc,
"secrel32",
TRUE,
0xffffffff,
0xffffffff,
TRUE),
#else
EMPTY_HOWTO (11),
#endif
EMPTY_HOWTO (12),
EMPTY_HOWTO (13),
#ifndef DONT_EXTEND_AMD64
HOWTO (R_AMD64_PCRQUAD,
0,
4,
64,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"R_X86_64_PC64",
TRUE,
0xffffffffffffffffll,
0xffffffffffffffffll,
PCRELOFFSET),
#else
EMPTY_HOWTO (14),
#endif
HOWTO (R_RELBYTE,
0,
0,
8,
FALSE,
0,
complain_overflow_bitfield,
coff_amd64_reloc,
"R_X86_64_8",
TRUE,
0x000000ff,
0x000000ff,
PCRELOFFSET),
HOWTO (R_RELWORD,
0,
1,
16,
FALSE,
0,
complain_overflow_bitfield,
coff_amd64_reloc,
"R_X86_64_16",
TRUE,
0x0000ffff,
0x0000ffff,
PCRELOFFSET),
HOWTO (R_RELLONG,
0,
2,
32,
FALSE,
0,
complain_overflow_bitfield,
coff_amd64_reloc,
"R_X86_64_32S",
TRUE,
0xffffffff,
0xffffffff,
PCRELOFFSET),
HOWTO (R_PCRBYTE,
0,
0,
8,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"R_X86_64_PC8",
TRUE,
0x000000ff,
0x000000ff,
PCRELOFFSET),
HOWTO (R_PCRWORD,
0,
1,
16,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"R_X86_64_PC16",
TRUE,
0x0000ffff,
0x0000ffff,
PCRELOFFSET),
HOWTO (R_PCRLONG,
0,
2,
32,
TRUE,
0,
complain_overflow_signed,
coff_amd64_reloc,
"R_X86_64_PC32",
TRUE,
0xffffffff,
0xffffffff,
PCRELOFFSET)
};
#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
#define I386 1
#define AMD64 1
#define RTYPE2HOWTO(cache_ptr, dst) \
((cache_ptr)->howto = \
((dst)->r_type < ARRAY_SIZE (howto_table)) \
? howto_table + (dst)->r_type \
: NULL)
#define BSS_NOLOAD_IS_SHARED_LIBRARY
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
{ \
coff_symbol_type *coffsym = NULL; \
\
if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
coffsym = (obj_symbols (abfd) \
+ (cache_ptr->sym_ptr_ptr - symbols)); \
else if (ptr) \
coffsym = coff_symbol_from (abfd, ptr); \
\
if (coffsym != NULL \
&& coffsym->native->u.syment.n_scnum == 0) \
cache_ptr->addend = - coffsym->native->u.syment.n_value; \
else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
&& ptr->section != NULL) \
cache_ptr->addend = - (ptr->section->vma + ptr->value); \
else \
cache_ptr->addend = 0; \
if (ptr && howto_table[reloc.r_type].pc_relative) \
cache_ptr->addend += asect->vma; \
}
#if !defined(COFF_WITH_PE)
#define coff_relocate_section _bfd_coff_generic_relocate_section
#else
static bfd_boolean
coff_pe_amd64_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)
{
if (info->relocatable)
return TRUE;
return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,input_section, contents,relocs, syms, sections);
}
#define coff_relocate_section coff_pe_amd64_relocate_section
#endif
static reloc_howto_type *
coff_amd64_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
asection *sec,
struct internal_reloc *rel,
struct coff_link_hash_entry *h,
struct internal_syment *sym,
bfd_vma *addendp)
{
reloc_howto_type *howto;
if (rel->r_type > ARRAY_SIZE (howto_table))
{
bfd_set_error (bfd_error_bad_value);
return NULL;
}
if (rel->r_type >= R_AMD64_PCRLONG_1 && rel->r_type <= R_AMD64_PCRLONG_5)
{
rel->r_vaddr += (bfd_vma)(rel->r_type-R_AMD64_PCRLONG);
rel->r_type = R_AMD64_PCRLONG;
}
howto = howto_table + rel->r_type;
#if defined(COFF_WITH_PE)
*addendp = 0;
#endif
if (howto->pc_relative)
*addendp += sec->vma;
if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
{
BFD_ASSERT (h != NULL);
#if !defined(COFF_WITH_PE)
*addendp -= sym->n_value;
#endif
}
#if !defined(COFF_WITH_PE)
if (h != NULL && h->root.type == bfd_link_hash_common)
*addendp += h->root.u.c.size;
#endif
#if defined(COFF_WITH_PE)
if (howto->pc_relative)
{
*addendp -= 4;
if (sym != NULL && sym->n_scnum != 0)
*addendp -= sym->n_value;
}
if (rel->r_type == R_AMD64_IMAGEBASE
&& (bfd_get_flavour (sec->output_section->owner) == bfd_target_coff_flavour))
*addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
if (rel->r_type == R_AMD64_SECREL)
{
bfd_vma osect_vma;
if (h && (h->type == bfd_link_hash_defined || h->type == bfd_link_hash_defweak))
osect_vma = h->root.u.def.section->output_section->vma;
else
{
asection *sec;
int i;
for (sec = abfd->sections, i = 1; i < sym->n_scnum; i++)
sec = sec->next;
osect_vma = sec->output_section->vma;
}
*addendp -= osect_vma;
}
#endif
return howto;
}
#define coff_bfd_reloc_type_lookup coff_amd64_reloc_type_lookup
static reloc_howto_type *
coff_amd64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
{
switch (code)
{
case BFD_RELOC_RVA:
return howto_table + R_AMD64_IMAGEBASE;
case BFD_RELOC_32:
return howto_table + R_AMD64_DIR32;
case BFD_RELOC_64:
return howto_table + R_AMD64_DIR64;
case BFD_RELOC_64_PCREL:
#ifndef DONT_EXTEND_AMD64
return howto_table + R_AMD64_PCRQUAD;
#else
#endif
case BFD_RELOC_32_PCREL:
return howto_table + R_AMD64_PCRLONG;
case BFD_RELOC_X86_64_32S:
return howto_table + R_RELLONG;
case BFD_RELOC_16:
return howto_table + R_RELWORD;
case BFD_RELOC_16_PCREL:
return howto_table + R_PCRWORD;
case BFD_RELOC_8:
return howto_table + R_RELBYTE;
case BFD_RELOC_8_PCREL:
return howto_table + R_PCRBYTE;
#if defined(COFF_WITH_PE)
case BFD_RELOC_32_SECREL:
return howto_table + R_AMD64_SECREL;
#endif
default:
BFD_FAIL ();
return 0;
}
}
#define coff_rtype_to_howto coff_amd64_rtype_to_howto
#ifdef TARGET_UNDERSCORE
static bfd_boolean
coff_amd64_is_local_label_name (bfd *abfd, const char *name)
{
if (name[0] == 'L')
return TRUE;
return _bfd_coff_is_local_label_name (abfd, name);
}
#define coff_bfd_is_local_label_name coff_amd64_is_local_label_name
#endif
#include "coffcode.h"
#ifdef PE
#define amd64coff_object_p pe_bfd_object_p
#else
#define amd64coff_object_p coff_object_p
#endif
const bfd_target
#ifdef TARGET_SYM
TARGET_SYM =
#else
x86_64coff_vec =
#endif
{
#ifdef TARGET_NAME
TARGET_NAME,
#else
"coff-x86-64",
#endif
bfd_target_coff_flavour,
BFD_ENDIAN_LITTLE,
BFD_ENDIAN_LITTLE,
(HAS_RELOC | EXEC_P |
HAS_LINENO | HAS_DEBUG |
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC
#if defined(COFF_WITH_PE)
| SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY
#endif
| SEC_CODE | SEC_DATA),
#ifdef TARGET_UNDERSCORE
TARGET_UNDERSCORE,
#else
0,
#endif
'/',
15,
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
bfd_getl16, bfd_getl_signed_16, bfd_putl16,
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
bfd_getl16, bfd_getl_signed_16, bfd_putl16,
{ _bfd_dummy_target, amd64coff_object_p,
bfd_generic_archive_p, amd64coff_object_p },
{ bfd_false, coff_mkobject, _bfd_generic_mkarchive,
bfd_false },
{ bfd_false, coff_write_object_contents,
_bfd_write_archive_contents, bfd_false },
BFD_JUMP_TABLE_GENERIC (coff),
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
};