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