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