1 /* BFD back-end for Motorola MCore COFF/PE 2 Copyright (C) 1999-2016 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, 51 Franklin Street - Fifth Floor, 19 Boston, MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "libbfd.h" 24 #include "coff/mcore.h" 25 #include "coff/internal.h" 26 #include "coff/pe.h" 27 #include "libcoff.h" 28 29 #ifdef BADMAG 30 #undef BADMAG 31 #endif 32 #define BADMAG(x) MCOREBADMAG(x) 33 34 #ifndef NUM_ELEM 35 #define NUM_ELEM(A) (sizeof (A) / sizeof (A)[0]) 36 #endif 37 38 /* This file is compiled more than once, but we only compile the 39 final_link routine once. */ 40 extern bfd_boolean mcore_bfd_coff_final_link 41 (bfd *, struct bfd_link_info *); 42 static bfd_reloc_status_type mcore_coff_unsupported_reloc 43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 44 45 46 /* The NT loader points the toc register to &toc + 32768, in order to 47 use the complete range of a 16-bit displacement. We have to adjust 48 for this when we fix up loads displaced off the toc reg. */ 49 #define TOC_LOAD_ADJUSTMENT (-32768) 50 #define TOC_SECTION_NAME ".private.toc" 51 52 /* The main body of code is in coffcode.h. */ 53 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2 54 55 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value 56 from smaller values. Start with zero, widen, *then* decrement. */ 57 #define MINUS_ONE (((bfd_vma)0) - 1) 58 59 static reloc_howto_type mcore_coff_howto_table[] = 60 { 61 /* Unused: */ 62 HOWTO (IMAGE_REL_MCORE_ABSOLUTE,/* type */ 63 0, /* rightshift */ 64 0, /* size (0 = byte, 1 = short, 2 = long) */ 65 0, /* bitsize */ 66 FALSE, /* pc_relative */ 67 0, /* bitpos */ 68 complain_overflow_dont, /* dont complain_on_overflow */ 69 NULL, /* special_function */ 70 "ABSOLUTE", /* name */ 71 FALSE, /* partial_inplace */ 72 0x00, /* src_mask */ 73 0x00, /* dst_mask */ 74 FALSE), /* pcrel_offset */ 75 76 HOWTO (IMAGE_REL_MCORE_ADDR32,/* type */ 77 0, /* rightshift */ 78 2, /* size (0 = byte, 1 = short, 2 = long) */ 79 32, /* bitsize */ 80 FALSE, /* pc_relative */ 81 0, /* bitpos */ 82 complain_overflow_bitfield, /* complain_on_overflow */ 83 NULL, /* special_function */ 84 "ADDR32", /* name */ 85 TRUE, /* partial_inplace */ 86 0xffffffff, /* src_mask */ 87 0xffffffff, /* dst_mask */ 88 FALSE), /* pcrel_offset */ 89 90 /* 8 bits + 2 zero bits; jmpi/jsri/lrw instructions. 91 Should not appear in object files. */ 92 HOWTO (IMAGE_REL_MCORE_PCREL_IMM8BY4, /* type */ 93 2, /* rightshift */ 94 1, /* size (0 = byte, 1 = short, 2 = long) */ 95 8, /* bitsize */ 96 TRUE, /* pc_relative */ 97 0, /* bitpos */ 98 complain_overflow_bitfield, /* complain_on_overflow */ 99 mcore_coff_unsupported_reloc, /* special_function */ 100 "IMM8BY4", /* name */ 101 FALSE, /* partial_inplace */ 102 0, /* src_mask */ 103 0, /* dst_mask */ 104 TRUE), /* pcrel_offset */ 105 106 /* bsr/bt/bf/br instructions; 11 bits + 1 zero bit 107 Span 2k instructions == 4k bytes. 108 Only useful pieces at the relocated address are the opcode (5 bits) */ 109 HOWTO (IMAGE_REL_MCORE_PCREL_IMM11BY2,/* type */ 110 1, /* rightshift */ 111 1, /* size (0 = byte, 1 = short, 2 = long) */ 112 11, /* bitsize */ 113 TRUE, /* pc_relative */ 114 0, /* bitpos */ 115 complain_overflow_signed, /* complain_on_overflow */ 116 NULL, /* special_function */ 117 "IMM11BY2", /* name */ 118 FALSE, /* partial_inplace */ 119 0x0, /* src_mask */ 120 0x7ff, /* dst_mask */ 121 TRUE), /* pcrel_offset */ 122 123 /* 4 bits + 1 zero bit; 'loopt' instruction only; unsupported. */ 124 HOWTO (IMAGE_REL_MCORE_PCREL_IMM4BY2, /* type */ 125 1, /* rightshift */ 126 1, /* size (0 = byte, 1 = short, 2 = long) */ 127 4, /* bitsize */ 128 TRUE, /* pc_relative */ 129 0, /* bitpos */ 130 complain_overflow_bitfield, /* complain_on_overflow */ 131 mcore_coff_unsupported_reloc, /* special_function */ 132 "IMM4BY2", /* name */ 133 FALSE, /* partial_inplace */ 134 0, /* src_mask */ 135 0, /* dst_mask */ 136 TRUE), /* pcrel_offset */ 137 138 /* 32-bit pc-relative. Eventually this will help support PIC code. */ 139 HOWTO (IMAGE_REL_MCORE_PCREL_32,/* type */ 140 0, /* rightshift */ 141 2, /* size (0 = byte, 1 = short, 2 = long) */ 142 32, /* bitsize */ 143 TRUE, /* pc_relative */ 144 0, /* bitpos */ 145 complain_overflow_bitfield, /* complain_on_overflow */ 146 NULL, /* special_function */ 147 "PCREL_32", /* name */ 148 FALSE, /* partial_inplace */ 149 0x0, /* src_mask */ 150 0xffffffff, /* dst_mask */ 151 TRUE), /* pcrel_offset */ 152 153 /* Like PCREL_IMM11BY2, this relocation indicates that there is a 154 'jsri' at the specified address. There is a separate relocation 155 entry for the literal pool entry that it references, but we 156 might be able to change the jsri to a bsr if the target turns out 157 to be close enough [even though we won't reclaim the literal pool 158 entry, we'll get some runtime efficiency back]. Note that this 159 is a relocation that we are allowed to safely ignore. */ 160 HOWTO (IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2,/* type */ 161 1, /* rightshift */ 162 1, /* size (0 = byte, 1 = short, 2 = long) */ 163 11, /* bitsize */ 164 TRUE, /* pc_relative */ 165 0, /* bitpos */ 166 complain_overflow_signed, /* complain_on_overflow */ 167 NULL, /* special_function */ 168 "JSR_IMM11BY2", /* name */ 169 FALSE, /* partial_inplace */ 170 0x0, /* src_mask */ 171 0x7ff, /* dst_mask */ 172 TRUE), /* pcrel_offset */ 173 174 HOWTO (IMAGE_REL_MCORE_RVA, /* type */ 175 0, /* rightshift */ 176 2, /* size (0 = byte, 1 = short, 2 = long) */ 177 32, /* bitsize */ 178 FALSE, /* pc_relative */ 179 0, /* bitpos */ 180 complain_overflow_signed, /* complain_on_overflow */ 181 NULL, /* special_function */ 182 "MCORE_RVA", /* name */ 183 TRUE, /* partial_inplace */ 184 0xffffffff, /* src_mask */ 185 0xffffffff, /* dst_mask */ 186 TRUE) /* pcrel_offset */ 187 }; 188 189 /* Extend the coff_link_hash_table structure with a few M*Core specific fields. 190 This allows us to store global data here without actually creating any 191 global variables, which is a no-no in the BFD world. */ 192 typedef struct coff_mcore_link_hash_table 193 { 194 /* The original coff_link_hash_table structure. MUST be first field. */ 195 struct coff_link_hash_table root; 196 197 bfd * bfd_of_toc_owner; 198 long int global_toc_size; 199 long int import_table_size; 200 long int first_thunk_address; 201 long int thunk_size; 202 } 203 mcore_hash_table; 204 205 /* Get the MCore coff linker hash table from a link_info structure. */ 206 #define coff_mcore_hash_table(info) \ 207 ((mcore_hash_table *) ((info)->hash)) 208 209 210 /* Add an entry to the base file. */ 211 212 static bfd_boolean 213 mcore_emit_base_file_entry (struct bfd_link_info *info, 214 bfd *output_bfd, 215 asection *input_section, 216 bfd_vma reloc_offset) 217 { 218 bfd_vma addr = reloc_offset 219 - input_section->vma 220 + input_section->output_offset 221 + input_section->output_section->vma; 222 223 if (coff_data (output_bfd)->pe) 224 addr -= pe_data (output_bfd)->pe_opthdr.ImageBase; 225 226 if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1) 227 return TRUE; 228 229 bfd_set_error (bfd_error_system_call); 230 return FALSE; 231 } 232 233 static bfd_reloc_status_type 234 mcore_coff_unsupported_reloc (bfd * abfd, 235 arelent * reloc_entry, 236 asymbol * symbol ATTRIBUTE_UNUSED, 237 void * data ATTRIBUTE_UNUSED, 238 asection * input_section ATTRIBUTE_UNUSED, 239 bfd * output_bfd ATTRIBUTE_UNUSED, 240 char ** error_message ATTRIBUTE_UNUSED) 241 { 242 BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0); 243 244 _bfd_error_handler (_("%B: Relocation %s (%d) is not currently supported.\n"), 245 abfd, 246 reloc_entry->howto->name, 247 reloc_entry->howto->type); 248 249 return bfd_reloc_notsupported; 250 } 251 252 /* A cheesy little macro to make the code a little more readable. */ 253 #define HOW2MAP(bfd_rtype, mcore_rtype) \ 254 case bfd_rtype: return & mcore_coff_howto_table [mcore_rtype] 255 256 static reloc_howto_type * 257 mcore_coff_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 258 bfd_reloc_code_real_type code) 259 { 260 switch (code) 261 { 262 HOW2MAP (BFD_RELOC_32, IMAGE_REL_MCORE_ADDR32); 263 HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM8BY4, IMAGE_REL_MCORE_PCREL_IMM8BY4); 264 HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM11BY2, IMAGE_REL_MCORE_PCREL_IMM11BY2); 265 HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM4BY2, IMAGE_REL_MCORE_PCREL_IMM4BY2); 266 HOW2MAP (BFD_RELOC_32_PCREL, IMAGE_REL_MCORE_PCREL_32); 267 HOW2MAP (BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2, IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2); 268 HOW2MAP (BFD_RELOC_RVA, IMAGE_REL_MCORE_RVA); 269 default: 270 return NULL; 271 } 272 /*NOTREACHED*/ 273 } 274 #undef HOW2MAP 275 276 #define NUM_HOWTOS NUM_ELEM (mcore_coff_howto_table) 277 278 static reloc_howto_type * 279 mcore_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 280 const char *r_name) 281 { 282 unsigned int i; 283 284 for (i = 0; i < NUM_HOWTOS; i++) 285 if (mcore_coff_howto_table[i].name != NULL 286 && strcasecmp (mcore_coff_howto_table[i].name, r_name) == 0) 287 return &mcore_coff_howto_table[i]; 288 289 return NULL; 290 } 291 292 #define RTYPE2HOWTO(cache_ptr, dst) \ 293 ((cache_ptr)->howto = \ 294 ((dst)->r_type < NUM_HOWTOS \ 295 ? mcore_coff_howto_table + (dst)->r_type \ 296 : NULL)) 297 298 static reloc_howto_type * 299 coff_mcore_rtype_to_howto (bfd * abfd ATTRIBUTE_UNUSED, 300 asection * sec, 301 struct internal_reloc * rel, 302 struct coff_link_hash_entry * h ATTRIBUTE_UNUSED, 303 struct internal_syment * sym, 304 bfd_vma * addendp) 305 { 306 reloc_howto_type * howto; 307 308 if (rel->r_type >= NUM_HOWTOS) 309 return NULL; 310 311 howto = mcore_coff_howto_table + rel->r_type; 312 313 if (rel->r_type == IMAGE_REL_MCORE_RVA) 314 * addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase; 315 316 else if (howto->pc_relative) 317 { 318 * addendp = sec->vma - 2; /* XXX guess - is this right ? */ 319 320 /* If the symbol is defined, then the generic code is going to 321 add back the symbol value in order to cancel out an 322 adjustment it made to the addend. However, we set the addend 323 to 0 at the start of this function. We need to adjust here, 324 to avoid the adjustment the generic code will make. FIXME: 325 This is getting a bit hackish. */ 326 if (sym != NULL && sym->n_scnum != 0) 327 * addendp -= sym->n_value; 328 } 329 else 330 * addendp = 0; 331 332 return howto; 333 } 334 335 /* Return TRUE if this relocation should appear in the output .reloc section. 336 This function is referenced in pe_mkobject in peicode.h. */ 337 338 static bfd_boolean 339 in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED, reloc_howto_type * howto) 340 { 341 return ! howto->pc_relative && howto->type != IMAGE_REL_MCORE_RVA; 342 } 343 344 /* The reloc processing routine for the optimized COFF linker. */ 345 static bfd_boolean 346 coff_mcore_relocate_section (bfd * output_bfd, 347 struct bfd_link_info * info, 348 bfd * input_bfd, 349 asection * input_section, 350 bfd_byte * contents, 351 struct internal_reloc * relocs, 352 struct internal_syment * syms, 353 asection ** sections) 354 { 355 struct internal_reloc * rel; 356 struct internal_reloc * relend; 357 358 /* If we are performing a relocatable link, we don't need to do a 359 thing. The caller will take care of adjusting the reloc 360 addresses and symbol indices. */ 361 if (bfd_link_relocatable (info)) 362 return TRUE; 363 364 /* Check if we have the same endianness */ 365 if ( input_bfd->xvec->byteorder != output_bfd->xvec->byteorder 366 && output_bfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN) 367 { 368 (*_bfd_error_handler) 369 (_("%B: compiled for a %s system and target is %s.\n"), 370 input_bfd, 371 bfd_big_endian (input_bfd) ? _("big endian") : _("little endian"), 372 bfd_big_endian (output_bfd) ? _("big endian") : _("little endian")); 373 374 bfd_set_error (bfd_error_wrong_format); 375 return FALSE; 376 } 377 378 rel = relocs; 379 relend = rel + input_section->reloc_count; 380 381 for (; rel < relend; rel++) 382 { 383 long symndx; 384 struct internal_syment * sym; 385 bfd_vma val; 386 bfd_vma addend; 387 bfd_reloc_status_type rstat; 388 bfd_byte * loc; 389 unsigned short r_type = rel->r_type; 390 reloc_howto_type * howto = NULL; 391 struct coff_link_hash_entry * h; 392 const char * my_name; 393 394 symndx = rel->r_symndx; 395 loc = contents + rel->r_vaddr - input_section->vma; 396 397 if (symndx == -1) 398 { 399 h = NULL; 400 sym = NULL; 401 } 402 else 403 { 404 h = obj_coff_sym_hashes (input_bfd)[symndx]; 405 sym = syms + symndx; 406 } 407 408 addend = 0; 409 410 /* Get the howto and initialise the addend. */ 411 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h, 412 sym, & addend); 413 if (howto == NULL) 414 return FALSE; 415 416 val = 0; 417 418 if (h == NULL) 419 { 420 if (symndx == -1) 421 my_name = "*ABS*"; 422 else 423 { 424 asection * sec = sections[symndx]; 425 426 val = (sym->n_value 427 + sec->output_section->vma 428 + sec->output_offset); 429 430 if (sym == NULL) 431 my_name = "*unknown*"; 432 else if ( sym->_n._n_n._n_zeroes == 0 433 && sym->_n._n_n._n_offset != 0) 434 my_name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset; 435 else 436 { 437 static char buf [SYMNMLEN + 1]; 438 439 strncpy (buf, sym->_n._n_name, SYMNMLEN); 440 buf[SYMNMLEN] = '\0'; 441 my_name = buf; 442 } 443 } 444 } 445 else 446 { 447 if ( h->root.type == bfd_link_hash_defined 448 || h->root.type == bfd_link_hash_defweak) 449 { 450 asection * sec = h->root.u.def.section; 451 452 val = (h->root.u.def.value 453 + sec->output_section->vma 454 + sec->output_offset); 455 } 456 else 457 (*info->callbacks->undefined_symbol) 458 (info, h->root.root.string, input_bfd, input_section, 459 rel->r_vaddr - input_section->vma, TRUE); 460 461 my_name = h->root.root.string; 462 } 463 464 rstat = bfd_reloc_ok; 465 466 /* Each case must do its own relocation, setting rstat appropriately. */ 467 switch (r_type) 468 { 469 default: 470 _bfd_error_handler (_("%B: unsupported relocation type 0x%02x"), 471 input_bfd, r_type); 472 bfd_set_error (bfd_error_bad_value); 473 return FALSE; 474 475 case IMAGE_REL_MCORE_ABSOLUTE: 476 _bfd_error_handler 477 (_("Warning: unsupported reloc %s <file %B, section %A>\n" 478 "sym %ld (%s), r_vaddr %ld (%lx)"), 479 input_bfd, input_section, howto->name, 480 rel->r_symndx, my_name, (long) rel->r_vaddr, 481 (unsigned long) rel->r_vaddr); 482 break; 483 484 case IMAGE_REL_MCORE_PCREL_IMM8BY4: 485 case IMAGE_REL_MCORE_PCREL_IMM11BY2: 486 case IMAGE_REL_MCORE_PCREL_IMM4BY2: 487 case IMAGE_REL_MCORE_PCREL_32: 488 case IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2: 489 case IMAGE_REL_MCORE_ADDR32: 490 /* XXX fixme - shouldn't this be like the code for the RVA reloc ? */ 491 rstat = _bfd_relocate_contents (howto, input_bfd, val, loc); 492 break; 493 494 case IMAGE_REL_MCORE_RVA: 495 rstat = _bfd_final_link_relocate 496 (howto, input_bfd, 497 input_section, contents, rel->r_vaddr - input_section->vma, 498 val, addend); 499 break; 500 } 501 502 /* Emit a reloc if the backend thinks it needs it. */ 503 if (info->base_file 504 && sym 505 && pe_data (output_bfd)->in_reloc_p (output_bfd, howto) 506 && !mcore_emit_base_file_entry (info, output_bfd, input_section, 507 rel->r_vaddr)) 508 return FALSE; 509 510 switch (rstat) 511 { 512 default: 513 abort (); 514 515 case bfd_reloc_ok: 516 break; 517 518 case bfd_reloc_overflow: 519 (*info->callbacks->reloc_overflow) 520 (info, (h ? &h->root : NULL), my_name, howto->name, 521 (bfd_vma) 0, input_bfd, 522 input_section, rel->r_vaddr - input_section->vma); 523 } 524 } 525 526 return TRUE; 527 } 528 529 /* Tailor coffcode.h -- macro heaven. */ 530 531 /* We use the special COFF backend linker, with our own special touch. */ 532 533 #define coff_bfd_reloc_type_lookup mcore_coff_reloc_type_lookup 534 #define coff_bfd_reloc_name_lookup mcore_coff_reloc_name_lookup 535 #define coff_relocate_section coff_mcore_relocate_section 536 #define coff_rtype_to_howto coff_mcore_rtype_to_howto 537 538 #define SELECT_RELOC(internal, howto) {internal.r_type = howto->type;} 539 540 /* Make sure that the 'r_offset' field is copied properly 541 so that identical binaries will compare the same. */ 542 #define SWAP_IN_RELOC_OFFSET H_GET_32 543 #define SWAP_OUT_RELOC_OFFSET H_PUT_32 544 545 #define COFF_PAGE_SIZE 0x1000 546 547 #include "coffcode.h" 548 549 /* Forward declaration to initialise alternative_target field. */ 550 extern const bfd_target TARGET_LITTLE_SYM; 551 552 /* The transfer vectors that lead the outside world to all of the above. */ 553 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED, 554 (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES), 555 0, & TARGET_LITTLE_SYM, COFF_SWAP_TABLE) 556 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED, 557 (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES), 558 0, & TARGET_BIG_SYM, COFF_SWAP_TABLE) 559