2000-11-10 Kazu Hirata <kazu@hxi.com>
[external/binutils.git] / bfd / coff-i386.c
1 /* BFD back-end for Intel 386 COFF files.
2    Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3    Free Software Foundation, Inc.
4    Written by Cygnus Support.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "libbfd.h"
25
26 #include "coff/i386.h"
27
28 #include "coff/internal.h"
29
30 #ifdef COFF_WITH_PE
31 #include "coff/pe.h"
32 #endif
33
34 #ifdef COFF_GO32_EXE
35 #include "coff/go32exe.h"
36 #endif
37
38 #include "libcoff.h"
39
40 static bfd_reloc_status_type coff_i386_reloc
41   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
42 static reloc_howto_type *coff_i386_rtype_to_howto
43   PARAMS ((bfd *, asection *, struct internal_reloc *,
44            struct coff_link_hash_entry *, struct internal_syment *,
45            bfd_vma *));
46 static reloc_howto_type *coff_i386_reloc_type_lookup
47   PARAMS ((bfd *, bfd_reloc_code_real_type));
48
49 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
50 /* The page size is a guess based on ELF.  */
51
52 #define COFF_PAGE_SIZE 0x1000
53
54 /* For some reason when using i386 COFF the value stored in the .text
55    section for a reference to a common symbol is the value itself plus
56    any desired offset.  Ian Taylor, Cygnus Support.  */
57
58 /* If we are producing relocateable output, we need to do some
59    adjustments to the object file that are not done by the
60    bfd_perform_relocation function.  This function is called by every
61    reloc type to make any required adjustments.  */
62
63 static bfd_reloc_status_type
64 coff_i386_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
65                  error_message)
66      bfd *abfd;
67      arelent *reloc_entry;
68      asymbol *symbol;
69      PTR data;
70      asection *input_section ATTRIBUTE_UNUSED;
71      bfd *output_bfd;
72      char **error_message ATTRIBUTE_UNUSED;
73 {
74   symvalue diff;
75
76 #ifndef COFF_WITH_PE
77   if (output_bfd == (bfd *) NULL)
78     return bfd_reloc_continue;
79 #endif
80
81   if (bfd_is_com_section (symbol->section))
82     {
83 #ifndef 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          relocateable output.  This seems to be always wrong for 386
106          COFF, so we handle the addend here instead.  */
107 #ifdef COFF_WITH_PE
108       if (output_bfd == (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-i386.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 == true && howto->pcrel_offset == true)
120             diff = -(1 << howto->size);
121           else
122             diff = -reloc_entry->addend;
123         }
124       else
125 #endif
126         diff = reloc_entry->addend;
127     }
128
129 #ifdef COFF_WITH_PE
130   /* FIXME: How should this case be handled?  */
131   if (reloc_entry->howto->type == R_IMAGEBASE)
132     diff -= pe_data (output_bfd)->pe_opthdr.ImageBase;
133 #endif
134
135 #define DOIT(x) \
136   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
137
138     if (diff != 0)
139       {
140         reloc_howto_type *howto = reloc_entry->howto;
141         unsigned char *addr = (unsigned char *) data + reloc_entry->address;
142
143         switch (howto->size)
144           {
145           case 0:
146             {
147               char x = bfd_get_8 (abfd, addr);
148               DOIT (x);
149               bfd_put_8 (abfd, x, addr);
150             }
151             break;
152
153           case 1:
154             {
155               short x = bfd_get_16 (abfd, addr);
156               DOIT (x);
157               bfd_put_16 (abfd, x, addr);
158             }
159             break;
160
161           case 2:
162             {
163               long x = bfd_get_32 (abfd, addr);
164               DOIT (x);
165               bfd_put_32 (abfd, x, addr);
166             }
167             break;
168
169           default:
170             abort ();
171           }
172       }
173
174   /* Now let bfd_perform_relocation finish everything up.  */
175   return bfd_reloc_continue;
176 }
177
178 #ifdef COFF_WITH_PE
179 /* Return true if this relocation should appear in the output .reloc
180    section.  */
181
182 static boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
183
184 static boolean in_reloc_p (abfd, howto)
185      bfd * abfd ATTRIBUTE_UNUSED;
186      reloc_howto_type *howto;
187 {
188   return ! howto->pc_relative && howto->type != R_IMAGEBASE;
189 }
190 #endif /* COFF_WITH_PE */
191
192 #ifndef PCRELOFFSET
193 #define PCRELOFFSET false
194 #endif
195
196 static reloc_howto_type howto_table[] =
197 {
198   EMPTY_HOWTO (0),
199   EMPTY_HOWTO (1),
200   EMPTY_HOWTO (2),
201   EMPTY_HOWTO (3),
202   EMPTY_HOWTO (4),
203   EMPTY_HOWTO (5),
204   HOWTO (R_DIR32,               /* type */
205          0,                     /* rightshift */
206          2,                     /* size (0 = byte, 1 = short, 2 = long) */
207          32,                    /* bitsize */
208          false,                 /* pc_relative */
209          0,                     /* bitpos */
210          complain_overflow_bitfield, /* complain_on_overflow */
211          coff_i386_reloc,       /* special_function */
212          "dir32",               /* name */
213          true,                  /* partial_inplace */
214          0xffffffff,            /* src_mask */
215          0xffffffff,            /* dst_mask */
216          true),                 /* pcrel_offset */
217   /* PE IMAGE_REL_I386_DIR32NB relocation (7).  */
218   HOWTO (R_IMAGEBASE,           /* type */
219          0,                     /* rightshift */
220          2,                     /* size (0 = byte, 1 = short, 2 = long) */
221          32,                    /* bitsize */
222          false,                 /* pc_relative */
223          0,                     /* bitpos */
224          complain_overflow_bitfield, /* complain_on_overflow */
225          coff_i386_reloc,       /* special_function */
226          "rva32",               /* name */
227          true,                  /* partial_inplace */
228          0xffffffff,            /* src_mask */
229          0xffffffff,            /* dst_mask */
230          false),                /* pcrel_offset */
231   EMPTY_HOWTO (010),
232   EMPTY_HOWTO (011),
233   EMPTY_HOWTO (012),
234   EMPTY_HOWTO (013),
235   EMPTY_HOWTO (014),
236   EMPTY_HOWTO (015),
237   EMPTY_HOWTO (016),
238   /* Byte relocation (017).  */
239   HOWTO (R_RELBYTE,             /* type */
240          0,                     /* rightshift */
241          0,                     /* size (0 = byte, 1 = short, 2 = long) */
242          8,                     /* bitsize */
243          false,                 /* pc_relative */
244          0,                     /* bitpos */
245          complain_overflow_bitfield, /* complain_on_overflow */
246          coff_i386_reloc,       /* special_function */
247          "8",                   /* name */
248          true,                  /* partial_inplace */
249          0x000000ff,            /* src_mask */
250          0x000000ff,            /* dst_mask */
251          PCRELOFFSET),          /* pcrel_offset */
252   /* 16-bit word relocation (020).  */
253   HOWTO (R_RELWORD,             /* type */
254          0,                     /* rightshift */
255          1,                     /* size (0 = byte, 1 = short, 2 = long) */
256          16,                    /* bitsize */
257          false,                 /* pc_relative */
258          0,                     /* bitpos */
259          complain_overflow_bitfield, /* complain_on_overflow */
260          coff_i386_reloc,       /* special_function */
261          "16",                  /* name */
262          true,                  /* partial_inplace */
263          0x0000ffff,            /* src_mask */
264          0x0000ffff,            /* dst_mask */
265          PCRELOFFSET),          /* pcrel_offset */
266   /* 32-bit longword relocation (021).  */
267   HOWTO (R_RELLONG,             /* type */
268          0,                     /* rightshift */
269          2,                     /* size (0 = byte, 1 = short, 2 = long) */
270          32,                    /* bitsize */
271          false,                 /* pc_relative */
272          0,                     /* bitpos */
273          complain_overflow_bitfield, /* complain_on_overflow */
274          coff_i386_reloc,       /* special_function */
275          "32",                  /* name */
276          true,                  /* partial_inplace */
277          0xffffffff,            /* src_mask */
278          0xffffffff,            /* dst_mask */
279          PCRELOFFSET),          /* pcrel_offset */
280   /* Byte PC relative relocation (022).  */
281   HOWTO (R_PCRBYTE,             /* type */
282          0,                     /* rightshift */
283          0,                     /* size (0 = byte, 1 = short, 2 = long) */
284          8,                     /* bitsize */
285          true,                  /* pc_relative */
286          0,                     /* bitpos */
287          complain_overflow_signed, /* complain_on_overflow */
288          coff_i386_reloc,       /* special_function */
289          "DISP8",               /* name */
290          true,                  /* partial_inplace */
291          0x000000ff,            /* src_mask */
292          0x000000ff,            /* dst_mask */
293          PCRELOFFSET),          /* pcrel_offset */
294   /* 16-bit word PC relative relocation (023).  */
295   HOWTO (R_PCRWORD,             /* type */
296          0,                     /* rightshift */
297          1,                     /* size (0 = byte, 1 = short, 2 = long) */
298          16,                    /* bitsize */
299          true,                  /* pc_relative */
300          0,                     /* bitpos */
301          complain_overflow_signed, /* complain_on_overflow */
302          coff_i386_reloc,       /* special_function */
303          "DISP16",              /* name */
304          true,                  /* partial_inplace */
305          0x0000ffff,            /* src_mask */
306          0x0000ffff,            /* dst_mask */
307          PCRELOFFSET),          /* pcrel_offset */
308   /* 32-bit longword PC relative relocation (024).  */
309   HOWTO (R_PCRLONG,             /* type */
310          0,                     /* rightshift */
311          2,                     /* size (0 = byte, 1 = short, 2 = long) */
312          32,                    /* bitsize */
313          true,                  /* pc_relative */
314          0,                     /* bitpos */
315          complain_overflow_signed, /* complain_on_overflow */
316          coff_i386_reloc,       /* special_function */
317          "DISP32",              /* name */
318          true,                  /* partial_inplace */
319          0xffffffff,            /* src_mask */
320          0xffffffff,            /* dst_mask */
321          PCRELOFFSET)           /* pcrel_offset */
322 };
323
324 /* Turn a howto into a reloc  nunmber */
325
326 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
327 #define BADMAG(x) I386BADMAG(x)
328 #define I386 1                  /* Customize coffcode.h */
329
330 #define RTYPE2HOWTO(cache_ptr, dst)                                     \
331   ((cache_ptr)->howto =                                                 \
332    ((dst)->r_type < sizeof (howto_table) / sizeof (howto_table[0])      \
333     ? howto_table + (dst)->r_type                                       \
334     : NULL))
335
336 /* For 386 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
337    library.  On some other COFF targets STYP_BSS is normally
338    STYP_NOLOAD.  */
339 #define BSS_NOLOAD_IS_SHARED_LIBRARY
340
341 /* Compute the addend of a reloc.  If the reloc is to a common symbol,
342    the object file contains the value of the common symbol.  By the
343    time this is called, the linker may be using a different symbol
344    from a different object file with a different value.  Therefore, we
345    hack wildly to locate the original symbol from this file so that we
346    can make the correct adjustment.  This macro sets coffsym to the
347    symbol from the original file, and uses it to set the addend value
348    correctly.  If this is not a common symbol, the usual addend
349    calculation is done, except that an additional tweak is needed for
350    PC relative relocs.
351    FIXME: This macro refers to symbols and asect; these are from the
352    calling function, not the macro arguments.  */
353
354 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
355   {                                                             \
356     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
357     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
358       coffsym = (obj_symbols (abfd)                             \
359                  + (cache_ptr->sym_ptr_ptr - symbols));         \
360     else if (ptr)                                               \
361       coffsym = coff_symbol_from (abfd, ptr);                   \
362     if (coffsym != (coff_symbol_type *) NULL                    \
363         && coffsym->native->u.syment.n_scnum == 0)              \
364       cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
365     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
366              && ptr->section != (asection *) NULL)              \
367       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
368     else                                                        \
369       cache_ptr->addend = 0;                                    \
370     if (ptr && howto_table[reloc.r_type].pc_relative)           \
371       cache_ptr->addend += asect->vma;                          \
372   }
373
374 /* We use the special COFF backend linker.  For normal i386 COFF, we
375    can use the generic relocate_section routine.  For PE, we need our
376    own routine.  */
377
378 #ifndef COFF_WITH_PE
379
380 #define coff_relocate_section _bfd_coff_generic_relocate_section
381
382 #else /* COFF_WITH_PE */
383
384 /* The PE relocate section routine.  The only difference between this
385    and the regular routine is that we don't want to do anything for a
386    relocateable link.  */
387
388 static boolean coff_pe_i386_relocate_section
389   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
390            struct internal_reloc *, struct internal_syment *, asection **));
391
392 static boolean
393 coff_pe_i386_relocate_section (output_bfd, info, input_bfd,
394                                input_section, contents, relocs, syms,
395                                sections)
396      bfd *output_bfd;
397      struct bfd_link_info *info;
398      bfd *input_bfd;
399      asection *input_section;
400      bfd_byte *contents;
401      struct internal_reloc *relocs;
402      struct internal_syment *syms;
403      asection **sections;
404 {
405   if (info->relocateable)
406     return true;
407
408   return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
409                                              input_section, contents,
410                                              relocs, syms, sections);
411 }
412
413 #define coff_relocate_section coff_pe_i386_relocate_section
414
415 #endif /* COFF_WITH_PE */
416
417 /* Convert an rtype to howto for the COFF backend linker.  */
418
419 static reloc_howto_type *
420 coff_i386_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
421      bfd *abfd ATTRIBUTE_UNUSED;
422      asection *sec;
423      struct internal_reloc *rel;
424      struct coff_link_hash_entry *h;
425      struct internal_syment *sym;
426      bfd_vma *addendp;
427 {
428   reloc_howto_type *howto;
429
430   if (rel->r_type > sizeof (howto_table) / sizeof (howto_table[0]))
431     {
432       bfd_set_error (bfd_error_bad_value);
433       return NULL;
434     }
435
436   howto = howto_table + rel->r_type;
437
438 #ifdef COFF_WITH_PE
439   /* Cancel out code in _bfd_coff_generic_relocate_section.  */
440   *addendp = 0;
441 #endif
442
443   if (howto->pc_relative)
444     *addendp += sec->vma;
445
446   if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
447     {
448       /* This is a common symbol.  The section contents include the
449          size (sym->n_value) as an addend.  The relocate_section
450          function will be adding in the final value of the symbol.  We
451          need to subtract out the current size in order to get the
452          correct result.  */
453
454       BFD_ASSERT (h != NULL);
455
456 #ifndef COFF_WITH_PE
457       /* I think we *do* want to bypass this.  If we don't, I have
458          seen some data parameters get the wrong relocation address.
459          If I link two versions with and without this section bypassed
460          and then do a binary comparison, the addresses which are
461          different can be looked up in the map.  The case in which
462          this section has been bypassed has addresses which correspond
463          to values I can find in the map.  */
464       *addendp -= sym->n_value;
465 #endif
466     }
467
468 #ifndef COFF_WITH_PE
469   /* If the output symbol is common (in which case this must be a
470      relocateable link), we need to add in the final size of the
471      common symbol.  */
472   if (h != NULL && h->root.type == bfd_link_hash_common)
473     *addendp += h->root.u.c.size;
474 #endif
475
476 #ifdef COFF_WITH_PE
477   if (howto->pc_relative)
478     {
479       *addendp -= 4;
480
481       /* If the symbol is defined, then the generic code is going to
482          add back the symbol value in order to cancel out an
483          adjustment it made to the addend.  However, we set the addend
484          to 0 at the start of this function.  We need to adjust here,
485          to avoid the adjustment the generic code will make.  FIXME:
486          This is getting a bit hackish.  */
487       if (sym != NULL && sym->n_scnum != 0)
488         *addendp -= sym->n_value;
489     }
490
491   if (rel->r_type == R_IMAGEBASE)
492     {
493       *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
494     }
495 #endif
496
497   return howto;
498 }
499
500 #define coff_bfd_reloc_type_lookup coff_i386_reloc_type_lookup
501
502 static reloc_howto_type *
503 coff_i386_reloc_type_lookup (abfd, code)
504      bfd *abfd ATTRIBUTE_UNUSED;
505      bfd_reloc_code_real_type code;
506 {
507   switch (code)
508     {
509     case BFD_RELOC_RVA:
510       return howto_table + R_IMAGEBASE;
511     case BFD_RELOC_32:
512       return howto_table + R_DIR32;
513     case BFD_RELOC_32_PCREL:
514       return howto_table + R_PCRLONG;
515     case BFD_RELOC_16:
516       return howto_table + R_RELWORD;
517     case BFD_RELOC_16_PCREL:
518       return howto_table + R_PCRWORD;
519     case BFD_RELOC_8:
520       return howto_table + R_RELBYTE;
521     case BFD_RELOC_8_PCREL:
522       return howto_table + R_PCRBYTE;
523     default:
524       BFD_FAIL ();
525       return 0;
526     }
527 }
528
529 #define coff_rtype_to_howto coff_i386_rtype_to_howto
530
531 #ifdef TARGET_UNDERSCORE
532
533 /* If i386 gcc uses underscores for symbol names, then it does not use
534    a leading dot for local labels, so if TARGET_UNDERSCORE is defined
535    we treat all symbols starting with L as local.  */
536
537 static boolean coff_i386_is_local_label_name PARAMS ((bfd *, const char *));
538
539 static boolean
540 coff_i386_is_local_label_name (abfd, name)
541      bfd *abfd;
542      const char *name;
543 {
544   if (name[0] == 'L')
545     return true;
546
547   return _bfd_coff_is_local_label_name (abfd, name);
548 }
549
550 #define coff_bfd_is_local_label_name coff_i386_is_local_label_name
551
552 #endif /* TARGET_UNDERSCORE */
553
554 #include "coffcode.h"
555
556 const bfd_target
557 #ifdef TARGET_SYM
558   TARGET_SYM =
559 #else
560   i386coff_vec =
561 #endif
562 {
563 #ifdef TARGET_NAME
564   TARGET_NAME,
565 #else
566   "coff-i386",                  /* name */
567 #endif
568   bfd_target_coff_flavour,
569   BFD_ENDIAN_LITTLE,            /* data byte order is little */
570   BFD_ENDIAN_LITTLE,            /* header byte order is little */
571
572   (HAS_RELOC | EXEC_P |         /* object flags */
573    HAS_LINENO | HAS_DEBUG |
574    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
575
576   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
577 #ifdef COFF_WITH_PE
578    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES
579 #endif
580    | SEC_CODE | SEC_DATA),
581
582 #ifdef TARGET_UNDERSCORE
583   TARGET_UNDERSCORE,            /* leading underscore */
584 #else
585   0,                            /* leading underscore */
586 #endif
587   '/',                          /* ar_pad_char */
588   15,                           /* ar_max_namelen */
589
590   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
591      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
592      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
593   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
594      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
595      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
596
597 /* Note that we allow an object file to be treated as a core file as well.  */
598     {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
599        bfd_generic_archive_p, coff_object_p},
600     {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
601        bfd_false},
602     {bfd_false, coff_write_object_contents, /* bfd_write_contents */
603        _bfd_write_archive_contents, bfd_false},
604
605      BFD_JUMP_TABLE_GENERIC (coff),
606      BFD_JUMP_TABLE_COPY (coff),
607      BFD_JUMP_TABLE_CORE (_bfd_nocore),
608      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
609      BFD_JUMP_TABLE_SYMBOLS (coff),
610      BFD_JUMP_TABLE_RELOCS (coff),
611      BFD_JUMP_TABLE_WRITE (coff),
612      BFD_JUMP_TABLE_LINK (coff),
613      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
614
615   NULL,
616
617   COFF_SWAP_TABLE
618 };