bfd/coff-m68k.c

   1 /* BFD back-end for Motorola 68000 COFF binaries.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999,
   3    2000, 2001, 2002, 2003, 2005, 2007, 2008
   4    Free Software Foundation, Inc.
   5    Written by Cygnus Support.
   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 3 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., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "libbfd.h"
  27 #include "coff/m68k.h"
  28 #include "coff/internal.h"
  29 #include "libcoff.h"
  30
  31 /* This source file is compiled multiple times for various m68k COFF
  32    variants.  The following macros control its behaviour:
  33
  34    TARGET_SYM
  35      The C name of the BFD target vector.  The default is m68kcoff_vec.
  36    TARGET_NAME
  37      The user visible target name.  The default is "coff-m68k".
  38    NAMES_HAVE_UNDERSCORE
  39      Whether symbol names have an underscore.
  40    ONLY_DECLARE_RELOCS
  41      Only declare the relocation howto array.  Don't actually compile
  42      it.  The actual array will be picked up in another version of the
  43      file.
  44    STATIC_RELOCS
  45      Make the relocation howto array, and associated functions, static.
  46    COFF_COMMON_ADDEND
  47      If this is defined, then, for a relocation against a common
  48      symbol, the object file holds the value (the size) of the common
  49      symbol.  If this is not defined, then, for a relocation against a
  50      common symbol, the object file holds zero.  */
  51
  52 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
  53
  54 #ifndef COFF_PAGE_SIZE
  55 /* The page size is a guess based on ELF.  */
  56 #define COFF_PAGE_SIZE 0x2000
  57 #endif
  58
  59 #ifndef COFF_COMMON_ADDEND
  60 #define RELOC_SPECIAL_FN 0
  61 #else
  62 static bfd_reloc_status_type m68kcoff_common_addend_special_fn
  63   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  64 static reloc_howto_type *m68kcoff_common_addend_rtype_to_howto
  65   PARAMS ((bfd *, asection *, struct internal_reloc *,
  66            struct coff_link_hash_entry *, struct internal_syment *,
  67            bfd_vma *));
  68 #define RELOC_SPECIAL_FN m68kcoff_common_addend_special_fn
  69 #endif
  70
  71 static bfd_boolean m68k_coff_is_local_label_name
  72   PARAMS ((bfd *, const char *));
  73
  74 /* On the delta, a symbol starting with L% is local.  We won't see
  75    such a symbol on other platforms, so it should be safe to always
  76    consider it local here.  */
  77
  78 static bfd_boolean
  79 m68k_coff_is_local_label_name (abfd, name)
  80      bfd *abfd;
  81      const char *name;
  82 {
  83   if (name[0] == 'L' && name[1] == '%')
  84     return TRUE;
  85
  86   return _bfd_coff_is_local_label_name (abfd, name);
  87 }
  88
  89 #ifndef STATIC_RELOCS
  90 /* Clean up namespace.  */
  91 #define m68kcoff_howto_table    _bfd_m68kcoff_howto_table
  92 #define m68k_rtype2howto        _bfd_m68kcoff_rtype2howto
  93 #define m68k_howto2rtype        _bfd_m68kcoff_howto2rtype
  94 #define m68k_reloc_type_lookup  _bfd_m68kcoff_reloc_type_lookup
  95 #define m68k_reloc_name_lookup _bfd_m68kcoff_reloc_name_lookup
  96 #endif
  97
  98 #ifdef ONLY_DECLARE_RELOCS
  99 extern reloc_howto_type m68kcoff_howto_table[];
 100 #else
 101 #ifdef STATIC_RELOCS
 102 static
 103 #endif
 104 reloc_howto_type m68kcoff_howto_table[] =
 105   {
 106     HOWTO (R_RELBYTE,          0,  0,   8,  FALSE, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "8",        TRUE, 0x000000ff,0x000000ff, FALSE),
 107     HOWTO (R_RELWORD,          0,  1,   16, FALSE, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "16",       TRUE, 0x0000ffff,0x0000ffff, FALSE),
 108     HOWTO (R_RELLONG,          0,  2,   32, FALSE, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "32",       TRUE, 0xffffffff,0xffffffff, FALSE),
 109     HOWTO (R_PCRBYTE,          0,  0,   8,  TRUE,  0, complain_overflow_signed,   RELOC_SPECIAL_FN, "DISP8",    TRUE, 0x000000ff,0x000000ff, FALSE),
 110     HOWTO (R_PCRWORD,          0,  1,   16, TRUE,  0, complain_overflow_signed,   RELOC_SPECIAL_FN, "DISP16",   TRUE, 0x0000ffff,0x0000ffff, FALSE),
 111     HOWTO (R_PCRLONG,          0,  2,   32, TRUE,  0, complain_overflow_signed,   RELOC_SPECIAL_FN, "DISP32",   TRUE, 0xffffffff,0xffffffff, FALSE),
 112     HOWTO (R_RELLONG_NEG,      0, -2,   32, FALSE, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "-32",      TRUE, 0xffffffff,0xffffffff, FALSE),
 113   };
 114 #endif /* not ONLY_DECLARE_RELOCS */
 115
 116 #ifndef BADMAG
 117 #define BADMAG(x) M68KBADMAG(x)
 118 #endif
 119 #define M68 1           /* Customize coffcode.h */
 120
 121 /* Turn a howto into a reloc number */
 122
 123 #ifdef ONLY_DECLARE_RELOCS
 124 extern void m68k_rtype2howto PARAMS ((arelent *internal, int relocentry));
 125 extern int m68k_howto2rtype PARAMS ((reloc_howto_type *));
 126 extern reloc_howto_type *m68k_reloc_type_lookup
 127   PARAMS ((bfd *, bfd_reloc_code_real_type));
 128 extern reloc_howto_type *m68k_reloc_name_lookup
 129   PARAMS ((bfd *, const char *));
 130 #else
 131
 132 #ifdef STATIC_RELOCS
 133 #define STAT_REL static
 134 #else
 135 #define STAT_REL
 136 #endif
 137
 138 STAT_REL reloc_howto_type * m68k_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type));
 139 STAT_REL reloc_howto_type * m68k_reloc_name_lookup PARAMS ((bfd *, const char *));
 140 STAT_REL int m68k_howto2rtype PARAMS ((reloc_howto_type *));
 141 STAT_REL void m68k_rtype2howto PARAMS ((arelent *, int));
 142
 143
 144 STAT_REL void
 145 m68k_rtype2howto(internal, relocentry)
 146      arelent *internal;
 147      int relocentry;
 148 {
 149   switch (relocentry)
 150     {
 151     case R_RELBYTE:     internal->howto = m68kcoff_howto_table + 0; break;
 152     case R_RELWORD:     internal->howto = m68kcoff_howto_table + 1; break;
 153     case R_RELLONG:     internal->howto = m68kcoff_howto_table + 2; break;
 154     case R_PCRBYTE:     internal->howto = m68kcoff_howto_table + 3; break;
 155     case R_PCRWORD:     internal->howto = m68kcoff_howto_table + 4; break;
 156     case R_PCRLONG:     internal->howto = m68kcoff_howto_table + 5; break;
 157     case R_RELLONG_NEG: internal->howto = m68kcoff_howto_table + 6; break;
 158     }
 159 }
 160
 161 STAT_REL int
 162 m68k_howto2rtype (internal)
 163      reloc_howto_type *internal;
 164 {
 165   if (internal->pc_relative)
 166     {
 167       switch (internal->bitsize)
 168         {
 169         case 32: return R_PCRLONG;
 170         case 16: return R_PCRWORD;
 171         case 8: return R_PCRBYTE;
 172         }
 173     }
 174   else
 175     {
 176       switch (internal->bitsize)
 177         {
 178         case 32: return R_RELLONG;
 179         case 16: return R_RELWORD;
 180         case 8: return R_RELBYTE;
 181         }
 182     }
 183   return R_RELLONG;
 184 }
 185
 186 STAT_REL reloc_howto_type *
 187 m68k_reloc_type_lookup (abfd, code)
 188      bfd *abfd ATTRIBUTE_UNUSED;
 189      bfd_reloc_code_real_type code;
 190 {
 191   switch (code)
 192     {
 193     default:                    return NULL;
 194     case BFD_RELOC_8:           return m68kcoff_howto_table + 0;
 195     case BFD_RELOC_16:          return m68kcoff_howto_table + 1;
 196     case BFD_RELOC_CTOR:
 197     case BFD_RELOC_32:          return m68kcoff_howto_table + 2;
 198     case BFD_RELOC_8_PCREL:     return m68kcoff_howto_table + 3;
 199     case BFD_RELOC_16_PCREL:    return m68kcoff_howto_table + 4;
 200     case BFD_RELOC_32_PCREL:    return m68kcoff_howto_table + 5;
 201       /* FIXME: There doesn't seem to be a code for R_RELLONG_NEG.  */
 202     }
 203   /*NOTREACHED*/
 204 }
 205
 206 STAT_REL reloc_howto_type *
 207 m68k_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 208                         const char *r_name)
 209 {
 210   unsigned int i;
 211
 212   for (i = 0;
 213        i < sizeof (m68kcoff_howto_table) / sizeof (m68kcoff_howto_table[0]);
 214        i++)
 215     if (m68kcoff_howto_table[i].name != NULL
 216         && strcasecmp (m68kcoff_howto_table[i].name, r_name) == 0)
 217       return &m68kcoff_howto_table[i];
 218
 219   return NULL;
 220 }
 221
 222 #endif /* not ONLY_DECLARE_RELOCS */
 223
 224 #define RTYPE2HOWTO(internal, relocentry) \
 225   m68k_rtype2howto(internal, (relocentry)->r_type)
 226
 227 #define SELECT_RELOC(external, internal) \
 228   external.r_type = m68k_howto2rtype (internal)
 229
 230 #define coff_bfd_reloc_type_lookup m68k_reloc_type_lookup
 231 #define coff_bfd_reloc_name_lookup m68k_reloc_name_lookup
 232
 233 #ifndef COFF_COMMON_ADDEND
 234 #ifndef coff_rtype_to_howto
 235
 236 #define coff_rtype_to_howto m68kcoff_rtype_to_howto
 237
 238 static reloc_howto_type *m68kcoff_rtype_to_howto
 239   PARAMS ((bfd *, asection *, struct internal_reloc *,
 240            struct coff_link_hash_entry *, struct internal_syment *,
 241            bfd_vma *));
 242
 243 static reloc_howto_type *
 244 m68kcoff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
 245      bfd *abfd ATTRIBUTE_UNUSED;
 246      asection *sec;
 247      struct internal_reloc *rel;
 248      struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
 249      struct internal_syment *sym ATTRIBUTE_UNUSED;
 250      bfd_vma *addendp;
 251 {
 252   arelent relent;
 253   reloc_howto_type *howto;
 254
 255   relent.howto = NULL;
 256   RTYPE2HOWTO (&relent, rel);
 257
 258   howto = relent.howto;
 259
 260   if (howto != NULL && howto->pc_relative)
 261     *addendp += sec->vma;
 262
 263   return howto;
 264 }
 265
 266 #endif /* ! defined (coff_rtype_to_howto) */
 267 #endif /* ! defined (COFF_COMMON_ADDEND) */
 268 \f
 269 #ifdef COFF_COMMON_ADDEND
 270
 271 /* If COFF_COMMON_ADDEND is defined, then when using m68k COFF the
 272    value stored in the .text section for a reference to a common
 273    symbol is the value itself plus any desired offset.  (taken from
 274    work done by Ian Taylor, Cygnus Support, for I386 COFF).  */
 275
 276 /* If we are producing relocatable output, we need to do some
 277    adjustments to the object file that are not done by the
 278    bfd_perform_relocation function.  This function is called by every
 279    reloc type to make any required adjustments.  */
 280
 281 static bfd_reloc_status_type
 282 m68kcoff_common_addend_special_fn (abfd, reloc_entry, symbol, data,
 283                                    input_section, output_bfd, error_message)
 284      bfd *abfd;
 285      arelent *reloc_entry;
 286      asymbol *symbol;
 287      PTR data;
 288      asection *input_section ATTRIBUTE_UNUSED;
 289      bfd *output_bfd;
 290      char **error_message ATTRIBUTE_UNUSED;
 291 {
 292   symvalue diff;
 293
 294   if (output_bfd == (bfd *) NULL)
 295     return bfd_reloc_continue;
 296
 297   if (bfd_is_com_section (symbol->section))
 298     {
 299       /* We are relocating a common symbol.  The current value in the
 300          object file is ORIG + OFFSET, where ORIG is the value of the
 301          common symbol as seen by the object file when it was compiled
 302          (this may be zero if the symbol was undefined) and OFFSET is
 303          the offset into the common symbol (normally zero, but may be
 304          non-zero when referring to a field in a common structure).
 305          ORIG is the negative of reloc_entry->addend, which is set by
 306          the CALC_ADDEND macro below.  We want to replace the value in
 307          the object file with NEW + OFFSET, where NEW is the value of
 308          the common symbol which we are going to put in the final
 309          object file.  NEW is symbol->value.  */
 310       diff = symbol->value + reloc_entry->addend;
 311     }
 312   else
 313     {
 314       /* For some reason bfd_perform_relocation always effectively
 315          ignores the addend for a COFF target when producing
 316          relocatable output.  This seems to be always wrong for 386
 317          COFF, so we handle the addend here instead.  */
 318       diff = reloc_entry->addend;
 319     }
 320
 321 #define DOIT(x) \
 322   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
 323
 324   if (diff != 0)
 325     {
 326       reloc_howto_type *howto = reloc_entry->howto;
 327       unsigned char *addr = (unsigned char *) data + reloc_entry->address;
 328
 329       switch (howto->size)
 330         {
 331         case 0:
 332           {
 333             char x = bfd_get_8 (abfd, addr);
 334             DOIT (x);
 335             bfd_put_8 (abfd, x, addr);
 336           }
 337           break;
 338
 339         case 1:
 340           {
 341             short x = bfd_get_16 (abfd, addr);
 342             DOIT (x);
 343             bfd_put_16 (abfd, (bfd_vma) x, addr);
 344           }
 345           break;
 346
 347         case 2:
 348           {
 349             long x = bfd_get_32 (abfd, addr);
 350             DOIT (x);
 351             bfd_put_32 (abfd, (bfd_vma) x, addr);
 352           }
 353           break;
 354
 355         default:
 356           abort ();
 357         }
 358     }
 359
 360   /* Now let bfd_perform_relocation finish everything up.  */
 361   return bfd_reloc_continue;
 362 }
 363
 364 /* Compute the addend of a reloc.  If the reloc is to a common symbol,
 365    the object file contains the value of the common symbol.  By the
 366    time this is called, the linker may be using a different symbol
 367    from a different object file with a different value.  Therefore, we
 368    hack wildly to locate the original symbol from this file so that we
 369    can make the correct adjustment.  This macro sets coffsym to the
 370    symbol from the original file, and uses it to set the addend value
 371    correctly.  If this is not a common symbol, the usual addend
 372    calculation is done, except that an additional tweak is needed for
 373    PC relative relocs.
 374    FIXME: This macro refers to symbols and asect; these are from the
 375    calling function, not the macro arguments.  */
 376
 377 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
 378   {                                                             \
 379     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
 380     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
 381       coffsym = (obj_symbols (abfd)                             \
 382                  + (cache_ptr->sym_ptr_ptr - symbols));         \
 383     else if (ptr)                                               \
 384       coffsym = coff_symbol_from (abfd, ptr);                   \
 385     if (coffsym != (coff_symbol_type *) NULL                    \
 386         && coffsym->native->u.syment.n_scnum == 0)              \
 387       cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
 388     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
 389              && ptr->section != (asection *) NULL)              \
 390       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
 391     else                                                        \
 392       cache_ptr->addend = 0;                                    \
 393     if (ptr && (reloc.r_type == R_PCRBYTE                       \
 394                 || reloc.r_type == R_PCRWORD                    \
 395                 || reloc.r_type == R_PCRLONG))                  \
 396       cache_ptr->addend += asect->vma;                          \
 397   }
 398
 399 #ifndef coff_rtype_to_howto
 400
 401 /* coff-m68k.c uses the special COFF backend linker.  We need to
 402    adjust common symbols.  */
 403
 404 static reloc_howto_type *
 405 m68kcoff_common_addend_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
 406      bfd *abfd ATTRIBUTE_UNUSED;
 407      asection *sec;
 408      struct internal_reloc *rel;
 409      struct coff_link_hash_entry *h;
 410      struct internal_syment *sym;
 411      bfd_vma *addendp;
 412 {
 413   arelent relent;
 414   reloc_howto_type *howto;
 415
 416   relent.howto = NULL;
 417   RTYPE2HOWTO (&relent, rel);
 418
 419   howto = relent.howto;
 420
 421   if (howto->pc_relative)
 422     *addendp += sec->vma;
 423
 424   if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
 425     {
 426       /* This is a common symbol.  The section contents include the
 427          size (sym->n_value) as an addend.  The relocate_section
 428          function will be adding in the final value of the symbol.  We
 429          need to subtract out the current size in order to get the
 430          correct result.  */
 431       BFD_ASSERT (h != NULL);
 432       *addendp -= sym->n_value;
 433     }
 434
 435   /* If the output symbol is common (in which case this must be a
 436      relocatable link), we need to add in the final size of the
 437      common symbol.  */
 438   if (h != NULL && h->root.type == bfd_link_hash_common)
 439     *addendp += h->root.u.c.size;
 440
 441   return howto;
 442 }
 443
 444 #define coff_rtype_to_howto m68kcoff_common_addend_rtype_to_howto
 445
 446 #endif /* ! defined (coff_rtype_to_howto) */
 447
 448 #endif /* COFF_COMMON_ADDEND */
 449
 450 #if !defined ONLY_DECLARE_RELOCS && ! defined STATIC_RELOCS
 451 /* Given a .data section and a .emreloc in-memory section, store
 452    relocation information into the .emreloc section which can be
 453    used at runtime to relocate the section.  This is called by the
 454    linker when the --embedded-relocs switch is used.  This is called
 455    after the add_symbols entry point has been called for all the
 456    objects, and before the final_link entry point is called.  */
 457
 458 bfd_boolean
 459 bfd_m68k_coff_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
 460      bfd *abfd;
 461      struct bfd_link_info *info;
 462      asection *datasec;
 463      asection *relsec;
 464      char **errmsg;
 465 {
 466   char *extsyms;
 467   bfd_size_type symesz;
 468   struct internal_reloc *irel, *irelend;
 469   bfd_byte *p;
 470   bfd_size_type amt;
 471
 472   BFD_ASSERT (! info->relocatable);
 473
 474   *errmsg = NULL;
 475
 476   if (datasec->reloc_count == 0)
 477     return TRUE;
 478
 479   extsyms = obj_coff_external_syms (abfd);
 480   symesz = bfd_coff_symesz (abfd);
 481
 482   irel = _bfd_coff_read_internal_relocs (abfd, datasec, TRUE, NULL, FALSE,
 483                                          NULL);
 484   irelend = irel + datasec->reloc_count;
 485
 486   amt = (bfd_size_type) datasec->reloc_count * 12;
 487   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
 488   if (relsec->contents == NULL)
 489     return FALSE;
 490
 491   p = relsec->contents;
 492
 493   for (; irel < irelend; irel++, p += 12)
 494     {
 495       asection *targetsec;
 496
 497       /* We are going to write a four byte longword into the runtime
 498        reloc section.  The longword will be the address in the data
 499        section which must be relocated.  It is followed by the name
 500        of the target section NUL-padded or truncated to 8
 501        characters.  */
 502
 503       /* We can only relocate absolute longword relocs at run time.  */
 504       if (irel->r_type != R_RELLONG)
 505         {
 506           *errmsg = _("unsupported reloc type");
 507           bfd_set_error (bfd_error_bad_value);
 508           return FALSE;
 509         }
 510
 511       if (irel->r_symndx == -1)
 512         targetsec = bfd_abs_section_ptr;
 513       else
 514         {
 515           struct coff_link_hash_entry *h;
 516
 517           h = obj_coff_sym_hashes (abfd)[irel->r_symndx];
 518           if (h == NULL)
 519             {
 520               struct internal_syment isym;
 521
 522               bfd_coff_swap_sym_in (abfd, extsyms + symesz * irel->r_symndx,
 523                                     &isym);
 524               targetsec = coff_section_from_bfd_index (abfd, isym.n_scnum);
 525             }
 526           else if (h->root.type == bfd_link_hash_defined
 527                    || h->root.type == bfd_link_hash_defweak)
 528             targetsec = h->root.u.def.section;
 529           else
 530             targetsec = NULL;
 531         }
 532
 533       bfd_put_32 (abfd,
 534                   (irel->r_vaddr - datasec->vma + datasec->output_offset), p);
 535       memset (p + 4, 0, 8);
 536       if (targetsec != NULL)
 537         strncpy ((char *) p + 4, targetsec->output_section->name, 8);
 538     }
 539
 540   return TRUE;
 541 }
 542 #endif /* neither ONLY_DECLARE_RELOCS not STATIC_RELOCS  */
 543 \f
 544 #define coff_bfd_is_local_label_name m68k_coff_is_local_label_name
 545
 546 #define coff_relocate_section _bfd_coff_generic_relocate_section
 547
 548 #ifndef bfd_pe_print_pdata
 549 #define bfd_pe_print_pdata      NULL
 550 #endif
 551
 552 #include "coffcode.h"
 553
 554 #ifndef TARGET_SYM
 555 #define TARGET_SYM m68kcoff_vec
 556 #endif
 557
 558 #ifndef TARGET_NAME
 559 #define TARGET_NAME "coff-m68k"
 560 #endif
 561
 562 #ifdef NAMES_HAVE_UNDERSCORE
 563 CREATE_BIG_COFF_TARGET_VEC (TARGET_SYM, TARGET_NAME, D_PAGED, 0, '_', NULL, COFF_SWAP_TABLE)
 564 #else
 565 CREATE_BIG_COFF_TARGET_VEC (TARGET_SYM, TARGET_NAME, D_PAGED, 0, 0, NULL, COFF_SWAP_TABLE)
 566 #endif