bfd/coff-m68k.c

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