bfd/coff-x86_64.c

   1 /* BFD back-end for AMD 64 COFF files.
   2    Copyright (C) 2006-2019 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.
  20
  21    Written by Kai Tietz, OneVision Software GmbH&CoKg.  */
  22
  23 #ifndef COFF_WITH_pex64
  24 #define COFF_WITH_pex64
  25 #endif
  26
  27 /* Note we have to make sure not to include headers twice.
  28    Not all headers are wrapped in #ifdef guards, so we define
  29    PEI_HEADERS to prevent double including here.  */
  30 #ifndef PEI_HEADERS
  31 #include "sysdep.h"
  32 #include "bfd.h"
  33 #include "libbfd.h"
  34 #include "coff/x86_64.h"
  35 #include "coff/internal.h"
  36 #include "coff/pe.h"
  37 #include "libcoff.h"
  38 #include "libiberty.h"
  39 #endif
  40
  41 #define BADMAG(x) AMD64BADMAG(x)
  42
  43 #ifdef COFF_WITH_pex64
  44 # undef  AOUTSZ
  45 # define AOUTSZ         PEPAOUTSZ
  46 # define PEAOUTHDR      PEPAOUTHDR
  47 #endif
  48
  49 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
  50
  51 /* The page size is a guess based on ELF.  */
  52
  53 #define COFF_PAGE_SIZE 0x1000
  54
  55 /* For some reason when using AMD COFF the value stored in the .text
  56    section for a reference to a common symbol is the value itself plus
  57    any desired offset.  Ian Taylor, Cygnus Support.  */
  58
  59 /* If we are producing relocatable output, we need to do some
  60    adjustments to the object file that are not done by the
  61    bfd_perform_relocation function.  This function is called by every
  62    reloc type to make any required adjustments.  */
  63
  64 static bfd_reloc_status_type
  65 coff_amd64_reloc (bfd *abfd,
  66                   arelent *reloc_entry,
  67                   asymbol *symbol,
  68                   void * data,
  69                   asection *input_section ATTRIBUTE_UNUSED,
  70                   bfd *output_bfd,
  71                   char **error_message ATTRIBUTE_UNUSED)
  72 {
  73   symvalue diff;
  74
  75 #if !defined(COFF_WITH_PE)
  76   if (output_bfd == NULL)
  77     return bfd_reloc_continue;
  78 #endif
  79
  80   if (bfd_is_com_section (symbol->section))
  81     {
  82 #if !defined(COFF_WITH_PE)
  83       /* We are relocating a common symbol.  The current value in the
  84          object file is ORIG + OFFSET, where ORIG is the value of the
  85          common symbol as seen by the object file when it was compiled
  86          (this may be zero if the symbol was undefined) and OFFSET is
  87          the offset into the common symbol (normally zero, but may be
  88          non-zero when referring to a field in a common structure).
  89          ORIG is the negative of reloc_entry->addend, which is set by
  90          the CALC_ADDEND macro below.  We want to replace the value in
  91          the object file with NEW + OFFSET, where NEW is the value of
  92          the common symbol which we are going to put in the final
  93          object file.  NEW is symbol->value.  */
  94       diff = symbol->value + reloc_entry->addend;
  95 #else
  96       /* In PE mode, we do not offset the common symbol.  */
  97       diff = reloc_entry->addend;
  98 #endif
  99     }
 100   else
 101     {
 102       /* For some reason bfd_perform_relocation always effectively
 103          ignores the addend for a COFF target when producing
 104          relocatable output.  This seems to be always wrong for 386
 105          COFF, so we handle the addend here instead.  */
 106 #if defined(COFF_WITH_PE)
 107       if (output_bfd == NULL)
 108         {
 109           reloc_howto_type *howto = reloc_entry->howto;
 110
 111           /* Although PC relative relocations are very similar between
 112              PE and non-PE formats, but they are off by 1 << howto->size
 113              bytes. For the external relocation, PE is very different
 114              from others. See md_apply_fix3 () in gas/config/tc-amd64.c.
 115              When we link PE and non-PE object files together to
 116              generate a non-PE executable, we have to compensate it
 117              here.  */
 118           if(howto->pc_relative && howto->pcrel_offset)
 119             diff = -(1 << howto->size);
 120           else if(symbol->flags & BSF_WEAK)
 121             diff = reloc_entry->addend - symbol->value;
 122           else
 123             diff = -reloc_entry->addend;
 124         }
 125       else
 126 #endif
 127         diff = reloc_entry->addend;
 128     }
 129
 130 #if defined(COFF_WITH_PE)
 131   /* FIXME: How should this case be handled?  */
 132   if (reloc_entry->howto->type == R_AMD64_IMAGEBASE
 133       && output_bfd != NULL
 134       && bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
 135     diff -= pe_data (output_bfd)->pe_opthdr.ImageBase;
 136 #endif
 137
 138 #define DOIT(x) \
 139   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
 140
 141   if (diff != 0)
 142     {
 143       reloc_howto_type *howto = reloc_entry->howto;
 144       unsigned char *addr = (unsigned char *) data + reloc_entry->address;
 145
 146       if (! bfd_reloc_offset_in_range (howto, abfd, input_section,
 147                                        reloc_entry->address
 148                                        * bfd_octets_per_byte (abfd)))
 149         return bfd_reloc_outofrange;
 150
 151       switch (howto->size)
 152         {
 153         case 0:
 154           {
 155             char x = bfd_get_8 (abfd, addr);
 156             DOIT (x);
 157             bfd_put_8 (abfd, x, addr);
 158           }
 159           break;
 160
 161         case 1:
 162           {
 163             short x = bfd_get_16 (abfd, addr);
 164             DOIT (x);
 165             bfd_put_16 (abfd, (bfd_vma) x, addr);
 166           }
 167           break;
 168
 169         case 2:
 170           {
 171             long x = bfd_get_32 (abfd, addr);
 172             DOIT (x);
 173             bfd_put_32 (abfd, (bfd_vma) x, addr);
 174           }
 175           break;
 176
 177         case 4:
 178           {
 179             bfd_uint64_t x = bfd_get_64 (abfd, addr);
 180             DOIT (x);
 181             bfd_put_64 (abfd, x, addr);
 182           }
 183           break;
 184
 185         default:
 186           bfd_set_error (bfd_error_bad_value);
 187           return bfd_reloc_notsupported;
 188         }
 189     }
 190
 191   /* Now let bfd_perform_relocation finish everything up.  */
 192   return bfd_reloc_continue;
 193 }
 194
 195 #if defined(COFF_WITH_PE)
 196 /* Return TRUE if this relocation should appear in the output .reloc
 197    section.  */
 198
 199 static bfd_boolean
 200 in_reloc_p (bfd *abfd ATTRIBUTE_UNUSED, reloc_howto_type *howto)
 201 {
 202   return ! howto->pc_relative && howto->type != R_AMD64_IMAGEBASE
 203          && howto->type != R_AMD64_SECREL;
 204 }
 205 #endif /* COFF_WITH_PE */
 206
 207 #ifndef PCRELOFFSET
 208 #define PCRELOFFSET TRUE
 209 #endif
 210
 211 static reloc_howto_type howto_table[] =
 212 {
 213   EMPTY_HOWTO (0),
 214   HOWTO (R_AMD64_DIR64,         /* type  1*/
 215          0,                     /* rightshift */
 216          4,                     /* size (0 = byte, 1 = short, 2 = long, 4 = long long) */
 217          64,                    /* bitsize */
 218          FALSE,                 /* pc_relative */
 219          0,                     /* bitpos */
 220          complain_overflow_bitfield, /* complain_on_overflow */
 221          coff_amd64_reloc,      /* special_function */
 222          "R_X86_64_64",         /* name */
 223          TRUE,                  /* partial_inplace */
 224          0xffffffffffffffffll,  /* src_mask */
 225          0xffffffffffffffffll,  /* dst_mask */
 226          TRUE),                 /* pcrel_offset */
 227   HOWTO (R_AMD64_DIR32,         /* type 2 */
 228          0,                     /* rightshift */
 229          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 230          32,                    /* bitsize */
 231          FALSE,                 /* pc_relative */
 232          0,                     /* bitpos */
 233          complain_overflow_bitfield, /* complain_on_overflow */
 234          coff_amd64_reloc,      /* special_function */
 235          "R_X86_64_32",         /* name */
 236          TRUE,                  /* partial_inplace */
 237          0xffffffff,            /* src_mask */
 238          0xffffffff,            /* dst_mask */
 239          TRUE),                 /* pcrel_offset */
 240   /* PE IMAGE_REL_AMD64_ADDR32NB relocation (3).        */
 241   HOWTO (R_AMD64_IMAGEBASE,     /* type */
 242          0,                     /* rightshift */
 243          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 244          32,                    /* bitsize */
 245          FALSE,                 /* pc_relative */
 246          0,                     /* bitpos */
 247          complain_overflow_bitfield, /* complain_on_overflow */
 248          coff_amd64_reloc,      /* special_function */
 249          "rva32",               /* name */
 250          TRUE,                  /* partial_inplace */
 251          0xffffffff,            /* src_mask */
 252          0xffffffff,            /* dst_mask */
 253          FALSE),                /* pcrel_offset */
 254   /* 32-bit longword PC relative relocation (4).  */
 255   HOWTO (R_AMD64_PCRLONG,       /* type 4 */
 256          0,                     /* rightshift */
 257          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 258          32,                    /* bitsize */
 259          TRUE,                  /* pc_relative */
 260          0,                     /* bitpos */
 261          complain_overflow_signed, /* complain_on_overflow */
 262          coff_amd64_reloc,      /* special_function */
 263          "R_X86_64_PC32",       /* name */
 264          TRUE,                  /* partial_inplace */
 265          0xffffffff,            /* src_mask */
 266          0xffffffff,            /* dst_mask */
 267          PCRELOFFSET),          /* pcrel_offset */
 268
 269  HOWTO (R_AMD64_PCRLONG_1,      /* type 5 */
 270          0,                     /* rightshift */
 271          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          32,                    /* bitsize */
 273          TRUE,                  /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_signed, /* complain_on_overflow */
 276          coff_amd64_reloc,      /* special_function */
 277          "DISP32+1",            /* name */
 278          TRUE,                  /* partial_inplace */
 279          0xffffffff,            /* src_mask */
 280          0xffffffff,            /* dst_mask */
 281          PCRELOFFSET),          /* pcrel_offset */
 282  HOWTO (R_AMD64_PCRLONG_2,      /* type 6 */
 283          0,                     /* rightshift */
 284          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 285          32,                    /* bitsize */
 286          TRUE,                  /* pc_relative */
 287          0,                     /* bitpos */
 288          complain_overflow_signed, /* complain_on_overflow */
 289          coff_amd64_reloc,      /* special_function */
 290          "DISP32+2",            /* name */
 291          TRUE,                  /* partial_inplace */
 292          0xffffffff,            /* src_mask */
 293          0xffffffff,            /* dst_mask */
 294          PCRELOFFSET),          /* pcrel_offset */
 295  HOWTO (R_AMD64_PCRLONG_3,      /* type 7 */
 296          0,                     /* rightshift */
 297          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 298          32,                    /* bitsize */
 299          TRUE,                  /* pc_relative */
 300          0,                     /* bitpos */
 301          complain_overflow_signed, /* complain_on_overflow */
 302          coff_amd64_reloc,      /* special_function */
 303          "DISP32+3",            /* name */
 304          TRUE,                  /* partial_inplace */
 305          0xffffffff,            /* src_mask */
 306          0xffffffff,            /* dst_mask */
 307          PCRELOFFSET),          /* pcrel_offset */
 308  HOWTO (R_AMD64_PCRLONG_4,      /* type 8 */
 309          0,                     /* rightshift */
 310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 311          32,                    /* bitsize */
 312          TRUE,                  /* pc_relative */
 313          0,                     /* bitpos */
 314          complain_overflow_signed, /* complain_on_overflow */
 315          coff_amd64_reloc,      /* special_function */
 316          "DISP32+4",            /* name */
 317          TRUE,                  /* partial_inplace */
 318          0xffffffff,            /* src_mask */
 319          0xffffffff,            /* dst_mask */
 320          PCRELOFFSET),          /* pcrel_offset */
 321  HOWTO (R_AMD64_PCRLONG_5,      /* type 9 */
 322          0,                     /* rightshift */
 323          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 324          32,                    /* bitsize */
 325          TRUE,                  /* pc_relative */
 326          0,                     /* bitpos */
 327          complain_overflow_signed, /* complain_on_overflow */
 328          coff_amd64_reloc,      /* special_function */
 329          "DISP32+5",            /* name */
 330          TRUE,                  /* partial_inplace */
 331          0xffffffff,            /* src_mask */
 332          0xffffffff,            /* dst_mask */
 333          PCRELOFFSET),          /* pcrel_offset */
 334   EMPTY_HOWTO (10), /* R_AMD64_SECTION 10  */
 335 #if defined(COFF_WITH_PE)
 336   /* 32-bit longword section relative relocation (11).  */
 337   HOWTO (R_AMD64_SECREL,        /* type */
 338          0,                     /* rightshift */
 339          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 340          32,                    /* bitsize */
 341          FALSE,                 /* pc_relative */
 342          0,                     /* bitpos */
 343          complain_overflow_bitfield, /* complain_on_overflow */
 344          coff_amd64_reloc,      /* special_function */
 345          "secrel32",            /* name */
 346          TRUE,                  /* partial_inplace */
 347          0xffffffff,            /* src_mask */
 348          0xffffffff,            /* dst_mask */
 349          TRUE),                 /* pcrel_offset */
 350 #else
 351   EMPTY_HOWTO (11),
 352 #endif
 353   EMPTY_HOWTO (12),
 354   EMPTY_HOWTO (13),
 355 #ifndef DONT_EXTEND_AMD64
 356   HOWTO (R_AMD64_PCRQUAD,
 357          0,                     /* rightshift */
 358          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 359          64,                    /* bitsize */
 360          TRUE,                  /* pc_relative */
 361          0,                     /* bitpos */
 362          complain_overflow_signed, /* complain_on_overflow */
 363          coff_amd64_reloc,      /* special_function */
 364          "R_X86_64_PC64",       /* name */
 365          TRUE,                  /* partial_inplace */
 366          0xffffffffffffffffll,  /* src_mask */
 367          0xffffffffffffffffll,  /* dst_mask */
 368          PCRELOFFSET),           /* pcrel_offset */
 369 #else
 370   EMPTY_HOWTO (14),
 371 #endif
 372   /* Byte relocation (15).  */
 373   HOWTO (R_RELBYTE,             /* type */
 374          0,                     /* rightshift */
 375          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 376          8,                     /* bitsize */
 377          FALSE,                 /* pc_relative */
 378          0,                     /* bitpos */
 379          complain_overflow_bitfield, /* complain_on_overflow */
 380          coff_amd64_reloc,      /* special_function */
 381          "R_X86_64_8",          /* name */
 382          TRUE,                  /* partial_inplace */
 383          0x000000ff,            /* src_mask */
 384          0x000000ff,            /* dst_mask */
 385          PCRELOFFSET),          /* pcrel_offset */
 386   /* 16-bit word relocation (16).  */
 387   HOWTO (R_RELWORD,             /* type */
 388          0,                     /* rightshift */
 389          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 390          16,                    /* bitsize */
 391          FALSE,                 /* pc_relative */
 392          0,                     /* bitpos */
 393          complain_overflow_bitfield, /* complain_on_overflow */
 394          coff_amd64_reloc,      /* special_function */
 395          "R_X86_64_16",         /* name */
 396          TRUE,                  /* partial_inplace */
 397          0x0000ffff,            /* src_mask */
 398          0x0000ffff,            /* dst_mask */
 399          PCRELOFFSET),          /* pcrel_offset */
 400   /* 32-bit longword relocation (17).   */
 401   HOWTO (R_RELLONG,             /* type */
 402          0,                     /* rightshift */
 403          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 404          32,                    /* bitsize */
 405          FALSE,                 /* pc_relative */
 406          0,                     /* bitpos */
 407          complain_overflow_bitfield, /* complain_on_overflow */
 408          coff_amd64_reloc,      /* special_function */
 409          "R_X86_64_32S",        /* name */
 410          TRUE,                  /* partial_inplace */
 411          0xffffffff,            /* src_mask */
 412          0xffffffff,            /* dst_mask */
 413          PCRELOFFSET),          /* pcrel_offset */
 414   /* Byte PC relative relocation (18).   */
 415   HOWTO (R_PCRBYTE,             /* type */
 416          0,                     /* rightshift */
 417          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 418          8,                     /* bitsize */
 419          TRUE,                  /* pc_relative */
 420          0,                     /* bitpos */
 421          complain_overflow_signed, /* complain_on_overflow */
 422          coff_amd64_reloc,      /* special_function */
 423          "R_X86_64_PC8",        /* name */
 424          TRUE,                  /* partial_inplace */
 425          0x000000ff,            /* src_mask */
 426          0x000000ff,            /* dst_mask */
 427          PCRELOFFSET),          /* pcrel_offset */
 428   /* 16-bit word PC relative relocation (19).   */
 429   HOWTO (R_PCRWORD,             /* type */
 430          0,                     /* rightshift */
 431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 432          16,                    /* bitsize */
 433          TRUE,                  /* pc_relative */
 434          0,                     /* bitpos */
 435          complain_overflow_signed, /* complain_on_overflow */
 436          coff_amd64_reloc,      /* special_function */
 437          "R_X86_64_PC16",       /* name */
 438          TRUE,                  /* partial_inplace */
 439          0x0000ffff,            /* src_mask */
 440          0x0000ffff,            /* dst_mask */
 441          PCRELOFFSET),          /* pcrel_offset */
 442   /* 32-bit longword PC relative relocation (20).  */
 443   HOWTO (R_PCRLONG,             /* type */
 444          0,                     /* rightshift */
 445          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 446          32,                    /* bitsize */
 447          TRUE,                  /* pc_relative */
 448          0,                     /* bitpos */
 449          complain_overflow_signed, /* complain_on_overflow */
 450          coff_amd64_reloc,      /* special_function */
 451          "R_X86_64_PC32",       /* name */
 452          TRUE,                  /* partial_inplace */
 453          0xffffffff,            /* src_mask */
 454          0xffffffff,            /* dst_mask */
 455          PCRELOFFSET)           /* pcrel_offset */
 456 };
 457
 458 #define NUM_HOWTOS ARRAY_SIZE (howto_table)
 459
 460 /* Turn a howto into a reloc  nunmber */
 461
 462 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
 463 #define I386  1                 /* Customize coffcode.h */
 464 #define AMD64 1
 465
 466 #define RTYPE2HOWTO(cache_ptr, dst)             \
 467   ((cache_ptr)->howto =                         \
 468    ((dst)->r_type < NUM_HOWTOS)                 \
 469     ? howto_table + (dst)->r_type               \
 470     : NULL)
 471
 472 /* For 386 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
 473    library.  On some other COFF targets STYP_BSS is normally
 474    STYP_NOLOAD.  */
 475 #define BSS_NOLOAD_IS_SHARED_LIBRARY
 476
 477 /* Compute the addend of a reloc.  If the reloc is to a common symbol,
 478    the object file contains the value of the common symbol.  By the
 479    time this is called, the linker may be using a different symbol
 480    from a different object file with a different value.  Therefore, we
 481    hack wildly to locate the original symbol from this file so that we
 482    can make the correct adjustment.  This macro sets coffsym to the
 483    symbol from the original file, and uses it to set the addend value
 484    correctly.  If this is not a common symbol, the usual addend
 485    calculation is done, except that an additional tweak is needed for
 486    PC relative relocs.
 487    FIXME: This macro refers to symbols and asect; these are from the
 488    calling function, not the macro arguments.  */
 489
 490 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
 491   {                                                             \
 492     coff_symbol_type *coffsym = NULL;                           \
 493                                                                 \
 494     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
 495       coffsym = (obj_symbols (abfd)                             \
 496                  + (cache_ptr->sym_ptr_ptr - symbols));         \
 497     else if (ptr)                                               \
 498       coffsym = coff_symbol_from (ptr);                         \
 499                                                                 \
 500     if (coffsym != NULL                                         \
 501         && coffsym->native->u.syment.n_scnum == 0)              \
 502       cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
 503     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
 504              && ptr->section != NULL)                           \
 505       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
 506     else                                                        \
 507       cache_ptr->addend = 0;                                    \
 508     if (ptr && reloc.r_type < NUM_HOWTOS                        \
 509         && howto_table[reloc.r_type].pc_relative)               \
 510       cache_ptr->addend += asect->vma;                          \
 511   }
 512
 513 /* We use the special COFF backend linker.  For normal AMD64 COFF, we
 514    can use the generic relocate_section routine.  For PE, we need our
 515    own routine.  */
 516
 517 #if !defined(COFF_WITH_PE)
 518
 519 #define coff_relocate_section _bfd_coff_generic_relocate_section
 520
 521 #else /* COFF_WITH_PE */
 522
 523 /* The PE relocate section routine.  The only difference between this
 524    and the regular routine is that we don't want to do anything for a
 525    relocatable link.  */
 526
 527 static bfd_boolean
 528 coff_pe_amd64_relocate_section (bfd *output_bfd,
 529                                 struct bfd_link_info *info,
 530                                 bfd *input_bfd,
 531                                 asection *input_section,
 532                                 bfd_byte *contents,
 533                                 struct internal_reloc *relocs,
 534                                 struct internal_syment *syms,
 535                                 asection **sections)
 536 {
 537   if (bfd_link_relocatable (info))
 538     return TRUE;
 539
 540   return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,input_section, contents,relocs, syms, sections);
 541 }
 542
 543 #define coff_relocate_section coff_pe_amd64_relocate_section
 544
 545 #endif /* COFF_WITH_PE */
 546
 547 /* Convert an rtype to howto for the COFF backend linker.  */
 548
 549 static reloc_howto_type *
 550 coff_amd64_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 551                            asection *sec,
 552                            struct internal_reloc *rel,
 553                            struct coff_link_hash_entry *h,
 554                            struct internal_syment *sym,
 555                            bfd_vma *addendp)
 556 {
 557   reloc_howto_type *howto;
 558
 559   if (rel->r_type >= NUM_HOWTOS)
 560     {
 561       bfd_set_error (bfd_error_bad_value);
 562       return NULL;
 563     }
 564   howto = howto_table + rel->r_type;
 565
 566 #if defined(COFF_WITH_PE)
 567   /* Cancel out code in _bfd_coff_generic_relocate_section.  */
 568   *addendp = 0;
 569   if (rel->r_type >= R_AMD64_PCRLONG_1 && rel->r_type <= R_AMD64_PCRLONG_5)
 570     {
 571       *addendp -= (bfd_vma)(rel->r_type - R_AMD64_PCRLONG);
 572       rel->r_type = R_AMD64_PCRLONG;
 573     }
 574 #endif
 575
 576   if (howto->pc_relative)
 577     *addendp += sec->vma;
 578
 579   if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
 580     {
 581       /* This is a common symbol.  The section contents include the
 582          size (sym->n_value) as an addend.  The relocate_section
 583          function will be adding in the final value of the symbol.  We
 584          need to subtract out the current size in order to get the
 585          correct result.  */
 586       BFD_ASSERT (h != NULL);
 587
 588 #if !defined(COFF_WITH_PE)
 589       /* I think we *do* want to bypass this.  If we don't, I have
 590          seen some data parameters get the wrong relocation address.
 591          If I link two versions with and without this section bypassed
 592          and then do a binary comparison, the addresses which are
 593          different can be looked up in the map.  The case in which
 594          this section has been bypassed has addresses which correspond
 595          to values I can find in the map.  */
 596       *addendp -= sym->n_value;
 597 #endif
 598     }
 599
 600 #if !defined(COFF_WITH_PE)
 601   /* If the output symbol is common (in which case this must be a
 602      relocatable link), we need to add in the final size of the
 603      common symbol.  */
 604   if (h != NULL && h->root.type == bfd_link_hash_common)
 605     *addendp += h->root.u.c.size;
 606 #endif
 607
 608 #if defined(COFF_WITH_PE)
 609   if (howto->pc_relative)
 610     {
 611 #ifndef DONT_EXTEND_AMD64
 612       if (rel->r_type == R_AMD64_PCRQUAD)
 613         *addendp -= 8;
 614       else
 615 #endif
 616         *addendp -= 4;
 617
 618       /* If the symbol is defined, then the generic code is going to
 619          add back the symbol value in order to cancel out an
 620          adjustment it made to the addend.  However, we set the addend
 621          to 0 at the start of this function.  We need to adjust here,
 622          to avoid the adjustment the generic code will make.  FIXME:
 623          This is getting a bit hackish.  */
 624       if (sym != NULL && sym->n_scnum != 0)
 625         *addendp -= sym->n_value;
 626     }
 627
 628   if (rel->r_type == R_AMD64_IMAGEBASE
 629       && (bfd_get_flavour (sec->output_section->owner) == bfd_target_coff_flavour))
 630     *addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
 631
 632   if (rel->r_type == R_AMD64_SECREL)
 633     {
 634       bfd_vma osect_vma;
 635
 636       if (h && (h->root.type == bfd_link_hash_defined
 637                 || h->root.type == bfd_link_hash_defweak))
 638         osect_vma = h->root.u.def.section->output_section->vma;
 639       else
 640         {
 641           asection *s;
 642           int i;
 643
 644           /* Sigh, the only way to get the section to offset against
 645              is to find it the hard way.  */
 646           for (s = abfd->sections, i = 1; i < sym->n_scnum; i++)
 647             s = s->next;
 648
 649           osect_vma = s->output_section->vma;
 650         }
 651
 652       *addendp -= osect_vma;
 653     }
 654 #endif
 655
 656   return howto;
 657 }
 658
 659 #define coff_bfd_reloc_type_lookup coff_amd64_reloc_type_lookup
 660 #define coff_bfd_reloc_name_lookup coff_amd64_reloc_name_lookup
 661
 662 static reloc_howto_type *
 663 coff_amd64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
 664 {
 665   switch (code)
 666     {
 667     case BFD_RELOC_RVA:
 668       return howto_table + R_AMD64_IMAGEBASE;
 669     case BFD_RELOC_32:
 670       return howto_table + R_AMD64_DIR32;
 671     case BFD_RELOC_64:
 672       return howto_table + R_AMD64_DIR64;
 673     case BFD_RELOC_64_PCREL:
 674 #ifndef DONT_EXTEND_AMD64
 675       return howto_table + R_AMD64_PCRQUAD;
 676 #else
 677       /* Fall through.  */
 678 #endif
 679     case BFD_RELOC_32_PCREL:
 680       return howto_table + R_AMD64_PCRLONG;
 681     case BFD_RELOC_X86_64_32S:
 682       return howto_table + R_RELLONG;
 683     case BFD_RELOC_16:
 684       return howto_table + R_RELWORD;
 685     case BFD_RELOC_16_PCREL:
 686       return howto_table + R_PCRWORD;
 687     case BFD_RELOC_8:
 688       return howto_table + R_RELBYTE;
 689     case BFD_RELOC_8_PCREL:
 690       return howto_table + R_PCRBYTE;
 691 #if defined(COFF_WITH_PE)
 692     case BFD_RELOC_32_SECREL:
 693       return howto_table + R_AMD64_SECREL;
 694 #endif
 695     default:
 696       BFD_FAIL ();
 697       return 0;
 698     }
 699 }
 700
 701 static reloc_howto_type *
 702 coff_amd64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 703                               const char *r_name)
 704 {
 705   unsigned int i;
 706
 707   for (i = 0; i < NUM_HOWTOS; i++)
 708     if (howto_table[i].name != NULL
 709         && strcasecmp (howto_table[i].name, r_name) == 0)
 710       return &howto_table[i];
 711
 712   return NULL;
 713 }
 714
 715 #define coff_rtype_to_howto coff_amd64_rtype_to_howto
 716
 717 #ifdef TARGET_UNDERSCORE
 718
 719 /* If amd64 gcc uses underscores for symbol names, then it does not use
 720    a leading dot for local labels, so if TARGET_UNDERSCORE is defined
 721    we treat all symbols starting with L as local.  */
 722
 723 static bfd_boolean
 724 coff_amd64_is_local_label_name (bfd *abfd, const char *name)
 725 {
 726   if (name[0] == 'L')
 727     return TRUE;
 728
 729   return _bfd_coff_is_local_label_name (abfd, name);
 730 }
 731
 732 #define coff_bfd_is_local_label_name coff_amd64_is_local_label_name
 733
 734 #endif /* TARGET_UNDERSCORE */
 735
 736 #ifndef bfd_pe_print_pdata
 737 #define bfd_pe_print_pdata   NULL
 738 #endif
 739
 740 #include "coffcode.h"
 741
 742 #ifdef PE
 743 #define amd64coff_object_p pe_bfd_object_p
 744 #else
 745 #define amd64coff_object_p coff_object_p
 746 #endif
 747
 748 const bfd_target
 749 #ifdef TARGET_SYM
 750   TARGET_SYM =
 751 #else
 752   x86_64_coff_vec =
 753 #endif
 754 {
 755 #ifdef TARGET_NAME
 756   TARGET_NAME,
 757 #else
 758  "coff-x86-64",                 /* Name.  */
 759 #endif
 760   bfd_target_coff_flavour,
 761   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */
 762   BFD_ENDIAN_LITTLE,            /* Header byte order is little.  */
 763
 764   (HAS_RELOC | EXEC_P           /* Object flags.  */
 765    | HAS_LINENO | HAS_DEBUG
 766    | HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | BFD_COMPRESS | BFD_DECOMPRESS),
 767
 768   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* Section flags.  */
 769 #if defined(COFF_WITH_PE)
 770    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY | SEC_DEBUGGING
 771 #endif
 772    | SEC_CODE | SEC_DATA | SEC_EXCLUDE ),
 773
 774 #ifdef TARGET_UNDERSCORE
 775   TARGET_UNDERSCORE,            /* Leading underscore.  */
 776 #else
 777   0,                            /* Leading underscore.  */
 778 #endif
 779   '/',                          /* Ar_pad_char.  */
 780   15,                           /* Ar_max_namelen.  */
 781   0,                            /* match priority.  */
 782
 783   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 784      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 785      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
 786   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 787      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 788      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Hdrs.  */
 789
 790   /* Note that we allow an object file to be treated as a core file as well.  */
 791   {                             /* bfd_check_format.  */
 792     _bfd_dummy_target,
 793     amd64coff_object_p,
 794     bfd_generic_archive_p,
 795     amd64coff_object_p
 796   },
 797   {                             /* bfd_set_format.  */
 798     _bfd_bool_bfd_false_error,
 799     coff_mkobject,
 800     _bfd_generic_mkarchive,
 801     _bfd_bool_bfd_false_error
 802   },
 803   {                             /* bfd_write_contents.  */
 804     _bfd_bool_bfd_false_error,
 805     coff_write_object_contents,
 806     _bfd_write_archive_contents,
 807     _bfd_bool_bfd_false_error
 808   },
 809
 810   BFD_JUMP_TABLE_GENERIC (coff),
 811   BFD_JUMP_TABLE_COPY (coff),
 812   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 813   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 814   BFD_JUMP_TABLE_SYMBOLS (coff),
 815   BFD_JUMP_TABLE_RELOCS (coff),
 816   BFD_JUMP_TABLE_WRITE (coff),
 817   BFD_JUMP_TABLE_LINK (coff),
 818   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 819
 820   NULL,
 821
 822   COFF_SWAP_TABLE
 823 };