bfd/coff-i860.c

   1 /* BFD back-end for Intel 860 COFF files.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4    Created mostly by substituting "860" for "386" in coff-i386.c
   5    Harry Dolan <dolan@ssd.intel.com>, October 1995
   6
   7 This file is part of BFD, the Binary File Descriptor library.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libbfd.h"
  26
  27 #include "coff/i860.h"
  28
  29 #include "coff/internal.h"
  30
  31 #include "libcoff.h"
  32
  33 static bfd_reloc_status_type coff_i860_reloc
  34   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  35 static reloc_howto_type *coff_i860_rtype_to_howto
  36   PARAMS ((bfd *, asection *, struct internal_reloc *,
  37            struct coff_link_hash_entry *, struct internal_syment *,
  38            bfd_vma *));
  39 static const bfd_target * i3coff_object_p PARAMS ((bfd *));
  40
  41 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
  42 /* The page size is a guess based on ELF.  */
  43
  44 #define COFF_PAGE_SIZE 0x1000
  45
  46 /* For some reason when using i860 COFF the value stored in the .text
  47    section for a reference to a common symbol is the value itself plus
  48    any desired offset.  Ian Taylor, Cygnus Support.  */
  49
  50 /* If we are producing relocateable output, we need to do some
  51    adjustments to the object file that are not done by the
  52    bfd_perform_relocation function.  This function is called by every
  53    reloc type to make any required adjustments.  */
  54
  55 static bfd_reloc_status_type
  56 coff_i860_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
  57                  error_message)
  58      bfd *abfd;
  59      arelent *reloc_entry;
  60      asymbol *symbol;
  61      PTR data;
  62      asection *input_section ATTRIBUTE_UNUSED;
  63      bfd *output_bfd;
  64      char **error_message ATTRIBUTE_UNUSED;
  65 {
  66   symvalue diff;
  67
  68   if (output_bfd == (bfd *) NULL)
  69     return bfd_reloc_continue;
  70
  71   if (bfd_is_com_section (symbol->section))
  72     {
  73       /* We are relocating a common symbol.  The current value in the
  74          object file is ORIG + OFFSET, where ORIG is the value of the
  75          common symbol as seen by the object file when it was compiled
  76          (this may be zero if the symbol was undefined) and OFFSET is
  77          the offset into the common symbol (normally zero, but may be
  78          non-zero when referring to a field in a common structure).
  79          ORIG is the negative of reloc_entry->addend, which is set by
  80          the CALC_ADDEND macro below.  We want to replace the value in
  81          the object file with NEW + OFFSET, where NEW is the value of
  82          the common symbol which we are going to put in the final
  83          object file.  NEW is symbol->value.  */
  84       diff = symbol->value + reloc_entry->addend;
  85     }
  86   else
  87     {
  88       /* For some reason bfd_perform_relocation always effectively
  89          ignores the addend for a COFF target when producing
  90          relocateable output.  This seems to be always wrong for 860
  91          COFF, so we handle the addend here instead.  */
  92       diff = reloc_entry->addend;
  93     }
  94
  95 #define DOIT(x) \
  96   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
  97
  98     if (diff != 0)
  99       {
 100         reloc_howto_type *howto = reloc_entry->howto;
 101         unsigned char *addr = (unsigned char *) data + reloc_entry->address;
 102
 103         switch (howto->size)
 104           {
 105           case 0:
 106             {
 107               char x = bfd_get_8 (abfd, addr);
 108               DOIT (x);
 109               bfd_put_8 (abfd, x, addr);
 110             }
 111             break;
 112
 113           case 1:
 114             {
 115               short x = bfd_get_16 (abfd, addr);
 116               DOIT (x);
 117               bfd_put_16 (abfd, (bfd_vma) x, addr);
 118             }
 119             break;
 120
 121           case 2:
 122             {
 123               long x = bfd_get_32 (abfd, addr);
 124               DOIT (x);
 125               bfd_put_32 (abfd, (bfd_vma) x, addr);
 126             }
 127             break;
 128
 129           default:
 130             abort ();
 131           }
 132       }
 133
 134   /* Now let bfd_perform_relocation finish everything up.  */
 135   return bfd_reloc_continue;
 136 }
 137
 138 #ifndef PCRELOFFSET
 139 #define PCRELOFFSET FALSE
 140 #endif
 141
 142 static reloc_howto_type howto_table[] =
 143 {
 144   EMPTY_HOWTO (0),
 145   EMPTY_HOWTO (1),
 146   EMPTY_HOWTO (2),
 147   EMPTY_HOWTO (3),
 148   EMPTY_HOWTO (4),
 149   EMPTY_HOWTO (5),
 150   HOWTO (R_DIR32,               /* type */
 151          0,                     /* rightshift */
 152          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 153          32,                    /* bitsize */
 154          FALSE,                 /* pc_relative */
 155          0,                     /* bitpos */
 156          complain_overflow_bitfield, /* complain_on_overflow */
 157          coff_i860_reloc,       /* special_function */
 158          "dir32",               /* name */
 159          TRUE,                  /* partial_inplace */
 160          0xffffffff,            /* src_mask */
 161          0xffffffff,            /* dst_mask */
 162          TRUE),                /* pcrel_offset */
 163   /* {7}, */
 164   HOWTO (R_IMAGEBASE,            /* type */
 165          0,                     /* rightshift */
 166          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 167          32,                    /* bitsize */
 168          FALSE,                 /* pc_relative */
 169          0,                     /* bitpos */
 170          complain_overflow_bitfield, /* complain_on_overflow */
 171          coff_i860_reloc,       /* special_function */
 172          "rva32",                  /* name */
 173          TRUE,                  /* partial_inplace */
 174          0xffffffff,            /* src_mask */
 175          0xffffffff,            /* dst_mask */
 176          FALSE),                /* pcrel_offset */
 177   EMPTY_HOWTO (010),
 178   EMPTY_HOWTO (011),
 179   EMPTY_HOWTO (012),
 180   EMPTY_HOWTO (013),
 181   EMPTY_HOWTO (014),
 182   EMPTY_HOWTO (015),
 183   EMPTY_HOWTO (016),
 184   HOWTO (R_RELBYTE,             /* type */
 185          0,                     /* rightshift */
 186          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 187          8,                     /* bitsize */
 188          FALSE,                 /* pc_relative */
 189          0,                     /* bitpos */
 190          complain_overflow_bitfield, /* complain_on_overflow */
 191          coff_i860_reloc,       /* special_function */
 192          "8",                   /* name */
 193          TRUE,                  /* partial_inplace */
 194          0x000000ff,            /* src_mask */
 195          0x000000ff,            /* dst_mask */
 196          PCRELOFFSET),          /* pcrel_offset */
 197   HOWTO (R_RELWORD,             /* type */
 198          0,                     /* rightshift */
 199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 200          16,                    /* bitsize */
 201          FALSE,                 /* pc_relative */
 202          0,                     /* bitpos */
 203          complain_overflow_bitfield, /* complain_on_overflow */
 204          coff_i860_reloc,       /* special_function */
 205          "16",                  /* name */
 206          TRUE,                  /* partial_inplace */
 207          0x0000ffff,            /* src_mask */
 208          0x0000ffff,            /* dst_mask */
 209          PCRELOFFSET),          /* pcrel_offset */
 210   HOWTO (R_RELLONG,             /* type */
 211          0,                     /* rightshift */
 212          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 213          32,                    /* bitsize */
 214          FALSE,                 /* pc_relative */
 215          0,                     /* bitpos */
 216          complain_overflow_bitfield, /* complain_on_overflow */
 217          coff_i860_reloc,       /* special_function */
 218          "32",                  /* name */
 219          TRUE,                  /* partial_inplace */
 220          0xffffffff,            /* src_mask */
 221          0xffffffff,            /* dst_mask */
 222          PCRELOFFSET),          /* pcrel_offset */
 223   HOWTO (R_PCRBYTE,             /* type */
 224          0,                     /* rightshift */
 225          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 226          8,                     /* bitsize */
 227          TRUE,                  /* pc_relative */
 228          0,                     /* bitpos */
 229          complain_overflow_signed, /* complain_on_overflow */
 230          coff_i860_reloc,       /* special_function */
 231          "DISP8",               /* name */
 232          TRUE,                  /* partial_inplace */
 233          0x000000ff,            /* src_mask */
 234          0x000000ff,            /* dst_mask */
 235          PCRELOFFSET),          /* pcrel_offset */
 236   HOWTO (R_PCRWORD,             /* type */
 237          0,                     /* rightshift */
 238          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 239          16,                    /* bitsize */
 240          TRUE,                  /* pc_relative */
 241          0,                     /* bitpos */
 242          complain_overflow_signed, /* complain_on_overflow */
 243          coff_i860_reloc,       /* special_function */
 244          "DISP16",              /* name */
 245          TRUE,                  /* partial_inplace */
 246          0x0000ffff,            /* src_mask */
 247          0x0000ffff,            /* dst_mask */
 248          PCRELOFFSET),          /* pcrel_offset */
 249   HOWTO (R_PCRLONG,             /* type */
 250          0,                     /* rightshift */
 251          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 252          32,                    /* bitsize */
 253          TRUE,                  /* pc_relative */
 254          0,                     /* bitpos */
 255          complain_overflow_signed, /* complain_on_overflow */
 256          coff_i860_reloc,       /* special_function */
 257          "DISP32",              /* name */
 258          TRUE,                  /* partial_inplace */
 259          0xffffffff,            /* src_mask */
 260          0xffffffff,            /* dst_mask */
 261          PCRELOFFSET)           /* pcrel_offset */
 262 };
 263
 264 /* Turn a howto into a reloc  nunmber */
 265
 266 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
 267 #define BADMAG(x) I860BADMAG(x)
 268 #define I860 1                  /* Customize coffcode.h */
 269
 270 #define RTYPE2HOWTO(cache_ptr, dst) \
 271             (cache_ptr)->howto = howto_table + (dst)->r_type;
 272
 273 /* For 860 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
 274    library.  On some other COFF targets STYP_BSS is normally
 275    STYP_NOLOAD.  */
 276 #define BSS_NOLOAD_IS_SHARED_LIBRARY
 277
 278 /* Compute the addend of a reloc.  If the reloc is to a common symbol,
 279    the object file contains the value of the common symbol.  By the
 280    time this is called, the linker may be using a different symbol
 281    from a different object file with a different value.  Therefore, we
 282    hack wildly to locate the original symbol from this file so that we
 283    can make the correct adjustment.  This macro sets coffsym to the
 284    symbol from the original file, and uses it to set the addend value
 285    correctly.  If this is not a common symbol, the usual addend
 286    calculation is done, except that an additional tweak is needed for
 287    PC relative relocs.
 288    FIXME: This macro refers to symbols and asect; these are from the
 289    calling function, not the macro arguments.  */
 290
 291 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
 292   {                                                             \
 293     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
 294     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
 295       coffsym = (obj_symbols (abfd)                             \
 296                  + (cache_ptr->sym_ptr_ptr - symbols));         \
 297     else if (ptr)                                               \
 298       coffsym = coff_symbol_from (abfd, ptr);                   \
 299     if (coffsym != (coff_symbol_type *) NULL                    \
 300         && coffsym->native->u.syment.n_scnum == 0)              \
 301       cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
 302     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
 303              && ptr->section != (asection *) NULL)              \
 304       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
 305     else                                                        \
 306       cache_ptr->addend = 0;                                    \
 307     if (ptr && howto_table[reloc.r_type].pc_relative)           \
 308       cache_ptr->addend += asect->vma;                          \
 309   }
 310
 311 /* We use the special COFF backend linker.  */
 312 #define coff_relocate_section _bfd_coff_generic_relocate_section
 313
 314 static reloc_howto_type *
 315 coff_i860_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
 316      bfd *abfd ATTRIBUTE_UNUSED;
 317      asection *sec;
 318      struct internal_reloc *rel;
 319      struct coff_link_hash_entry *h;
 320      struct internal_syment *sym;
 321      bfd_vma *addendp;
 322 {
 323
 324   reloc_howto_type *howto;
 325
 326   howto = howto_table + rel->r_type;
 327
 328   if (howto->pc_relative)
 329     *addendp += sec->vma;
 330
 331   if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
 332     {
 333       /* This is a common symbol.  The section contents include the
 334          size (sym->n_value) as an addend.  The relocate_section
 335          function will be adding in the final value of the symbol.  We
 336          need to subtract out the current size in order to get the
 337          correct result.  */
 338
 339       BFD_ASSERT (h != NULL);
 340
 341       /* I think we *do* want to bypass this.  If we don't, I have seen some data
 342          parameters get the wrong relcation address.  If I link two versions
 343          with and without this section bypassed and then do a binary comparison,
 344          the addresses which are different can be looked up in the map.  The
 345          case in which this section has been bypassed has addresses which correspond
 346          to values I can find in the map.  */
 347       *addendp -= sym->n_value;
 348     }
 349
 350   /* If the output symbol is common (in which case this must be a
 351      relocateable link), we need to add in the final size of the
 352      common symbol.  */
 353   if (h != NULL && h->root.type == bfd_link_hash_common)
 354     *addendp += h->root.u.c.size;
 355
 356   return howto;
 357 }
 358
 359 #define coff_rtype_to_howto coff_i860_rtype_to_howto
 360
 361 #include "coffcode.h"
 362
 363 static const bfd_target *
 364 i3coff_object_p(a)
 365      bfd *a;
 366 {
 367   return coff_object_p (a);
 368 }
 369
 370 const bfd_target
 371 #ifdef TARGET_SYM
 372   TARGET_SYM =
 373 #else
 374   i860coff_vec =
 375 #endif
 376 {
 377 #ifdef TARGET_NAME
 378   TARGET_NAME,
 379 #else
 380   "coff-i860",                  /* name */
 381 #endif
 382   bfd_target_coff_flavour,
 383   BFD_ENDIAN_LITTLE,            /* data byte order is little */
 384   BFD_ENDIAN_LITTLE,            /* header byte order is little */
 385
 386   (HAS_RELOC | EXEC_P |         /* object flags */
 387    HAS_LINENO | HAS_DEBUG |
 388    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 389
 390   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 391   '_',                          /* leading underscore */
 392   '/',                          /* ar_pad_char */
 393   15,                           /* ar_max_namelen */
 394
 395   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 396      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 397      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 398   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 399      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 400      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
 401
 402 /* Note that we allow an object file to be treated as a core file as well.  */
 403     {_bfd_dummy_target, i3coff_object_p, /* bfd_check_format */
 404        bfd_generic_archive_p, i3coff_object_p},
 405     {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
 406        bfd_false},
 407     {bfd_false, coff_write_object_contents, /* bfd_write_contents */
 408        _bfd_write_archive_contents, bfd_false},
 409
 410      BFD_JUMP_TABLE_GENERIC (coff),
 411      BFD_JUMP_TABLE_COPY (coff),
 412      BFD_JUMP_TABLE_CORE (_bfd_nocore),
 413      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 414      BFD_JUMP_TABLE_SYMBOLS (coff),
 415      BFD_JUMP_TABLE_RELOCS (coff),
 416      BFD_JUMP_TABLE_WRITE (coff),
 417      BFD_JUMP_TABLE_LINK (coff),
 418      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 419
 420   NULL,
 421
 422   COFF_SWAP_TABLE
 423 };