1 /* Morpho Technologies MT specific support for 32-bit ELF 2 Copyright (C) 2001-2015 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, Inc., 59 Temple Place - Suite 330, Boston, 19 MA 02111-1307, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "libbfd.h" 24 #include "elf-bfd.h" 25 #include "elf/mt.h" 26 27 /* Prototypes. */ 28 static reloc_howto_type * mt_reloc_type_lookup 29 (bfd *, bfd_reloc_code_real_type); 30 31 static void mt_info_to_howto_rela 32 (bfd *, arelent *, Elf_Internal_Rela *); 33 34 static bfd_reloc_status_type mt_elf_relocate_hi16 35 (bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma); 36 37 static bfd_reloc_status_type mt_final_link_relocate 38 (reloc_howto_type *, bfd *, asection *, bfd_byte *, 39 Elf_Internal_Rela *, bfd_vma); 40 41 static bfd_boolean mt_elf_relocate_section 42 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 43 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **); 44 45 /* Relocation tables. */ 46 static reloc_howto_type mt_elf_howto_table [] = 47 { 48 /* This reloc does nothing. */ 49 HOWTO (R_MT_NONE, /* type */ 50 0, /* rightshift */ 51 3, /* size (0 = byte, 1 = short, 2 = long) */ 52 0, /* bitsize */ 53 FALSE, /* pc_relative */ 54 0, /* bitpos */ 55 complain_overflow_dont, /* complain_on_overflow */ 56 bfd_elf_generic_reloc, /* special_function */ 57 "R_MT_NONE", /* name */ 58 FALSE, /* partial_inplace */ 59 0 , /* src_mask */ 60 0, /* dst_mask */ 61 FALSE), /* pcrel_offset */ 62 63 /* A 16 bit absolute relocation. */ 64 HOWTO (R_MT_16, /* type */ 65 0, /* rightshift */ 66 2, /* size (0 = byte, 1 = short, 2 = long) */ 67 16, /* bitsize */ 68 FALSE, /* pc_relative */ 69 0, /* bitpos */ 70 complain_overflow_dont, /* complain_on_overflow */ 71 bfd_elf_generic_reloc, /* special_function */ 72 "R_MT_16", /* name */ 73 FALSE, /* partial_inplace */ 74 0 , /* src_mask */ 75 0xffff, /* dst_mask */ 76 FALSE), /* pcrel_offset */ 77 78 /* A 32 bit absolute relocation. */ 79 HOWTO (R_MT_32, /* type */ 80 0, /* rightshift */ 81 2, /* size (0 = byte, 1 = short, 2 = long) */ 82 32, /* bitsize */ 83 FALSE, /* pc_relative */ 84 0, /* bitpos */ 85 complain_overflow_dont, /* complain_on_overflow */ 86 bfd_elf_generic_reloc, /* special_function */ 87 "R_MT_32", /* name */ 88 FALSE, /* partial_inplace */ 89 0 , /* src_mask */ 90 0xffffffff, /* dst_mask */ 91 FALSE), /* pcrel_offset */ 92 93 /* A 32 bit pc-relative relocation. */ 94 HOWTO (R_MT_32_PCREL, /* type */ 95 0, /* rightshift */ 96 2, /* size (0 = byte, 1 = short, 2 = long) */ 97 32, /* bitsize */ 98 TRUE, /* pc_relative */ 99 0, /* bitpos */ 100 complain_overflow_dont, /* complain_on_overflow */ 101 bfd_elf_generic_reloc, /* special_function */ 102 "R_MT_32_PCREL", /* name */ 103 FALSE, /* partial_inplace */ 104 0 , /* src_mask */ 105 0xffffffff, /* dst_mask */ 106 TRUE), /* pcrel_offset */ 107 108 /* A 16 bit pc-relative relocation. */ 109 HOWTO (R_MT_PC16, /* type */ 110 0, /* rightshift */ 111 2, /* size (0 = byte, 1 = short, 2 = long) */ 112 16, /* bitsize */ 113 TRUE, /* pc_relative */ 114 0, /* bitpos */ 115 complain_overflow_signed, /* complain_on_overflow */ 116 bfd_elf_generic_reloc, /* special_function */ 117 "R_MT_PC16", /* name */ 118 FALSE, /* partial_inplace */ 119 0, /* src_mask */ 120 0xffff, /* dst_mask */ 121 TRUE), /* pcrel_offset */ 122 123 /* high 16 bits of symbol value. */ 124 HOWTO (R_MT_HI16, /* type */ 125 0, /* rightshift */ 126 2, /* size (0 = byte, 1 = short, 2 = long) */ 127 16, /* bitsize */ 128 FALSE, /* pc_relative */ 129 0, /* bitpos */ 130 complain_overflow_dont, /* complain_on_overflow */ 131 bfd_elf_generic_reloc, /* special_function */ 132 "R_MT_HI16", /* name */ 133 FALSE, /* partial_inplace */ 134 0xffff0000, /* src_mask */ 135 0xffff0000, /* dst_mask */ 136 FALSE), /* pcrel_offset */ 137 138 /* Low 16 bits of symbol value. */ 139 HOWTO (R_MT_LO16, /* type */ 140 0, /* rightshift */ 141 2, /* size (0 = byte, 1 = short, 2 = long) */ 142 16, /* bitsize */ 143 FALSE, /* pc_relative */ 144 0, /* bitpos */ 145 complain_overflow_dont, /* complain_on_overflow */ 146 bfd_elf_generic_reloc, /* special_function */ 147 "R_MT_LO16", /* name */ 148 FALSE, /* partial_inplace */ 149 0xffff, /* src_mask */ 150 0xffff, /* dst_mask */ 151 FALSE), /* pcrel_offset */ 152 }; 153 154 /* Map BFD reloc types to MT ELF reloc types. */ 155 156 static reloc_howto_type * 157 mt_reloc_type_lookup 158 (bfd * abfd ATTRIBUTE_UNUSED, 159 bfd_reloc_code_real_type code) 160 { 161 /* Note that the mt_elf_howto_table is indxed by the R_ 162 constants. Thus, the order that the howto records appear in the 163 table *must* match the order of the relocation types defined in 164 include/elf/mt.h. */ 165 166 switch (code) 167 { 168 case BFD_RELOC_NONE: 169 return &mt_elf_howto_table[ (int) R_MT_NONE]; 170 case BFD_RELOC_16: 171 return &mt_elf_howto_table[ (int) R_MT_16]; 172 case BFD_RELOC_32: 173 return &mt_elf_howto_table[ (int) R_MT_32]; 174 case BFD_RELOC_32_PCREL: 175 return &mt_elf_howto_table[ (int) R_MT_32_PCREL]; 176 case BFD_RELOC_16_PCREL: 177 return &mt_elf_howto_table[ (int) R_MT_PC16]; 178 case BFD_RELOC_HI16: 179 return &mt_elf_howto_table[ (int) R_MT_HI16]; 180 case BFD_RELOC_LO16: 181 return &mt_elf_howto_table[ (int) R_MT_LO16]; 182 183 default: 184 /* Pacify gcc -Wall. */ 185 return NULL; 186 } 187 return NULL; 188 } 189 190 static reloc_howto_type * 191 mt_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 192 const char *r_name) 193 { 194 unsigned int i; 195 196 for (i = 0; 197 i < sizeof (mt_elf_howto_table) / sizeof (mt_elf_howto_table[0]); 198 i++) 199 if (mt_elf_howto_table[i].name != NULL 200 && strcasecmp (mt_elf_howto_table[i].name, r_name) == 0) 201 return &mt_elf_howto_table[i]; 202 203 return NULL; 204 } 205 206 bfd_reloc_status_type 207 mt_elf_relocate_hi16 208 (bfd * input_bfd, 209 Elf_Internal_Rela * relhi, 210 bfd_byte * contents, 211 bfd_vma value) 212 { 213 bfd_vma insn; 214 215 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); 216 217 value += relhi->r_addend; 218 value >>= 16; 219 insn = ((insn & ~0xFFFF) | value); 220 221 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); 222 return bfd_reloc_ok; 223 } 224 225 /* XXX: The following code is the result of a cut&paste. This unfortunate 226 practice is very widespread in the various target back-end files. */ 227 228 /* Set the howto pointer for a MT ELF reloc. */ 229 230 static void 231 mt_info_to_howto_rela 232 (bfd * abfd ATTRIBUTE_UNUSED, 233 arelent * cache_ptr, 234 Elf_Internal_Rela * dst) 235 { 236 unsigned int r_type; 237 238 r_type = ELF32_R_TYPE (dst->r_info); 239 if (r_type >= (unsigned int) R_MT_max) 240 { 241 _bfd_error_handler (_("%B: invalid MT reloc number: %d"), abfd, r_type); 242 r_type = 0; 243 } 244 cache_ptr->howto = & mt_elf_howto_table [r_type]; 245 } 246 247 /* Perform a single relocation. By default we use the standard BFD 248 routines. */ 249 250 static bfd_reloc_status_type 251 mt_final_link_relocate 252 (reloc_howto_type * howto, 253 bfd * input_bfd, 254 asection * input_section, 255 bfd_byte * contents, 256 Elf_Internal_Rela * rel, 257 bfd_vma relocation) 258 { 259 return _bfd_final_link_relocate (howto, input_bfd, input_section, 260 contents, rel->r_offset, 261 relocation, rel->r_addend); 262 } 263 264 /* Relocate a MT ELF section. 265 There is some attempt to make this function usable for many architectures, 266 both USE_REL and USE_RELA ['twould be nice if such a critter existed], 267 if only to serve as a learning tool. 268 269 The RELOCATE_SECTION function is called by the new ELF backend linker 270 to handle the relocations for a section. 271 272 The relocs are always passed as Rela structures; if the section 273 actually uses Rel structures, the r_addend field will always be 274 zero. 275 276 This function is responsible for adjusting the section contents as 277 necessary, and (if using Rela relocs and generating a relocatable 278 output file) adjusting the reloc addend as necessary. 279 280 This function does not have to worry about setting the reloc 281 address or the reloc symbol index. 282 283 LOCAL_SYMS is a pointer to the swapped in local symbols. 284 285 LOCAL_SECTIONS is an array giving the section in the input file 286 corresponding to the st_shndx field of each local symbol. 287 288 The global hash table entry for the global symbols can be found 289 via elf_sym_hashes (input_bfd). 290 291 When generating relocatable output, this function must handle 292 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 293 going to be the section symbol corresponding to the output 294 section, which means that the addend must be adjusted 295 accordingly. */ 296 297 static bfd_boolean 298 mt_elf_relocate_section 299 (bfd * output_bfd ATTRIBUTE_UNUSED, 300 struct bfd_link_info * info, 301 bfd * input_bfd, 302 asection * input_section, 303 bfd_byte * contents, 304 Elf_Internal_Rela * relocs, 305 Elf_Internal_Sym * local_syms, 306 asection ** local_sections) 307 { 308 Elf_Internal_Shdr * symtab_hdr; 309 struct elf_link_hash_entry ** sym_hashes; 310 Elf_Internal_Rela * rel; 311 Elf_Internal_Rela * relend; 312 313 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 314 sym_hashes = elf_sym_hashes (input_bfd); 315 relend = relocs + input_section->reloc_count; 316 317 for (rel = relocs; rel < relend; rel ++) 318 { 319 reloc_howto_type * howto; 320 unsigned long r_symndx; 321 Elf_Internal_Sym * sym; 322 asection * sec; 323 struct elf_link_hash_entry * h; 324 bfd_vma relocation; 325 bfd_reloc_status_type r; 326 const char * name = NULL; 327 int r_type; 328 329 r_type = ELF32_R_TYPE (rel->r_info); 330 331 r_symndx = ELF32_R_SYM (rel->r_info); 332 333 howto = mt_elf_howto_table + ELF32_R_TYPE (rel->r_info); 334 h = NULL; 335 sym = NULL; 336 sec = NULL; 337 338 if (r_symndx < symtab_hdr->sh_info) 339 { 340 sym = local_syms + r_symndx; 341 sec = local_sections [r_symndx]; 342 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 343 344 name = bfd_elf_string_from_elf_section 345 (input_bfd, symtab_hdr->sh_link, sym->st_name); 346 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; 347 } 348 else 349 { 350 bfd_boolean unresolved_reloc; 351 bfd_boolean warned, ignored; 352 353 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 354 r_symndx, symtab_hdr, sym_hashes, 355 h, sec, relocation, 356 unresolved_reloc, warned, ignored); 357 358 name = h->root.root.string; 359 } 360 361 if (sec != NULL && discarded_section (sec)) 362 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 363 rel, 1, relend, howto, 0, contents); 364 365 if (info->relocatable) 366 continue; 367 368 /* Finally, the sole MT-specific part. */ 369 switch (r_type) 370 { 371 case R_MT_HI16: 372 r = mt_elf_relocate_hi16 (input_bfd, rel, contents, relocation); 373 break; 374 default: 375 r = mt_final_link_relocate (howto, input_bfd, input_section, 376 contents, rel, relocation); 377 break; 378 } 379 380 381 if (r != bfd_reloc_ok) 382 { 383 const char * msg = (const char *) NULL; 384 385 switch (r) 386 { 387 case bfd_reloc_overflow: 388 r = info->callbacks->reloc_overflow 389 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0, 390 input_bfd, input_section, rel->r_offset); 391 break; 392 393 case bfd_reloc_undefined: 394 r = info->callbacks->undefined_symbol 395 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 396 break; 397 398 case bfd_reloc_outofrange: 399 msg = _("internal error: out of range error"); 400 break; 401 402 case bfd_reloc_dangerous: 403 msg = _("internal error: dangerous relocation"); 404 break; 405 406 default: 407 msg = _("internal error: unknown error"); 408 break; 409 } 410 411 if (msg) 412 r = info->callbacks->warning 413 (info, msg, name, input_bfd, input_section, rel->r_offset); 414 415 if (! r) 416 return FALSE; 417 } 418 } 419 420 return TRUE; 421 } 422 423 /* Look through the relocs for a section during the first phase. 424 Since we don't do .gots or .plts, we just need to consider the 425 virtual table relocs for gc. */ 426 427 static bfd_boolean 428 mt_elf_check_relocs 429 (bfd * abfd, 430 struct bfd_link_info * info, 431 asection * sec, 432 const Elf_Internal_Rela * relocs) 433 { 434 Elf_Internal_Shdr * symtab_hdr; 435 struct elf_link_hash_entry ** sym_hashes; 436 const Elf_Internal_Rela * rel; 437 const Elf_Internal_Rela * rel_end; 438 439 if (info->relocatable) 440 return TRUE; 441 442 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 443 sym_hashes = elf_sym_hashes (abfd); 444 445 rel_end = relocs + sec->reloc_count; 446 for (rel = relocs; rel < rel_end; rel++) 447 { 448 struct elf_link_hash_entry *h; 449 unsigned long r_symndx; 450 451 r_symndx = ELF32_R_SYM (rel->r_info); 452 if (r_symndx < symtab_hdr->sh_info) 453 h = NULL; 454 else 455 { 456 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 457 while (h->root.type == bfd_link_hash_indirect 458 || h->root.type == bfd_link_hash_warning) 459 h = (struct elf_link_hash_entry *) h->root.u.i.link; 460 461 /* PR15323, ref flags aren't set for references in the same 462 object. */ 463 h->root.non_ir_ref = 1; 464 } 465 } 466 467 return TRUE; 468 } 469 470 /* Return the MACH for an e_flags value. */ 471 472 static int 473 elf32_mt_machine (bfd *abfd) 474 { 475 switch (elf_elfheader (abfd)->e_flags & EF_MT_CPU_MASK) 476 { 477 case EF_MT_CPU_MRISC: return bfd_mach_ms1; 478 case EF_MT_CPU_MRISC2: return bfd_mach_mrisc2; 479 case EF_MT_CPU_MS2: return bfd_mach_ms2; 480 } 481 482 return bfd_mach_ms1; 483 } 484 485 static bfd_boolean 486 mt_elf_object_p (bfd * abfd) 487 { 488 bfd_default_set_arch_mach (abfd, bfd_arch_mt, elf32_mt_machine (abfd)); 489 490 return TRUE; 491 } 492 493 /* Function to set the ELF flag bits. */ 494 495 static bfd_boolean 496 mt_elf_set_private_flags (bfd * abfd, 497 flagword flags) 498 { 499 elf_elfheader (abfd)->e_flags = flags; 500 elf_flags_init (abfd) = TRUE; 501 return TRUE; 502 } 503 504 /* Merge backend specific data from an object file to the output 505 object file when linking. */ 506 507 static bfd_boolean 508 mt_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd) 509 { 510 flagword old_flags, new_flags; 511 bfd_boolean ok = TRUE; 512 513 /* Check if we have the same endianness. */ 514 if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE) 515 return FALSE; 516 517 /* If they're not both mt, then merging is meaningless, so just 518 don't do it. */ 519 if (strcmp (ibfd->arch_info->arch_name, "mt") != 0) 520 return TRUE; 521 if (strcmp (obfd->arch_info->arch_name, "mt") != 0) 522 return TRUE; 523 524 new_flags = elf_elfheader (ibfd)->e_flags; 525 old_flags = elf_elfheader (obfd)->e_flags; 526 527 #ifdef DEBUG 528 _bfd_error_handler ("%B: old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s", 529 ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no"); 530 #endif 531 532 if (!elf_flags_init (obfd)) 533 { 534 old_flags = new_flags; 535 elf_flags_init (obfd) = TRUE; 536 } 537 else if ((new_flags & EF_MT_CPU_MASK) != (old_flags & EF_MT_CPU_MASK)) 538 { 539 /* CPU has changed. This is invalid, because MRISC, MRISC2 and 540 MS2 are not subsets of each other. */ 541 ok = FALSE; 542 } 543 544 if (ok) 545 { 546 obfd->arch_info = ibfd->arch_info; 547 elf_elfheader (obfd)->e_flags = old_flags; 548 } 549 550 return ok; 551 } 552 553 static bfd_boolean 554 mt_elf_print_private_bfd_data (bfd * abfd, void * ptr) 555 { 556 FILE * file = (FILE *) ptr; 557 flagword flags; 558 559 BFD_ASSERT (abfd != NULL && ptr != NULL); 560 561 /* Print normal ELF private data. */ 562 _bfd_elf_print_private_bfd_data (abfd, ptr); 563 564 flags = elf_elfheader (abfd)->e_flags; 565 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags); 566 567 switch (flags & EF_MT_CPU_MASK) 568 { 569 default: 570 case EF_MT_CPU_MRISC: fprintf (file, " ms1-16-002"); break; 571 case EF_MT_CPU_MRISC2: fprintf (file, " ms1-16-003"); break; 572 case EF_MT_CPU_MS2: fprintf (file, " ms2"); break; 573 } 574 575 fputc ('\n', file); 576 577 return TRUE; 578 } 579 580 581 #define TARGET_BIG_SYM mt_elf32_vec 582 #define TARGET_BIG_NAME "elf32-mt" 583 584 #define ELF_ARCH bfd_arch_mt 585 #define ELF_MACHINE_CODE EM_MT 586 #define ELF_MAXPAGESIZE 1 /* No pages on the MT. */ 587 588 #define elf_info_to_howto_rel NULL 589 #define elf_info_to_howto mt_info_to_howto_rela 590 591 #define elf_backend_relocate_section mt_elf_relocate_section 592 593 #define bfd_elf32_bfd_reloc_type_lookup mt_reloc_type_lookup 594 #define bfd_elf32_bfd_reloc_name_lookup mt_reloc_name_lookup 595 596 #define elf_backend_check_relocs mt_elf_check_relocs 597 #define elf_backend_object_p mt_elf_object_p 598 #define elf_backend_rela_normal 1 599 600 #define elf_backend_can_gc_sections 1 601 602 #define bfd_elf32_bfd_set_private_flags mt_elf_set_private_flags 603 #define bfd_elf32_bfd_merge_private_bfd_data mt_elf_merge_private_bfd_data 604 #define bfd_elf32_bfd_print_private_bfd_data mt_elf_print_private_bfd_data 605 606 #include "elf32-target.h" 607