bfd/coff-x86_64.c

   1 /* BFD back-end for AMD 64 COFF files.
   2    Copyright (C) 2006-2014 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         switch (howto->size)
 147           {
 148           case 0:
 149             {
 150               char x = bfd_get_8 (abfd, addr);
 151               DOIT (x);
 152               bfd_put_8 (abfd, x, addr);
 153             }
 154             break;
 155
 156           case 1:
 157             {
 158               short x = bfd_get_16 (abfd, addr);
 159               DOIT (x);
 160               bfd_put_16 (abfd, (bfd_vma) x, addr);
 161             }
 162             break;
 163
 164           case 2:
 165             {
 166               long x = bfd_get_32 (abfd, addr);
 167               DOIT (x);
 168               bfd_put_32 (abfd, (bfd_vma) x, addr);
 169             }
 170             break;
 171           case 4:
 172             {
 173               long long x = bfd_get_64 (abfd, addr);
 174               DOIT (x);
 175               bfd_put_64 (abfd, (bfd_vma) x, addr);
 176             }
 177             break;
 178
 179           default:
 180             abort ();
 181           }
 182       }
 183
 184   /* Now let bfd_perform_relocation finish everything up.  */
 185   return bfd_reloc_continue;
 186 }
 187
 188 #if defined(COFF_WITH_PE)
 189 /* Return TRUE if this relocation should appear in the output .reloc
 190    section.  */
 191
 192 static bfd_boolean
 193 in_reloc_p (bfd *abfd ATTRIBUTE_UNUSED, reloc_howto_type *howto)
 194 {
 195   return ! howto->pc_relative && howto->type != R_AMD64_IMAGEBASE
 196          && howto->type != R_AMD64_SECREL;
 197 }
 198 #endif /* COFF_WITH_PE */
 199
 200 #ifndef PCRELOFFSET
 201 #define PCRELOFFSET TRUE
 202 #endif
 203
 204 static reloc_howto_type howto_table[] =
 205 {
 206   EMPTY_HOWTO (0),
 207   HOWTO (R_AMD64_DIR64,         /* type  1*/
 208          0,                     /* rightshift */
 209          4,                     /* size (0 = byte, 1 = short, 2 = long, 4 = long long) */
 210          64,                    /* bitsize */
 211          FALSE,                 /* pc_relative */
 212          0,                     /* bitpos */
 213          complain_overflow_bitfield, /* complain_on_overflow */
 214          coff_amd64_reloc,      /* special_function */
 215          "R_X86_64_64",         /* name */
 216          TRUE,                  /* partial_inplace */
 217          0xffffffffffffffffll,  /* src_mask */
 218          0xffffffffffffffffll,  /* dst_mask */
 219          TRUE),                 /* pcrel_offset */
 220   HOWTO (R_AMD64_DIR32,         /* type 2 */
 221          0,                     /* rightshift */
 222          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 223          32,                    /* bitsize */
 224          FALSE,                 /* pc_relative */
 225          0,                     /* bitpos */
 226          complain_overflow_bitfield, /* complain_on_overflow */
 227          coff_amd64_reloc,      /* special_function */
 228          "R_X86_64_32",         /* name */
 229          TRUE,                  /* partial_inplace */
 230          0xffffffff,            /* src_mask */
 231          0xffffffff,            /* dst_mask */
 232          TRUE),                 /* pcrel_offset */
 233   /* PE IMAGE_REL_AMD64_ADDR32NB relocation (3).        */
 234   HOWTO (R_AMD64_IMAGEBASE,     /* type */
 235          0,                     /* rightshift */
 236          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 237          32,                    /* bitsize */
 238          FALSE,                 /* pc_relative */
 239          0,                     /* bitpos */
 240          complain_overflow_bitfield, /* complain_on_overflow */
 241          coff_amd64_reloc,      /* special_function */
 242          "rva32",               /* name */
 243          TRUE,                  /* partial_inplace */
 244          0xffffffff,            /* src_mask */
 245          0xffffffff,            /* dst_mask */
 246          FALSE),                /* pcrel_offset */
 247   /* 32-bit longword PC relative relocation (4).  */
 248   HOWTO (R_AMD64_PCRLONG,       /* type 4 */
 249          0,                     /* rightshift */
 250          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 251          32,                    /* bitsize */
 252          TRUE,                  /* pc_relative */
 253          0,                     /* bitpos */
 254          complain_overflow_signed, /* complain_on_overflow */
 255          coff_amd64_reloc,      /* special_function */
 256          "R_X86_64_PC32",       /* name */
 257          TRUE,                  /* partial_inplace */
 258          0xffffffff,            /* src_mask */
 259          0xffffffff,            /* dst_mask */
 260          PCRELOFFSET),          /* pcrel_offset */
 261
 262  HOWTO (R_AMD64_PCRLONG_1,      /* type 5 */
 263          0,                     /* rightshift */
 264          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 265          32,                    /* bitsize */
 266          TRUE,                  /* pc_relative */
 267          0,                     /* bitpos */
 268          complain_overflow_signed, /* complain_on_overflow */
 269          coff_amd64_reloc,      /* special_function */
 270          "DISP32+1",            /* name */
 271          TRUE,                  /* partial_inplace */
 272          0xffffffff,            /* src_mask */
 273          0xffffffff,            /* dst_mask */
 274          PCRELOFFSET),          /* pcrel_offset */
 275  HOWTO (R_AMD64_PCRLONG_2,      /* type 6 */
 276          0,                     /* rightshift */
 277          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 278          32,                    /* bitsize */
 279          TRUE,                  /* pc_relative */
 280          0,                     /* bitpos */
 281          complain_overflow_signed, /* complain_on_overflow */
 282          coff_amd64_reloc,      /* special_function */
 283          "DISP32+2",            /* name */
 284          TRUE,                  /* partial_inplace */
 285          0xffffffff,            /* src_mask */
 286          0xffffffff,            /* dst_mask */
 287          PCRELOFFSET),          /* pcrel_offset */
 288  HOWTO (R_AMD64_PCRLONG_3,      /* type 7 */
 289          0,                     /* rightshift */
 290          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 291          32,                    /* bitsize */
 292          TRUE,                  /* pc_relative */
 293          0,                     /* bitpos */
 294          complain_overflow_signed, /* complain_on_overflow */
 295          coff_amd64_reloc,      /* special_function */
 296          "DISP32+3",            /* name */
 297          TRUE,                  /* partial_inplace */
 298          0xffffffff,            /* src_mask */
 299          0xffffffff,            /* dst_mask */
 300          PCRELOFFSET),          /* pcrel_offset */
 301  HOWTO (R_AMD64_PCRLONG_4,      /* type 8 */
 302          0,                     /* rightshift */
 303          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 304          32,                    /* bitsize */
 305          TRUE,                  /* pc_relative */
 306          0,                     /* bitpos */
 307          complain_overflow_signed, /* complain_on_overflow */
 308          coff_amd64_reloc,      /* special_function */
 309          "DISP32+4",            /* name */
 310          TRUE,                  /* partial_inplace */
 311          0xffffffff,            /* src_mask */
 312          0xffffffff,            /* dst_mask */
 313          PCRELOFFSET),          /* pcrel_offset */
 314  HOWTO (R_AMD64_PCRLONG_5,      /* type 9 */
 315          0,                     /* rightshift */
 316          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 317          32,                    /* bitsize */
 318          TRUE,                  /* pc_relative */
 319          0,                     /* bitpos */
 320          complain_overflow_signed, /* complain_on_overflow */
 321          coff_amd64_reloc,      /* special_function */
 322          "DISP32+5",            /* name */
 323          TRUE,                  /* partial_inplace */
 324          0xffffffff,            /* src_mask */
 325          0xffffffff,            /* dst_mask */
 326          PCRELOFFSET),          /* pcrel_offset */
 327   EMPTY_HOWTO (10), /* R_AMD64_SECTION 10  */
 328 #if defined(COFF_WITH_PE)
 329   /* 32-bit longword section relative relocation (11).  */
 330   HOWTO (R_AMD64_SECREL,        /* type */
 331          0,                     /* rightshift */
 332          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          32,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_bitfield, /* complain_on_overflow */
 337          coff_amd64_reloc,      /* special_function */
 338          "secrel32",            /* name */
 339          TRUE,                  /* partial_inplace */
 340          0xffffffff,            /* src_mask */
 341          0xffffffff,            /* dst_mask */
 342          TRUE),                 /* pcrel_offset */
 343 #else
 344   EMPTY_HOWTO (11),
 345 #endif
 346   EMPTY_HOWTO (12),
 347   EMPTY_HOWTO (13),
 348 #ifndef DONT_EXTEND_AMD64
 349   HOWTO (R_AMD64_PCRQUAD,
 350          0,                     /* rightshift */
 351          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 352          64,                    /* bitsize */
 353          TRUE,                  /* pc_relative */
 354          0,                     /* bitpos */
 355          complain_overflow_signed, /* complain_on_overflow */
 356          coff_amd64_reloc,      /* special_function */
 357          "R_X86_64_PC64",       /* name */
 358          TRUE,                  /* partial_inplace */
 359          0xffffffffffffffffll,  /* src_mask */
 360          0xffffffffffffffffll,  /* dst_mask */
 361          PCRELOFFSET),           /* pcrel_offset */
 362 #else
 363   EMPTY_HOWTO (14),
 364 #endif
 365   /* Byte relocation (15).  */
 366   HOWTO (R_RELBYTE,             /* type */
 367          0,                     /* rightshift */
 368          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          8,                     /* bitsize */
 370          FALSE,                 /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_bitfield, /* complain_on_overflow */
 373          coff_amd64_reloc,      /* special_function */
 374          "R_X86_64_8",          /* name */
 375          TRUE,                  /* partial_inplace */
 376          0x000000ff,            /* src_mask */
 377          0x000000ff,            /* dst_mask */
 378          PCRELOFFSET),          /* pcrel_offset */
 379   /* 16-bit word relocation (16).  */
 380   HOWTO (R_RELWORD,             /* type */
 381          0,                     /* rightshift */
 382          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 383          16,                    /* bitsize */
 384          FALSE,                 /* pc_relative */
 385          0,                     /* bitpos */
 386          complain_overflow_bitfield, /* complain_on_overflow */
 387          coff_amd64_reloc,      /* special_function */
 388          "R_X86_64_16",         /* name */
 389          TRUE,                  /* partial_inplace */
 390          0x0000ffff,            /* src_mask */
 391          0x0000ffff,            /* dst_mask */
 392          PCRELOFFSET),          /* pcrel_offset */
 393   /* 32-bit longword relocation (17).   */
 394   HOWTO (R_RELLONG,             /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          32,                    /* bitsize */
 398          FALSE,                 /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_bitfield, /* complain_on_overflow */
 401          coff_amd64_reloc,      /* special_function */
 402          "R_X86_64_32S",        /* name */
 403          TRUE,                  /* partial_inplace */
 404          0xffffffff,            /* src_mask */
 405          0xffffffff,            /* dst_mask */
 406          PCRELOFFSET),          /* pcrel_offset */
 407   /* Byte PC relative relocation (18).   */
 408   HOWTO (R_PCRBYTE,             /* type */
 409          0,                     /* rightshift */
 410          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          8,                     /* bitsize */
 412          TRUE,                  /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_signed, /* complain_on_overflow */
 415          coff_amd64_reloc,      /* special_function */
 416          "R_X86_64_PC8",        /* name */
 417          TRUE,                  /* partial_inplace */
 418          0x000000ff,            /* src_mask */
 419          0x000000ff,            /* dst_mask */
 420          PCRELOFFSET),          /* pcrel_offset */
 421   /* 16-bit word PC relative relocation (19).   */
 422   HOWTO (R_PCRWORD,             /* type */
 423          0,                     /* rightshift */
 424          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 425          16,                    /* bitsize */
 426          TRUE,                  /* pc_relative */
 427          0,                     /* bitpos */
 428          complain_overflow_signed, /* complain_on_overflow */
 429          coff_amd64_reloc,      /* special_function */
 430          "R_X86_64_PC16",       /* name */
 431          TRUE,                  /* partial_inplace */
 432          0x0000ffff,            /* src_mask */
 433          0x0000ffff,            /* dst_mask */
 434          PCRELOFFSET),          /* pcrel_offset */
 435   /* 32-bit longword PC relative relocation (20).  */
 436   HOWTO (R_PCRLONG,             /* type */
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          32,                    /* bitsize */
 440          TRUE,                  /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_signed, /* complain_on_overflow */
 443          coff_amd64_reloc,      /* special_function */
 444          "R_X86_64_PC32",       /* name */
 445          TRUE,                  /* partial_inplace */
 446          0xffffffff,            /* src_mask */
 447          0xffffffff,            /* dst_mask */
 448          PCRELOFFSET)           /* pcrel_offset */
 449 };
 450
 451 #define NUM_HOWTOS ARRAY_SIZE (howto_table)
 452
 453 /* Turn a howto into a reloc  nunmber */
 454
 455 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
 456 #define I386  1                 /* Customize coffcode.h */
 457 #define AMD64 1
 458
 459 #define RTYPE2HOWTO(cache_ptr, dst)             \
 460   ((cache_ptr)->howto =                         \
 461    ((dst)->r_type < NUM_HOWTOS)                 \
 462     ? howto_table + (dst)->r_type               \
 463     : NULL)
 464
 465 /* For 386 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
 466    library.  On some other COFF targets STYP_BSS is normally
 467    STYP_NOLOAD.  */
 468 #define BSS_NOLOAD_IS_SHARED_LIBRARY
 469
 470 /* Compute the addend of a reloc.  If the reloc is to a common symbol,
 471    the object file contains the value of the common symbol.  By the
 472    time this is called, the linker may be using a different symbol
 473    from a different object file with a different value.  Therefore, we
 474    hack wildly to locate the original symbol from this file so that we
 475    can make the correct adjustment.  This macro sets coffsym to the
 476    symbol from the original file, and uses it to set the addend value
 477    correctly.  If this is not a common symbol, the usual addend
 478    calculation is done, except that an additional tweak is needed for
 479    PC relative relocs.
 480    FIXME: This macro refers to symbols and asect; these are from the
 481    calling function, not the macro arguments.  */
 482
 483 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
 484   {                                                             \
 485     coff_symbol_type *coffsym = NULL;                           \
 486                                                                 \
 487     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
 488       coffsym = (obj_symbols (abfd)                             \
 489                  + (cache_ptr->sym_ptr_ptr - symbols));         \
 490     else if (ptr)                                               \
 491       coffsym = coff_symbol_from (abfd, ptr);                   \
 492                                                                 \
 493     if (coffsym != NULL                                         \
 494         && coffsym->native->u.syment.n_scnum == 0)              \
 495       cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
 496     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
 497              && ptr->section != NULL)                           \
 498       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
 499     else                                                        \
 500       cache_ptr->addend = 0;                                    \
 501     if (ptr && reloc.r_type < NUM_HOWTOS                        \
 502         && howto_table[reloc.r_type].pc_relative)               \
 503       cache_ptr->addend += asect->vma;                          \
 504   }
 505
 506 /* We use the special COFF backend linker.  For normal AMD64 COFF, we
 507    can use the generic relocate_section routine.  For PE, we need our
 508    own routine.  */
 509
 510 #if !defined(COFF_WITH_PE)
 511
 512 #define coff_relocate_section _bfd_coff_generic_relocate_section
 513
 514 #else /* COFF_WITH_PE */
 515
 516 /* The PE relocate section routine.  The only difference between this
 517    and the regular routine is that we don't want to do anything for a
 518    relocatable link.  */
 519
 520 static bfd_boolean
 521 coff_pe_amd64_relocate_section (bfd *output_bfd,
 522                                 struct bfd_link_info *info,
 523                                 bfd *input_bfd,
 524                                 asection *input_section,
 525                                 bfd_byte *contents,
 526                                 struct internal_reloc *relocs,
 527                                 struct internal_syment *syms,
 528                                 asection **sections)
 529 {
 530   if (info->relocatable)
 531     return TRUE;
 532
 533   return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,input_section, contents,relocs, syms, sections);
 534 }
 535
 536 #define coff_relocate_section coff_pe_amd64_relocate_section
 537
 538 #endif /* COFF_WITH_PE */
 539
 540 /* Convert an rtype to howto for the COFF backend linker.  */
 541
 542 static reloc_howto_type *
 543 coff_amd64_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 544                            asection *sec,
 545                            struct internal_reloc *rel,
 546                            struct coff_link_hash_entry *h,
 547                            struct internal_syment *sym,
 548                            bfd_vma *addendp)
 549 {
 550   reloc_howto_type *howto;
 551
 552   if (rel->r_type >= NUM_HOWTOS)
 553     {
 554       bfd_set_error (bfd_error_bad_value);
 555       return NULL;
 556     }
 557   howto = howto_table + rel->r_type;
 558
 559 #if defined(COFF_WITH_PE)
 560   /* Cancel out code in _bfd_coff_generic_relocate_section.  */
 561   *addendp = 0;
 562   if (rel->r_type >= R_AMD64_PCRLONG_1 && rel->r_type <= R_AMD64_PCRLONG_5)
 563     {
 564       *addendp -= (bfd_vma)(rel->r_type - R_AMD64_PCRLONG);
 565       rel->r_type = R_AMD64_PCRLONG;
 566     }
 567 #endif
 568
 569   if (howto->pc_relative)
 570     *addendp += sec->vma;
 571
 572   if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
 573     {
 574       /* This is a common symbol.  The section contents include the
 575          size (sym->n_value) as an addend.  The relocate_section
 576          function will be adding in the final value of the symbol.  We
 577          need to subtract out the current size in order to get the
 578          correct result.  */
 579       BFD_ASSERT (h != NULL);
 580
 581 #if !defined(COFF_WITH_PE)
 582       /* I think we *do* want to bypass this.  If we don't, I have
 583          seen some data parameters get the wrong relocation address.
 584          If I link two versions with and without this section bypassed
 585          and then do a binary comparison, the addresses which are
 586          different can be looked up in the map.  The case in which
 587          this section has been bypassed has addresses which correspond
 588          to values I can find in the map.  */
 589       *addendp -= sym->n_value;
 590 #endif
 591     }
 592
 593 #if !defined(COFF_WITH_PE)
 594   /* If the output symbol is common (in which case this must be a
 595      relocatable link), we need to add in the final size of the
 596      common symbol.  */
 597   if (h != NULL && h->root.type == bfd_link_hash_common)
 598     *addendp += h->root.u.c.size;
 599 #endif
 600
 601 #if defined(COFF_WITH_PE)
 602   if (howto->pc_relative)
 603     {
 604       *addendp -= 4;
 605
 606       /* If the symbol is defined, then the generic code is going to
 607          add back the symbol value in order to cancel out an
 608          adjustment it made to the addend.  However, we set the addend
 609          to 0 at the start of this function.  We need to adjust here,
 610          to avoid the adjustment the generic code will make.  FIXME:
 611          This is getting a bit hackish.  */
 612       if (sym != NULL && sym->n_scnum != 0)
 613         *addendp -= sym->n_value;
 614     }
 615
 616   if (rel->r_type == R_AMD64_IMAGEBASE
 617       && (bfd_get_flavour (sec->output_section->owner) == bfd_target_coff_flavour))
 618     *addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
 619
 620   if (rel->r_type == R_AMD64_SECREL)
 621     {
 622       bfd_vma osect_vma;
 623
 624       if (h && (h->root.type == bfd_link_hash_defined
 625                 || h->root.type == bfd_link_hash_defweak))
 626         osect_vma = h->root.u.def.section->output_section->vma;
 627       else
 628         {
 629           asection *s;
 630           int i;
 631
 632           /* Sigh, the only way to get the section to offset against
 633              is to find it the hard way.  */
 634           for (s = abfd->sections, i = 1; i < sym->n_scnum; i++)
 635             s = s->next;
 636
 637           osect_vma = s->output_section->vma;
 638         }
 639
 640       *addendp -= osect_vma;
 641     }
 642 #endif
 643
 644   return howto;
 645 }
 646
 647 #define coff_bfd_reloc_type_lookup coff_amd64_reloc_type_lookup
 648 #define coff_bfd_reloc_name_lookup coff_amd64_reloc_name_lookup
 649
 650 static reloc_howto_type *
 651 coff_amd64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
 652 {
 653   switch (code)
 654     {
 655     case BFD_RELOC_RVA:
 656       return howto_table + R_AMD64_IMAGEBASE;
 657     case BFD_RELOC_32:
 658       return howto_table + R_AMD64_DIR32;
 659     case BFD_RELOC_64:
 660       return howto_table + R_AMD64_DIR64;
 661     case BFD_RELOC_64_PCREL:
 662 #ifndef DONT_EXTEND_AMD64
 663       return howto_table + R_AMD64_PCRQUAD;
 664 #else
 665       /* Fall through.  */
 666 #endif
 667     case BFD_RELOC_32_PCREL:
 668       return howto_table + R_AMD64_PCRLONG;
 669     case BFD_RELOC_X86_64_32S:
 670       return howto_table + R_RELLONG;
 671     case BFD_RELOC_16:
 672       return howto_table + R_RELWORD;
 673     case BFD_RELOC_16_PCREL:
 674       return howto_table + R_PCRWORD;
 675     case BFD_RELOC_8:
 676       return howto_table + R_RELBYTE;
 677     case BFD_RELOC_8_PCREL:
 678       return howto_table + R_PCRBYTE;
 679 #if defined(COFF_WITH_PE)
 680     case BFD_RELOC_32_SECREL:
 681       return howto_table + R_AMD64_SECREL;
 682 #endif
 683     default:
 684       BFD_FAIL ();
 685       return 0;
 686     }
 687 }
 688
 689 static reloc_howto_type *
 690 coff_amd64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 691                               const char *r_name)
 692 {
 693   unsigned int i;
 694
 695   for (i = 0; i < NUM_HOWTOS; i++)
 696     if (howto_table[i].name != NULL
 697         && strcasecmp (howto_table[i].name, r_name) == 0)
 698       return &howto_table[i];
 699
 700   return NULL;
 701 }
 702
 703 #define coff_rtype_to_howto coff_amd64_rtype_to_howto
 704
 705 #ifdef TARGET_UNDERSCORE
 706
 707 /* If amd64 gcc uses underscores for symbol names, then it does not use
 708    a leading dot for local labels, so if TARGET_UNDERSCORE is defined
 709    we treat all symbols starting with L as local.  */
 710
 711 static bfd_boolean
 712 coff_amd64_is_local_label_name (bfd *abfd, const char *name)
 713 {
 714   if (name[0] == 'L')
 715     return TRUE;
 716
 717   return _bfd_coff_is_local_label_name (abfd, name);
 718 }
 719
 720 #define coff_bfd_is_local_label_name coff_amd64_is_local_label_name
 721
 722 #endif /* TARGET_UNDERSCORE */
 723
 724 #ifndef bfd_pe_print_pdata
 725 #define bfd_pe_print_pdata   NULL
 726 #endif
 727
 728 #include "coffcode.h"
 729
 730 #ifdef PE
 731 #define amd64coff_object_p pe_bfd_object_p
 732 #else
 733 #define amd64coff_object_p coff_object_p
 734 #endif
 735
 736 const bfd_target
 737 #ifdef TARGET_SYM
 738   TARGET_SYM =
 739 #else
 740   x86_64_coff_vec =
 741 #endif
 742 {
 743 #ifdef TARGET_NAME
 744   TARGET_NAME,
 745 #else
 746  "coff-x86-64",                 /* Name.  */
 747 #endif
 748   bfd_target_coff_flavour,
 749   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */
 750   BFD_ENDIAN_LITTLE,            /* Header byte order is little.  */
 751
 752   (HAS_RELOC | EXEC_P |         /* Object flags.  */
 753    HAS_LINENO | HAS_DEBUG |
 754    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | BFD_COMPRESS | BFD_DECOMPRESS),
 755
 756   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* Section flags.  */
 757 #if defined(COFF_WITH_PE)
 758    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY | SEC_DEBUGGING
 759 #endif
 760    | SEC_CODE | SEC_DATA | SEC_EXCLUDE ),
 761
 762 #ifdef TARGET_UNDERSCORE
 763   TARGET_UNDERSCORE,            /* Leading underscore.  */
 764 #else
 765   0,                            /* Leading underscore.  */
 766 #endif
 767   '/',                          /* Ar_pad_char.  */
 768   15,                           /* Ar_max_namelen.  */
 769   0,                            /* match priority.  */
 770
 771   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 772      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 773      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
 774   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 775      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 776      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Hdrs.  */
 777
 778   /* Note that we allow an object file to be treated as a core file as well.  */
 779   { _bfd_dummy_target, amd64coff_object_p, /* BFD_check_format.  */
 780     bfd_generic_archive_p, amd64coff_object_p },
 781   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format.  */
 782     bfd_false },
 783   { bfd_false, coff_write_object_contents, /* bfd_write_contents.  */
 784    _bfd_write_archive_contents, bfd_false },
 785
 786   BFD_JUMP_TABLE_GENERIC (coff),
 787   BFD_JUMP_TABLE_COPY (coff),
 788   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 789   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 790   BFD_JUMP_TABLE_SYMBOLS (coff),
 791   BFD_JUMP_TABLE_RELOCS (coff),
 792   BFD_JUMP_TABLE_WRITE (coff),
 793   BFD_JUMP_TABLE_LINK (coff),
 794   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 795
 796   NULL,
 797
 798   COFF_SWAP_TABLE
 799 };