bfd/coff-i386.c

   1 /* BFD back-end for Intel 386 COFF files.
   2    Copyright (C) 1990-2022 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   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 #include "sysdep.h"
  23 #include "bfd.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 #ifndef bfd_pe_print_pdata
  35 #define bfd_pe_print_pdata      NULL
  36 #endif
  37
  38 #include "libcoff.h"
  39
  40 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1.  */
  41 #define OCTETS_PER_BYTE(ABFD, SEC) 1
  42
  43 static reloc_howto_type *coff_i386_rtype_to_howto
  44   (bfd *, asection *, struct internal_reloc *,
  45    struct coff_link_hash_entry *, struct internal_syment *,
  46    bfd_vma *);
  47 static reloc_howto_type *coff_i386_reloc_type_lookup
  48   (bfd *, bfd_reloc_code_real_type);
  49
  50 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
  51 /* The page size is a guess based on ELF.  */
  52
  53 #define COFF_PAGE_SIZE 0x1000
  54
  55 /* For some reason when using i386 COFF the value stored in the .text
  56    section for a reference to a common symbol is the value itself plus
  57    any desired offset.  Ian Taylor, Cygnus Support.  */
  58
  59 /* If we are producing relocatable output, we need to do some
  60    adjustments to the object file that are not done by the
  61    bfd_perform_relocation function.  This function is called by every
  62    reloc type to make any required adjustments.  */
  63
  64 static bfd_reloc_status_type
  65 coff_i386_reloc (bfd *abfd,
  66                  arelent *reloc_entry,
  67                  asymbol *symbol,
  68                  void * data,
  69                  asection *input_section,
  70                  bfd *output_bfd,
  71                  char **error_message ATTRIBUTE_UNUSED)
  72 {
  73   symvalue diff;
  74
  75 #ifndef COFF_WITH_PE
  76   if (output_bfd == (bfd *) NULL)
  77     return bfd_reloc_continue;
  78 #endif
  79
  80   if (bfd_is_com_section (symbol->section))
  81     {
  82 #ifndef 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 #ifdef COFF_WITH_PE
 107       if (output_bfd == (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-i386.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 #ifdef COFF_WITH_PE
 131   /* FIXME: How should this case be handled?  */
 132   if (reloc_entry->howto->type == R_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       bfd_size_type octets = (reloc_entry->address
 145                               * OCTETS_PER_BYTE (abfd, input_section));
 146       unsigned char *addr = (unsigned char *) data + octets;
 147
 148       if (!bfd_reloc_offset_in_range (howto, abfd, input_section, octets))
 149         return bfd_reloc_outofrange;
 150
 151       switch (howto->size)
 152         {
 153         case 0:
 154           {
 155             char x = bfd_get_8 (abfd, addr);
 156             DOIT (x);
 157             bfd_put_8 (abfd, x, addr);
 158           }
 159           break;
 160
 161         case 1:
 162           {
 163             short x = bfd_get_16 (abfd, addr);
 164             DOIT (x);
 165             bfd_put_16 (abfd, (bfd_vma) x, addr);
 166           }
 167           break;
 168
 169         case 2:
 170           {
 171             long x = bfd_get_32 (abfd, addr);
 172             DOIT (x);
 173             bfd_put_32 (abfd, (bfd_vma) x, addr);
 174           }
 175           break;
 176
 177         default:
 178           abort ();
 179         }
 180     }
 181
 182   /* Now let bfd_perform_relocation finish everything up.  */
 183   return bfd_reloc_continue;
 184 }
 185
 186 #ifdef COFF_WITH_PE
 187 /* Return TRUE if this relocation should appear in the output .reloc
 188    section.  */
 189
 190 static bool
 191 in_reloc_p (bfd *abfd ATTRIBUTE_UNUSED, reloc_howto_type *howto)
 192 {
 193   return ! howto->pc_relative
 194     && howto->type != R_IMAGEBASE
 195     && howto->type != R_SECREL32
 196     && howto->type != R_SECTION;
 197 }
 198 #endif /* COFF_WITH_PE */
 199
 200 #ifndef PCRELOFFSET
 201 #define PCRELOFFSET false
 202 #endif
 203
 204 static reloc_howto_type howto_table[] =
 205 {
 206   EMPTY_HOWTO (0),
 207   EMPTY_HOWTO (1),
 208   EMPTY_HOWTO (2),
 209   EMPTY_HOWTO (3),
 210   EMPTY_HOWTO (4),
 211   EMPTY_HOWTO (5),
 212   HOWTO (R_DIR32,               /* type */
 213          0,                     /* rightshift */
 214          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 215          32,                    /* bitsize */
 216          false,                 /* pc_relative */
 217          0,                     /* bitpos */
 218          complain_overflow_bitfield, /* complain_on_overflow */
 219          coff_i386_reloc,       /* special_function */
 220          "dir32",               /* name */
 221          true,                  /* partial_inplace */
 222          0xffffffff,            /* src_mask */
 223          0xffffffff,            /* dst_mask */
 224          true),                 /* pcrel_offset */
 225   /* PE IMAGE_REL_I386_DIR32NB relocation (7).  */
 226   HOWTO (R_IMAGEBASE,           /* type */
 227          0,                     /* rightshift */
 228          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 229          32,                    /* bitsize */
 230          false,                 /* pc_relative */
 231          0,                     /* bitpos */
 232          complain_overflow_bitfield, /* complain_on_overflow */
 233          coff_i386_reloc,       /* special_function */
 234          "rva32",               /* name */
 235          true,                  /* partial_inplace */
 236          0xffffffff,            /* src_mask */
 237          0xffffffff,            /* dst_mask */
 238          false),                /* pcrel_offset */
 239   EMPTY_HOWTO (010),
 240   EMPTY_HOWTO (011),
 241 #ifdef COFF_WITH_PE
 242   /* 16-bit word section relocation (012).  */
 243   HOWTO (R_SECTION,             /* type */
 244          0,                     /* rightshift */
 245          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 246          16,                    /* bitsize */
 247          false,                 /* pc_relative */
 248          0,                     /* bitpos */
 249          complain_overflow_bitfield, /* complain_on_overflow */
 250          coff_i386_reloc,       /* special_function */
 251          "secidx",              /* name */
 252          true,                  /* partial_inplace */
 253          0xffffffff,            /* src_mask */
 254          0xffffffff,            /* dst_mask */
 255          true),                 /* pcrel_offset */
 256   /* 32-bit longword section relative relocation (013).  */
 257   HOWTO (R_SECREL32,            /* type */
 258          0,                     /* rightshift */
 259          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 260          32,                    /* bitsize */
 261          false,                 /* pc_relative */
 262          0,                     /* bitpos */
 263          complain_overflow_bitfield, /* complain_on_overflow */
 264          coff_i386_reloc,       /* special_function */
 265          "secrel32",            /* name */
 266          true,                  /* partial_inplace */
 267          0xffffffff,            /* src_mask */
 268          0xffffffff,            /* dst_mask */
 269          true),                 /* pcrel_offset */
 270 #else
 271   EMPTY_HOWTO (012),
 272   EMPTY_HOWTO (013),
 273 #endif
 274   EMPTY_HOWTO (014),
 275   EMPTY_HOWTO (015),
 276   EMPTY_HOWTO (016),
 277   /* Byte relocation (017).  */
 278   HOWTO (R_RELBYTE,             /* type */
 279          0,                     /* rightshift */
 280          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 281          8,                     /* bitsize */
 282          false,                 /* pc_relative */
 283          0,                     /* bitpos */
 284          complain_overflow_bitfield, /* complain_on_overflow */
 285          coff_i386_reloc,       /* special_function */
 286          "8",                   /* name */
 287          true,                  /* partial_inplace */
 288          0x000000ff,            /* src_mask */
 289          0x000000ff,            /* dst_mask */
 290          PCRELOFFSET),          /* pcrel_offset */
 291   /* 16-bit word relocation (020).  */
 292   HOWTO (R_RELWORD,             /* type */
 293          0,                     /* rightshift */
 294          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 295          16,                    /* bitsize */
 296          false,                 /* pc_relative */
 297          0,                     /* bitpos */
 298          complain_overflow_bitfield, /* complain_on_overflow */
 299          coff_i386_reloc,       /* special_function */
 300          "16",                  /* name */
 301          true,                  /* partial_inplace */
 302          0x0000ffff,            /* src_mask */
 303          0x0000ffff,            /* dst_mask */
 304          PCRELOFFSET),          /* pcrel_offset */
 305   /* 32-bit longword relocation (021).  */
 306   HOWTO (R_RELLONG,             /* type */
 307          0,                     /* rightshift */
 308          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 309          32,                    /* bitsize */
 310          false,                 /* pc_relative */
 311          0,                     /* bitpos */
 312          complain_overflow_bitfield, /* complain_on_overflow */
 313          coff_i386_reloc,       /* special_function */
 314          "32",                  /* name */
 315          true,                  /* partial_inplace */
 316          0xffffffff,            /* src_mask */
 317          0xffffffff,            /* dst_mask */
 318          PCRELOFFSET),          /* pcrel_offset */
 319   /* Byte PC relative relocation (022).  */
 320   HOWTO (R_PCRBYTE,             /* type */
 321          0,                     /* rightshift */
 322          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 323          8,                     /* bitsize */
 324          true,                  /* pc_relative */
 325          0,                     /* bitpos */
 326          complain_overflow_signed, /* complain_on_overflow */
 327          coff_i386_reloc,       /* special_function */
 328          "DISP8",               /* name */
 329          true,                  /* partial_inplace */
 330          0x000000ff,            /* src_mask */
 331          0x000000ff,            /* dst_mask */
 332          PCRELOFFSET),          /* pcrel_offset */
 333   /* 16-bit word PC relative relocation (023).  */
 334   HOWTO (R_PCRWORD,             /* type */
 335          0,                     /* rightshift */
 336          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 337          16,                    /* bitsize */
 338          true,                  /* pc_relative */
 339          0,                     /* bitpos */
 340          complain_overflow_signed, /* complain_on_overflow */
 341          coff_i386_reloc,       /* special_function */
 342          "DISP16",              /* name */
 343          true,                  /* partial_inplace */
 344          0x0000ffff,            /* src_mask */
 345          0x0000ffff,            /* dst_mask */
 346          PCRELOFFSET),          /* pcrel_offset */
 347   /* 32-bit longword PC relative relocation (024).  */
 348   HOWTO (R_PCRLONG,             /* type */
 349          0,                     /* rightshift */
 350          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 351          32,                    /* bitsize */
 352          true,                  /* pc_relative */
 353          0,                     /* bitpos */
 354          complain_overflow_signed, /* complain_on_overflow */
 355          coff_i386_reloc,       /* special_function */
 356          "DISP32",              /* name */
 357          true,                  /* partial_inplace */
 358          0xffffffff,            /* src_mask */
 359          0xffffffff,            /* dst_mask */
 360          PCRELOFFSET)           /* pcrel_offset */
 361 };
 362
 363 #define NUM_HOWTOS (sizeof (howto_table) / sizeof (howto_table[0]))
 364
 365 /* Turn a howto into a reloc  nunmber */
 366
 367 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
 368 #define BADMAG(x) I386BADMAG(x)
 369 #define I386 1                  /* Customize coffcode.h */
 370
 371 #define RTYPE2HOWTO(cache_ptr, dst)                             \
 372   ((cache_ptr)->howto =                                         \
 373    ((dst)->r_type < NUM_HOWTOS                                  \
 374     ? howto_table + (dst)->r_type                               \
 375     : NULL))
 376
 377 /* For 386 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
 378    library.  On some other COFF targets STYP_BSS is normally
 379    STYP_NOLOAD.  */
 380 #define BSS_NOLOAD_IS_SHARED_LIBRARY
 381
 382 /* Compute the addend of a reloc.  If the reloc is to a common symbol,
 383    the object file contains the value of the common symbol.  By the
 384    time this is called, the linker may be using a different symbol
 385    from a different object file with a different value.  Therefore, we
 386    hack wildly to locate the original symbol from this file so that we
 387    can make the correct adjustment.  This macro sets coffsym to the
 388    symbol from the original file, and uses it to set the addend value
 389    correctly.  If this is not a common symbol, the usual addend
 390    calculation is done, except that an additional tweak is needed for
 391    PC relative relocs.
 392    FIXME: This macro refers to symbols and asect; these are from the
 393    calling function, not the macro arguments.  */
 394
 395 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
 396   {                                                             \
 397     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
 398     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
 399       coffsym = (obj_symbols (abfd)                             \
 400                  + (cache_ptr->sym_ptr_ptr - symbols));         \
 401     else if (ptr)                                               \
 402       coffsym = coff_symbol_from (ptr);                         \
 403     if (coffsym != (coff_symbol_type *) NULL                    \
 404         && coffsym->native->u.syment.n_scnum == 0)              \
 405       cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
 406     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
 407              && ptr->section != (asection *) NULL)              \
 408       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
 409     else                                                        \
 410       cache_ptr->addend = 0;                                    \
 411     if (ptr && reloc.r_type < NUM_HOWTOS                        \
 412         && howto_table[reloc.r_type].pc_relative)               \
 413       cache_ptr->addend += asect->vma;                          \
 414   }
 415
 416 /* We use the special COFF backend linker.  For normal i386 COFF, we
 417    can use the generic relocate_section routine.  For PE, we need our
 418    own routine.  */
 419
 420 #ifndef COFF_WITH_PE
 421
 422 #define coff_relocate_section _bfd_coff_generic_relocate_section
 423
 424 #else /* COFF_WITH_PE */
 425
 426 /* The PE relocate section routine.  We handle secidx relocations here,
 427    as well as making sure that we don't do anything for a relocatable
 428    link.  */
 429
 430 static bool
 431 coff_pe_i386_relocate_section (bfd *output_bfd,
 432                                struct bfd_link_info *info,
 433                                bfd *input_bfd,
 434                                asection *input_section,
 435                                bfd_byte *contents,
 436                                struct internal_reloc *relocs,
 437                                struct internal_syment *syms,
 438                                asection **sections)
 439 {
 440   struct internal_reloc *rel;
 441   struct internal_reloc *relend;
 442
 443   if (bfd_link_relocatable (info))
 444     return true;
 445
 446   rel = relocs;
 447   relend = rel + input_section->reloc_count;
 448
 449   for (; rel < relend; rel++)
 450     {
 451       long symndx;
 452       struct coff_link_hash_entry *h;
 453       asection *sec, *s;
 454       uint16_t idx = 0, i = 1;
 455
 456       if (rel->r_type != R_SECTION)
 457         continue;
 458
 459       /* Make sure that _bfd_coff_generic_relocate_section won't parse
 460          this reloc after us.  */
 461       rel->r_type = 0;
 462
 463       symndx = rel->r_symndx;
 464
 465       if (symndx < 0
 466           || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
 467         continue;
 468
 469       h = obj_coff_sym_hashes (input_bfd)[symndx];
 470
 471       if (h == NULL)
 472         sec = sections[symndx];
 473       else
 474         {
 475           if (h->root.type == bfd_link_hash_defined
 476               || h->root.type == bfd_link_hash_defweak)
 477             {
 478               /* Defined weak symbols are a GNU extension.  */
 479               sec = h->root.u.def.section;
 480             }
 481           else
 482             {
 483               sec = NULL;
 484             }
 485         }
 486
 487       if (!sec)
 488         continue;
 489
 490       if (bfd_is_abs_section (sec))
 491         continue;
 492
 493       if (discarded_section (sec))
 494         continue;
 495
 496       s = output_bfd->sections;
 497       while (s)
 498         {
 499           if (s == sec->output_section)
 500             {
 501               idx = i;
 502               break;
 503             }
 504
 505           i++;
 506           s = s->next;
 507         }
 508
 509       bfd_putl16 (idx, contents + rel->r_vaddr - input_section->vma);
 510     }
 511
 512   return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
 513                                              input_section, contents,
 514                                              relocs, syms, sections);
 515 }
 516
 517 #define coff_relocate_section coff_pe_i386_relocate_section
 518
 519 #endif /* COFF_WITH_PE */
 520
 521 /* Convert an rtype to howto for the COFF backend linker.  */
 522
 523 static reloc_howto_type *
 524 coff_i386_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 525                           asection *sec,
 526                           struct internal_reloc *rel,
 527                           struct coff_link_hash_entry *h,
 528                           struct internal_syment *sym,
 529                           bfd_vma *addendp)
 530 {
 531   reloc_howto_type *howto;
 532
 533   if (rel->r_type >= NUM_HOWTOS)
 534     {
 535       bfd_set_error (bfd_error_bad_value);
 536       return NULL;
 537     }
 538
 539   howto = howto_table + rel->r_type;
 540
 541 #ifdef COFF_WITH_PE
 542   /* Cancel out code in _bfd_coff_generic_relocate_section.  */
 543   *addendp = 0;
 544 #endif
 545
 546   if (howto->pc_relative)
 547     *addendp += sec->vma;
 548
 549   if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
 550     {
 551       /* This is a common symbol.  The section contents include the
 552          size (sym->n_value) as an addend.  The relocate_section
 553          function will be adding in the final value of the symbol.  We
 554          need to subtract out the current size in order to get the
 555          correct result.  */
 556
 557       BFD_ASSERT (h != NULL);
 558
 559 #ifndef COFF_WITH_PE
 560       /* I think we *do* want to bypass this.  If we don't, I have
 561          seen some data parameters get the wrong relocation address.
 562          If I link two versions with and without this section bypassed
 563          and then do a binary comparison, the addresses which are
 564          different can be looked up in the map.  The case in which
 565          this section has been bypassed has addresses which correspond
 566          to values I can find in the map.  */
 567       *addendp -= sym->n_value;
 568 #endif
 569     }
 570
 571 #ifndef COFF_WITH_PE
 572   /* If the output symbol is common (in which case this must be a
 573      relocatable link), we need to add in the final size of the
 574      common symbol.  */
 575   if (h != NULL && h->root.type == bfd_link_hash_common)
 576     *addendp += h->root.u.c.size;
 577 #endif
 578
 579 #ifdef COFF_WITH_PE
 580   if (howto->pc_relative)
 581     {
 582       *addendp -= 4;
 583
 584       /* If the symbol is defined, then the generic code is going to
 585          add back the symbol value in order to cancel out an
 586          adjustment it made to the addend.  However, we set the addend
 587          to 0 at the start of this function.  We need to adjust here,
 588          to avoid the adjustment the generic code will make.  FIXME:
 589          This is getting a bit hackish.  */
 590       if (sym != NULL && sym->n_scnum != 0)
 591         *addendp -= sym->n_value;
 592     }
 593
 594   if (rel->r_type == R_IMAGEBASE
 595       && (bfd_get_flavour(sec->output_section->owner)
 596           == bfd_target_coff_flavour))
 597     {
 598       *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
 599     }
 600
 601   /* PR 17099 - Absolute R_PCRLONG relocations do not need a symbol.  */
 602   if (rel->r_type == R_PCRLONG && sym == NULL)
 603     *addendp -= rel->r_vaddr;
 604   else
 605     BFD_ASSERT (sym != NULL);
 606
 607   if (rel->r_type == R_SECREL32 && sym != NULL)
 608     {
 609       bfd_vma osect_vma;
 610
 611       if (h && (h->root.type == bfd_link_hash_defined
 612                 || h->root.type == bfd_link_hash_defweak))
 613         osect_vma = h->root.u.def.section->output_section->vma;
 614       else
 615         {
 616           asection *s;
 617           int i;
 618
 619           /* Sigh, the only way to get the section to offset against
 620              is to find it the hard way.  */
 621
 622           for (s = abfd->sections, i = 1; i < sym->n_scnum; i++)
 623             s = s->next;
 624
 625           osect_vma = s->output_section->vma;
 626         }
 627
 628       *addendp -= osect_vma;
 629     }
 630 #endif
 631
 632   return howto;
 633 }
 634
 635 #define coff_bfd_reloc_type_lookup coff_i386_reloc_type_lookup
 636 #define coff_bfd_reloc_name_lookup coff_i386_reloc_name_lookup
 637
 638 static reloc_howto_type *
 639 coff_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 640                              bfd_reloc_code_real_type code)
 641 {
 642   switch (code)
 643     {
 644     case BFD_RELOC_RVA:
 645       return howto_table + R_IMAGEBASE;
 646     case BFD_RELOC_32:
 647       return howto_table + R_DIR32;
 648     case BFD_RELOC_32_PCREL:
 649       return howto_table + R_PCRLONG;
 650     case BFD_RELOC_16:
 651       return howto_table + R_RELWORD;
 652     case BFD_RELOC_16_PCREL:
 653       return howto_table + R_PCRWORD;
 654     case BFD_RELOC_8:
 655       return howto_table + R_RELBYTE;
 656     case BFD_RELOC_8_PCREL:
 657       return howto_table + R_PCRBYTE;
 658 #ifdef COFF_WITH_PE
 659     case BFD_RELOC_32_SECREL:
 660       return howto_table + R_SECREL32;
 661     case BFD_RELOC_16_SECIDX:
 662       return howto_table + R_SECTION;
 663 #endif
 664     default:
 665       BFD_FAIL ();
 666       return 0;
 667     }
 668 }
 669
 670 static reloc_howto_type *
 671 coff_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 672                              const char *r_name)
 673 {
 674   unsigned int i;
 675
 676   for (i = 0; i < NUM_HOWTOS; i++)
 677     if (howto_table[i].name != NULL
 678         && strcasecmp (howto_table[i].name, r_name) == 0)
 679       return &howto_table[i];
 680
 681   return NULL;
 682 }
 683
 684 #define coff_rtype_to_howto coff_i386_rtype_to_howto
 685
 686 #ifdef TARGET_UNDERSCORE
 687
 688 /* If i386 gcc uses underscores for symbol names, then it does not use
 689    a leading dot for local labels, so if TARGET_UNDERSCORE is defined
 690    we treat all symbols starting with L as local.  */
 691
 692 static bool
 693 coff_i386_is_local_label_name (bfd *abfd, const char *name)
 694 {
 695   if (name[0] == 'L')
 696     return true;
 697
 698   return _bfd_coff_is_local_label_name (abfd, name);
 699 }
 700
 701 #define coff_bfd_is_local_label_name coff_i386_is_local_label_name
 702
 703 #endif /* TARGET_UNDERSCORE */
 704
 705 #include "coffcode.h"
 706
 707 const bfd_target
 708 #ifdef TARGET_SYM
 709   TARGET_SYM =
 710 #else
 711   i386_coff_vec =
 712 #endif
 713 {
 714 #ifdef TARGET_NAME
 715   TARGET_NAME,
 716 #else
 717   "coff-i386",                  /* name */
 718 #endif
 719   bfd_target_coff_flavour,
 720   BFD_ENDIAN_LITTLE,            /* data byte order is little */
 721   BFD_ENDIAN_LITTLE,            /* header byte order is little */
 722
 723   (HAS_RELOC | EXEC_P |         /* object flags */
 724    HAS_LINENO | HAS_DEBUG |
 725    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | BFD_COMPRESS | BFD_DECOMPRESS ),
 726
 727   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
 728 #ifdef COFF_WITH_PE
 729    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY | SEC_DEBUGGING
 730 #endif
 731    | SEC_CODE | SEC_DATA | SEC_EXCLUDE ),
 732
 733 #ifdef TARGET_UNDERSCORE
 734   TARGET_UNDERSCORE,            /* leading underscore */
 735 #else
 736   0,                            /* leading underscore */
 737 #endif
 738   '/',                          /* ar_pad_char */
 739   15,                           /* ar_max_namelen */
 740   0,                            /* match priority.  */
 741   TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
 742
 743   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 744      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 745      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 746   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 747      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 748      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
 749
 750 #ifndef COFF_CHECK_FORMAT
 751 #define COFF_CHECK_FORMAT coff_object_p
 752 #endif
 753 #ifndef COFF_WRITE_CONTENTS
 754 #define COFF_WRITE_CONTENTS coff_write_object_contents
 755 #endif
 756
 757 /* Note that we allow an object file to be treated as a core file as well.  */
 758
 759   {                             /* bfd_check_format */
 760     _bfd_dummy_target,
 761     COFF_CHECK_FORMAT,
 762     bfd_generic_archive_p,
 763     COFF_CHECK_FORMAT
 764   },
 765   {                             /* bfd_set_format */
 766     _bfd_bool_bfd_false_error,
 767     coff_mkobject,
 768     _bfd_generic_mkarchive,
 769     _bfd_bool_bfd_false_error
 770   },
 771   {                             /* bfd_write_contents */
 772     _bfd_bool_bfd_false_error,
 773     COFF_WRITE_CONTENTS,
 774     _bfd_write_archive_contents,
 775     _bfd_bool_bfd_false_error
 776   },
 777
 778   BFD_JUMP_TABLE_GENERIC (coff),
 779   BFD_JUMP_TABLE_COPY (coff),
 780   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 781   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 782   BFD_JUMP_TABLE_SYMBOLS (coff),
 783   BFD_JUMP_TABLE_RELOCS (coff),
 784   BFD_JUMP_TABLE_WRITE (coff),
 785   BFD_JUMP_TABLE_LINK (coff),
 786   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 787
 788   NULL,
 789
 790   COFF_SWAP_TABLE
 791 };
 792
 793 #ifdef COFF_WITH_PE_BIGOBJ
 794 const bfd_target
 795   TARGET_SYM_BIG =
 796 {
 797   TARGET_NAME_BIG,
 798   bfd_target_coff_flavour,
 799   BFD_ENDIAN_LITTLE,            /* data byte order is little */
 800   BFD_ENDIAN_LITTLE,            /* header byte order is little */
 801
 802   (HAS_RELOC | EXEC_P |         /* object flags */
 803    HAS_LINENO | HAS_DEBUG |
 804    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | BFD_COMPRESS | BFD_DECOMPRESS ),
 805
 806   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
 807 #ifdef COFF_WITH_PE
 808    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY | SEC_DEBUGGING
 809 #endif
 810    | SEC_CODE | SEC_DATA | SEC_EXCLUDE ),
 811
 812 #ifdef TARGET_UNDERSCORE
 813   TARGET_UNDERSCORE,            /* leading underscore */
 814 #else
 815   0,                            /* leading underscore */
 816 #endif
 817   '/',                          /* ar_pad_char */
 818   15,                           /* ar_max_namelen */
 819   0,                            /* match priority.  */
 820   TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
 821
 822   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 823      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 824      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 825   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 826      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 827      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
 828
 829 /* Note that we allow an object file to be treated as a core file as well.  */
 830
 831   {                             /* bfd_check_format */
 832     _bfd_dummy_target,
 833     COFF_CHECK_FORMAT,
 834     bfd_generic_archive_p,
 835     COFF_CHECK_FORMAT
 836   },
 837   {                             /* bfd_set_format */
 838     _bfd_bool_bfd_false_error,
 839     coff_mkobject,
 840     _bfd_generic_mkarchive,
 841     _bfd_bool_bfd_false_error
 842   },
 843   {                             /* bfd_write_contents */
 844     _bfd_bool_bfd_false_error,
 845     COFF_WRITE_CONTENTS,
 846     _bfd_write_archive_contents,
 847     _bfd_bool_bfd_false_error
 848   },
 849
 850   BFD_JUMP_TABLE_GENERIC (coff),
 851   BFD_JUMP_TABLE_COPY (coff),
 852   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 853   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 854   BFD_JUMP_TABLE_SYMBOLS (coff),
 855   BFD_JUMP_TABLE_RELOCS (coff),
 856   BFD_JUMP_TABLE_WRITE (coff),
 857   BFD_JUMP_TABLE_LINK (coff),
 858   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 859
 860   NULL,
 861
 862   &bigobj_swap_table
 863 };
 864 #endif