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