OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [bfd/] [coff-x86_64.c] - Blame information for rev 834

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.