bfd/coff-i960.c

   1 /* BFD back-end for Intel 960 COFF files.
   2    Copyright (C) 1990, 91, 92, 93, 94, 1995 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #define I960 1
  22 #define BADMAG(x) I960BADMAG(x)
  23
  24 #include "bfd.h"
  25 #include "sysdep.h"
  26 #include "libbfd.h"
  27 #include "obstack.h"
  28 #include "coff/i960.h"
  29 #include "coff/internal.h"
  30 #include "libcoff.h"            /* to allow easier abstraction-breaking */
  31
  32 static bfd_reloc_status_type optcall_callback
  33   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  34 static bfd_reloc_status_type coff_i960_relocate
  35   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  36
  37 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
  38
  39 /* The i960 does not support an MMU, so COFF_PAGE_SIZE can be
  40    arbitrarily small.  */
  41 #define COFF_PAGE_SIZE 1
  42
  43 #define COFF_LONG_FILENAMES
  44
  45 #define CALLS    0x66003800     /* Template for 'calls' instruction     */
  46 #define BAL      0x0b000000     /* Template for 'bal' instruction       */
  47 #define BAL_MASK 0x00ffffff
  48
  49 static bfd_reloc_status_type
  50 optcall_callback (abfd, reloc_entry, symbol_in, data,
  51                   input_section, ignore_bfd, error_message)
  52      bfd *abfd;
  53      arelent *reloc_entry;
  54      asymbol *symbol_in;
  55      PTR data;
  56      asection *input_section;
  57      bfd *ignore_bfd;
  58      char **error_message;
  59 {
  60   /* This item has already been relocated correctly, but we may be
  61    * able to patch in yet better code - done by digging out the
  62    * correct info on this symbol */
  63   bfd_reloc_status_type result;
  64   coff_symbol_type *cs = coffsymbol(symbol_in);
  65
  66   /* Don't do anything with symbols which aren't tied up yet,
  67      except move the reloc. */
  68   if (bfd_is_und_section (cs->symbol.section)) {
  69     reloc_entry->address += input_section->output_offset;
  70     return bfd_reloc_ok;
  71   }
  72
  73   /* So the target symbol has to be of coff type, and the symbol
  74      has to have the correct native information within it */
  75   if ((bfd_asymbol_flavour(&cs->symbol) != bfd_target_coff_flavour)
  76       || (cs->native == (combined_entry_type *)NULL))
  77     {
  78       /* This is interesting, consider the case where we're outputting coff
  79          from a mix n match input, linking from coff to a symbol defined in a
  80          bout file will cause this match to be true. Should I complain?  This
  81          will only work if the bout symbol is non leaf.  */
  82       *error_message =
  83         (char *) "uncertain calling convention for non-COFF symbol";
  84       result = bfd_reloc_dangerous;
  85     }
  86   else
  87     {
  88     switch (cs->native->u.syment.n_sclass)
  89       {
  90       case C_LEAFSTAT:
  91       case C_LEAFEXT:
  92         /* This is a call to a leaf procedure, replace instruction with a bal
  93            to the correct location.  */
  94         {
  95           union internal_auxent *aux = &((cs->native+2)->u.auxent);
  96           int word = bfd_get_32(abfd, (bfd_byte *)data + reloc_entry->address);
  97           int olf = (aux->x_bal.x_balntry - cs->native->u.syment.n_value);
  98           BFD_ASSERT(cs->native->u.syment.n_numaux==2);
  99
 100           /* We replace the original call instruction with a bal to
 101              the bal entry point - the offset of which is described in
 102              the 2nd auxent of the original symbol. We keep the native
 103              sym and auxents untouched, so the delta between the two
 104              is the offset of the bal entry point.  */
 105           word = ((word +  olf)  & BAL_MASK) | BAL;
 106           bfd_put_32(abfd, word, (bfd_byte *) data + reloc_entry->address);
 107         }
 108         result = bfd_reloc_ok;
 109         break;
 110       case C_SCALL:
 111         /* This is a call to a system call, replace with a calls to # */
 112         BFD_ASSERT(0);
 113         result = bfd_reloc_ok;
 114         break;
 115       default:
 116         result = bfd_reloc_ok;
 117         break;
 118       }
 119   }
 120   return result;
 121 }
 122
 123 /* i960 COFF is used by VxWorks 5.1.  However, VxWorks 5.1 does not
 124    appear to correctly handle a reloc against a symbol defined in the
 125    same object file.  It appears to simply discard such relocs, rather
 126    than adding their values into the object file.  We handle this here
 127    by converting all relocs against defined symbols into relocs
 128    against the section symbol, when generating a relocateable output
 129    file.  */
 130
 131 static bfd_reloc_status_type
 132 coff_i960_relocate (abfd, reloc_entry, symbol, data, input_section,
 133                     output_bfd, error_message)
 134      bfd *abfd;
 135      arelent *reloc_entry;
 136      asymbol *symbol;
 137      PTR data;
 138      asection *input_section;
 139      bfd *output_bfd;
 140      char **error_message;
 141 {
 142   asection *osec;
 143
 144   if (output_bfd == NULL)
 145     {
 146       /* Not generating relocateable output file.  */
 147       return bfd_reloc_continue;
 148     }
 149
 150   if (bfd_is_und_section (bfd_get_section (symbol)))
 151     {
 152       /* Symbol is not defined, so no need to worry about it.  */
 153       return bfd_reloc_continue;
 154     }
 155
 156   if (bfd_is_com_section (bfd_get_section (symbol)))
 157     {
 158       /* I don't really know what the right action is for a common
 159          symbol.  */
 160       return bfd_reloc_continue;
 161     }
 162
 163   /* Convert the reloc to use the section symbol.  FIXME: This method
 164      is ridiculous.  Fortunately, we don't use the used_by_bfd field
 165      in COFF.  */
 166   osec = bfd_get_section (symbol)->output_section;
 167   if (osec->used_by_bfd != NULL)
 168     reloc_entry->sym_ptr_ptr = (asymbol **) osec->used_by_bfd;
 169   else
 170     {
 171       const char *sec_name;
 172       asymbol **syms, **sym_end;
 173
 174       sec_name = bfd_get_section_name (output_bfd, osec);
 175       syms = bfd_get_outsymbols (output_bfd);
 176       sym_end = syms + bfd_get_symcount (output_bfd);
 177       for (; syms < sym_end; syms++)
 178         {
 179           if (bfd_asymbol_name (*syms) != NULL
 180               && (*syms)->value == 0
 181               && strcmp (!(*syms)->section->output_section->name, sec_name))
 182             {
 183               osec->used_by_bfd = (PTR) syms;
 184               reloc_entry->sym_ptr_ptr = syms;
 185               break;
 186             }
 187         }
 188
 189       if (syms >= sym_end)
 190         abort ();
 191     }
 192
 193   /* Let bfd_perform_relocation do its thing, which will include
 194      stuffing the symbol addend into the object file.  */
 195   return bfd_reloc_continue;
 196 }
 197
 198 static reloc_howto_type howto_rellong =
 199   HOWTO ((unsigned int) R_RELLONG, 0, 2, 32,false, 0,
 200          complain_overflow_bitfield, coff_i960_relocate,"rellong", true,
 201          0xffffffff, 0xffffffff, 0);
 202 static reloc_howto_type howto_iprmed =
 203   HOWTO (R_IPRMED, 0, 2, 24,true,0, complain_overflow_signed,
 204          coff_i960_relocate, "iprmed ", true, 0x00ffffff, 0x00ffffff, 0);
 205 static reloc_howto_type howto_optcall =
 206   HOWTO (R_OPTCALL, 0,2,24,true,0, complain_overflow_signed,
 207          optcall_callback, "optcall", true, 0x00ffffff, 0x00ffffff, 0);
 208
 209 static reloc_howto_type *
 210 coff_i960_reloc_type_lookup (abfd, code)
 211      bfd *abfd;
 212      bfd_reloc_code_real_type code;
 213 {
 214   switch (code)
 215     {
 216     default:
 217       return 0;
 218     case BFD_RELOC_I960_CALLJ:
 219       return &howto_optcall;
 220     case BFD_RELOC_32:
 221     case BFD_RELOC_CTOR:
 222       return &howto_rellong;
 223     case BFD_RELOC_24_PCREL:
 224       return &howto_iprmed;
 225     }
 226 }
 227
 228 /* The real code is in coffcode.h */
 229
 230 #define RTYPE2HOWTO(cache_ptr, dst) \
 231 {                                                       \
 232    reloc_howto_type *howto_ptr;                         \
 233    switch ((dst)->r_type) {                             \
 234      case 17: howto_ptr = &howto_rellong; break;        \
 235      case 25: howto_ptr = &howto_iprmed; break;         \
 236      case 27: howto_ptr = &howto_optcall; break;        \
 237      default: howto_ptr = 0; break;                     \
 238      }                                                  \
 239    (cache_ptr)->howto = howto_ptr;                      \
 240  }
 241
 242 #include "coffcode.h"
 243
 244 #undef coff_bfd_reloc_type_lookup
 245 #define coff_bfd_reloc_type_lookup coff_i960_reloc_type_lookup
 246
 247 const bfd_target icoff_little_vec =
 248 {
 249   "coff-Intel-little",          /* name */
 250   bfd_target_coff_flavour,
 251   false,                        /* data byte order is little */
 252   false,                        /* header byte order is little */
 253
 254   (HAS_RELOC | EXEC_P |         /* object flags */
 255    HAS_LINENO | HAS_DEBUG |
 256    HAS_SYMS | HAS_LOCALS | WP_TEXT),
 257
 258   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 259   '_',                          /* leading underscore */
 260   '/',                          /* ar_pad_char */
 261   15,                           /* ar_max_namelen */
 262
 263   3,                            /* minimum alignment power */
 264   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 265      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 266      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 267   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 268      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 269      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
 270
 271  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
 272    bfd_generic_archive_p, _bfd_dummy_target},
 273  {bfd_false, coff_mkobject,     /* bfd_set_format */
 274    _bfd_generic_mkarchive, bfd_false},
 275  {bfd_false, coff_write_object_contents, /* bfd_write_contents */
 276    _bfd_write_archive_contents, bfd_false},
 277
 278      BFD_JUMP_TABLE_GENERIC (coff),
 279      BFD_JUMP_TABLE_COPY (coff),
 280      BFD_JUMP_TABLE_CORE (_bfd_nocore),
 281      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 282      BFD_JUMP_TABLE_SYMBOLS (coff),
 283      BFD_JUMP_TABLE_RELOCS (coff),
 284      BFD_JUMP_TABLE_WRITE (coff),
 285      BFD_JUMP_TABLE_LINK (coff),
 286      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 287
 288   COFF_SWAP_TABLE,
 289 };
 290
 291
 292 const bfd_target icoff_big_vec =
 293 {
 294   "coff-Intel-big",             /* name */
 295   bfd_target_coff_flavour,
 296   false,                        /* data byte order is little */
 297   true,                         /* header byte order is big */
 298
 299   (HAS_RELOC | EXEC_P |         /* object flags */
 300    HAS_LINENO | HAS_DEBUG |
 301    HAS_SYMS | HAS_LOCALS | WP_TEXT),
 302
 303   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 304   '_',                          /* leading underscore */
 305   '/',                          /* ar_pad_char */
 306   15,                           /* ar_max_namelen */
 307
 308   3,                            /* minimum alignment power */
 309 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 310      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 311      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 312 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 313      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 314      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
 315
 316   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
 317      bfd_generic_archive_p, _bfd_dummy_target},
 318   {bfd_false, coff_mkobject,    /* bfd_set_format */
 319      _bfd_generic_mkarchive, bfd_false},
 320   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
 321      _bfd_write_archive_contents, bfd_false},
 322
 323      BFD_JUMP_TABLE_GENERIC (coff),
 324      BFD_JUMP_TABLE_COPY (coff),
 325      BFD_JUMP_TABLE_CORE (_bfd_nocore),
 326      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 327      BFD_JUMP_TABLE_SYMBOLS (coff),
 328      BFD_JUMP_TABLE_RELOCS (coff),
 329      BFD_JUMP_TABLE_WRITE (coff),
 330      BFD_JUMP_TABLE_LINK (coff),
 331      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 332
 333   COFF_SWAP_TABLE,
 334 };