1 /* OpenRISC-specific support for 32-bit ELF. 2 Copyright 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 3 Contributed by Johan Rydberg, jrydberg@opencores.org 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 2 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, MA 02110-1301, 20 USA. */ 21 22 #include "bfd.h" 23 #include "sysdep.h" 24 #include "libbfd.h" 25 #include "elf-bfd.h" 26 #include "elf/openrisc.h" 27 #include "libiberty.h" 28 29 static reloc_howto_type openrisc_elf_howto_table[] = 30 { 31 /* This reloc does nothing. */ 32 HOWTO (R_OPENRISC_NONE, /* type */ 33 0, /* rightshift */ 34 2, /* size (0 = byte, 1 = short, 2 = long) */ 35 32, /* bitsize */ 36 FALSE, /* pc_relative */ 37 0, /* bitpos */ 38 complain_overflow_bitfield, /* complain_on_overflow */ 39 bfd_elf_generic_reloc, /* special_function */ 40 "R_OPENRISC_NONE", /* name */ 41 FALSE, /* partial_inplace */ 42 0, /* src_mask */ 43 0, /* dst_mask */ 44 FALSE), /* pcrel_offset */ 45 46 /* A PC relative 26 bit relocation, right shifted by 2. */ 47 HOWTO (R_OPENRISC_INSN_REL_26, /* type */ 48 2, /* rightshift */ 49 2, /* size (0 = byte, 1 = short, 2 = long) */ 50 26, /* bitsize */ 51 TRUE, /* pc_relative */ 52 0, /* bitpos */ 53 complain_overflow_signed, /* complain_on_overflow */ 54 bfd_elf_generic_reloc, /* special_function */ 55 "R_OPENRISC_INSN_REL_26", /* name */ 56 FALSE, /* partial_inplace */ 57 0x00000000, /* src_mask */ 58 0x03ffffff, /* dst_mask */ 59 FALSE), /* pcrel_offset */ 60 61 /* A absolute 26 bit relocation, right shifted by 2. */ 62 HOWTO (R_OPENRISC_INSN_ABS_26, /* type */ 63 2, /* rightshift */ 64 2, /* size (0 = byte, 1 = short, 2 = long) */ 65 26, /* bitsize */ 66 FALSE, /* pc_relative */ 67 0, /* bitpos */ 68 complain_overflow_signed, /* complain_on_overflow */ 69 bfd_elf_generic_reloc, /* special_function */ 70 "R_OPENRISC_INSN_ABS_26", /* name */ 71 FALSE, /* partial_inplace */ 72 0x00000000, /* src_mask */ 73 0x03ffffff, /* dst_mask */ 74 FALSE), /* pcrel_offset */ 75 76 HOWTO (R_OPENRISC_LO_16_IN_INSN, /* type */ 77 0, /* rightshift */ 78 1, /* size (0 = byte, 1 = short, 2 = long) */ 79 16, /* bitsize */ 80 FALSE, /* pc_relative */ 81 0, /* bitpos */ 82 complain_overflow_dont, /* complain_on_overflow */ 83 bfd_elf_generic_reloc, /* special_function */ 84 "R_OPENRISC_LO_16_IN_INSN", /* name */ 85 FALSE, /* partial_inplace */ 86 0, /* src_mask */ 87 0x0000ffff, /* dst_mask */ 88 FALSE), /* pcrel_offset */ 89 90 HOWTO (R_OPENRISC_HI_16_IN_INSN, /* type */ 91 16, /* rightshift */ 92 1, /* size (0 = byte, 1 = short, 2 = long) */ 93 16, /* bitsize */ 94 FALSE, /* pc_relative */ 95 0, /* bitpos */ 96 complain_overflow_dont, /* complain_on_overflow */ 97 bfd_elf_generic_reloc, /* special_function */ 98 "R_OPENRISC_HI_16_IN_INSN", /* name */ 99 FALSE, /* partial_inplace */ 100 0, /* src_mask */ 101 0x0000ffff, /* dst_mask */ 102 FALSE), /* pcrel_offset */ 103 104 /* An 8 bit absolute relocation. */ 105 HOWTO (R_OPENRISC_8, /* type */ 106 0, /* rightshift */ 107 0, /* size (0 = byte, 1 = short, 2 = long) */ 108 8, /* bitsize */ 109 FALSE, /* pc_relative */ 110 0, /* bitpos */ 111 complain_overflow_bitfield, /* complain_on_overflow */ 112 bfd_elf_generic_reloc, /* special_function */ 113 "R_OPENRISC_8", /* name */ 114 TRUE, /* partial_inplace */ 115 0x0000, /* src_mask */ 116 0x00ff, /* dst_mask */ 117 FALSE), /* pcrel_offset */ 118 119 /* A 16 bit absolute relocation. */ 120 HOWTO (R_OPENRISC_16, /* type */ 121 0, /* rightshift */ 122 1, /* size (0 = byte, 1 = short, 2 = long) */ 123 16, /* bitsize */ 124 FALSE, /* pc_relative */ 125 0, /* bitpos */ 126 complain_overflow_bitfield, /* complain_on_overflow */ 127 bfd_elf_generic_reloc, /* special_function */ 128 "R_OPENRISC_16", /* name */ 129 TRUE, /* partial_inplace */ 130 0x00000000, /* src_mask */ 131 0x0000ffff, /* dst_mask */ 132 FALSE), /* pcrel_offset */ 133 134 /* A 32 bit absolute relocation. */ 135 HOWTO (R_OPENRISC_32, /* type */ 136 0, /* rightshift */ 137 2, /* size (0 = byte, 1 = short, 2 = long) */ 138 32, /* bitsize */ 139 FALSE, /* pc_relative */ 140 0, /* bitpos */ 141 complain_overflow_bitfield, /* complain_on_overflow */ 142 bfd_elf_generic_reloc, /* special_function */ 143 "R_OPENRISC_32", /* name */ 144 TRUE, /* partial_inplace */ 145 0x00000000, /* src_mask */ 146 0xffffffff, /* dst_mask */ 147 FALSE), /* pcrel_offset */ 148 149 /* GNU extension to record C++ vtable hierarchy. */ 150 HOWTO (R_OPENRISC_GNU_VTINHERIT, /* type */ 151 0, /* rightshift */ 152 2, /* size (0 = byte, 1 = short, 2 = long) */ 153 0, /* bitsize */ 154 FALSE, /* pc_relative */ 155 0, /* bitpos */ 156 complain_overflow_dont, /* complain_on_overflow */ 157 NULL, /* special_function */ 158 "R_OPENRISC_GNU_VTINHERIT", /* name */ 159 FALSE, /* partial_inplace */ 160 0, /* src_mask */ 161 0, /* dst_mask */ 162 FALSE), /* pcrel_offset */ 163 164 /* GNU extension to record C++ vtable member usage. */ 165 HOWTO (R_OPENRISC_GNU_VTENTRY, /* type */ 166 0, /* rightshift */ 167 2, /* size (0 = byte, 1 = short, 2 = long) */ 168 0, /* bitsize */ 169 FALSE, /* pc_relative */ 170 0, /* bitpos */ 171 complain_overflow_dont, /* complain_on_overflow */ 172 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 173 "R_OPENRISC_GNU_VTENTRY", /* name */ 174 FALSE, /* partial_inplace */ 175 0, /* src_mask */ 176 0, /* dst_mask */ 177 FALSE), /* pcrel_offset */ 178 }; 179 180 /* Map BFD reloc types to OpenRISC ELF reloc types. */ 181 182 struct openrisc_reloc_map 183 { 184 bfd_reloc_code_real_type bfd_reloc_val; 185 unsigned int openrisc_reloc_val; 186 }; 187 188 static const struct openrisc_reloc_map openrisc_reloc_map[] = 189 { 190 { BFD_RELOC_NONE, R_OPENRISC_NONE }, 191 { BFD_RELOC_32, R_OPENRISC_32 }, 192 { BFD_RELOC_16, R_OPENRISC_16 }, 193 { BFD_RELOC_8, R_OPENRISC_8 }, 194 { BFD_RELOC_OPENRISC_REL_26,R_OPENRISC_INSN_REL_26 }, 195 { BFD_RELOC_OPENRISC_ABS_26,R_OPENRISC_INSN_ABS_26 }, 196 { BFD_RELOC_HI16, R_OPENRISC_HI_16_IN_INSN }, 197 { BFD_RELOC_LO16, R_OPENRISC_LO_16_IN_INSN }, 198 { BFD_RELOC_VTABLE_INHERIT, R_OPENRISC_GNU_VTINHERIT }, 199 { BFD_RELOC_VTABLE_ENTRY, R_OPENRISC_GNU_VTENTRY } 200 }; 201 202 static reloc_howto_type * 203 openrisc_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 204 bfd_reloc_code_real_type code) 205 { 206 unsigned int i; 207 208 for (i = ARRAY_SIZE (openrisc_reloc_map); --i;) 209 if (openrisc_reloc_map[i].bfd_reloc_val == code) 210 return & openrisc_elf_howto_table[openrisc_reloc_map[i]. 211 openrisc_reloc_val]; 212 213 return NULL; 214 } 215 216 /* Set the howto pointer for an OpenRISC ELF reloc. */ 217 218 static void 219 openrisc_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED, 220 arelent * cache_ptr, 221 Elf_Internal_Rela * dst) 222 { 223 unsigned int r_type; 224 225 r_type = ELF32_R_TYPE (dst->r_info); 226 BFD_ASSERT (r_type < (unsigned int) R_OPENRISC_max); 227 cache_ptr->howto = & openrisc_elf_howto_table[r_type]; 228 } 229 230 /* Perform a single relocation. By default we use the standard BFD 231 routines, but a few relocs, we have to do them ourselves. */ 232 233 static bfd_reloc_status_type 234 openrisc_final_link_relocate (reloc_howto_type *howto, 235 bfd *input_bfd, 236 asection *input_section, 237 bfd_byte *contents, 238 Elf_Internal_Rela *rel, 239 bfd_vma relocation) 240 { 241 bfd_reloc_status_type r = bfd_reloc_ok; 242 243 switch (howto->type) 244 { 245 case R_OPENRISC_LO_16_IN_INSN: 246 relocation &= 0xffff; 247 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 248 contents, rel->r_offset, 249 relocation, rel->r_addend); 250 break; 251 252 default: 253 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 254 contents, rel->r_offset, 255 relocation, rel->r_addend); 256 } 257 258 return r; 259 } 260 261 /* Relocate an OpenRISC ELF section. 262 263 The RELOCATE_SECTION function is called by the new ELF backend linker 264 to handle the relocations for a section. 265 266 The relocs are always passed as Rela structures; if the section 267 actually uses Rel structures, the r_addend field will always be 268 zero. 269 270 This function is responsible for adjusting the section contents as 271 necessary, and (if using Rela relocs and generating a relocatable 272 output file) adjusting the reloc addend as necessary. 273 274 This function does not have to worry about setting the reloc 275 address or the reloc symbol index. 276 277 LOCAL_SYMS is a pointer to the swapped in local symbols. 278 279 LOCAL_SECTIONS is an array giving the section in the input file 280 corresponding to the st_shndx field of each local symbol. 281 282 The global hash table entry for the global symbols can be found 283 via elf_sym_hashes (input_bfd). 284 285 When generating relocatable output, this function must handle 286 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 287 going to be the section symbol corresponding to the output 288 section, which means that the addend must be adjusted 289 accordingly. */ 290 291 static bfd_boolean 292 openrisc_elf_relocate_section (bfd *output_bfd, 293 struct bfd_link_info *info, 294 bfd *input_bfd, 295 asection *input_section, 296 bfd_byte *contents, 297 Elf_Internal_Rela *relocs, 298 Elf_Internal_Sym *local_syms, 299 asection **local_sections) 300 { 301 Elf_Internal_Shdr *symtab_hdr; 302 struct elf_link_hash_entry **sym_hashes; 303 Elf_Internal_Rela *rel; 304 Elf_Internal_Rela *relend; 305 306 if (info->relocatable) 307 return TRUE; 308 309 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 310 sym_hashes = elf_sym_hashes (input_bfd); 311 relend = relocs + input_section->reloc_count; 312 313 for (rel = relocs; rel < relend; rel++) 314 { 315 reloc_howto_type *howto; 316 unsigned long r_symndx; 317 Elf_Internal_Sym *sym; 318 asection *sec; 319 struct elf_link_hash_entry *h; 320 bfd_vma relocation; 321 bfd_reloc_status_type r; 322 const char *name = NULL; 323 int r_type; 324 325 r_type = ELF32_R_TYPE (rel->r_info); 326 r_symndx = ELF32_R_SYM (rel->r_info); 327 328 if (r_type == R_OPENRISC_GNU_VTINHERIT 329 || r_type == R_OPENRISC_GNU_VTENTRY) 330 continue; 331 332 if ((unsigned int) r_type > 333 (sizeof openrisc_elf_howto_table / sizeof (reloc_howto_type))) 334 abort (); 335 336 /* This is a final link. */ 337 howto = openrisc_elf_howto_table + ELF32_R_TYPE (rel->r_info); 338 h = NULL; 339 sym = NULL; 340 sec = NULL; 341 342 if (r_symndx < symtab_hdr->sh_info) 343 { 344 sym = local_syms + r_symndx; 345 sec = local_sections[r_symndx]; 346 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 347 348 name = bfd_elf_string_from_elf_section 349 (input_bfd, symtab_hdr->sh_link, sym->st_name); 350 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; 351 } 352 else 353 { 354 bfd_boolean unresolved_reloc, warned; 355 356 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 357 r_symndx, symtab_hdr, sym_hashes, 358 h, sec, relocation, 359 unresolved_reloc, warned); 360 } 361 362 r = openrisc_final_link_relocate (howto, input_bfd, input_section, 363 contents, rel, relocation); 364 365 if (r != bfd_reloc_ok) 366 { 367 const char *msg = NULL; 368 369 switch (r) 370 { 371 case bfd_reloc_overflow: 372 r = info->callbacks->reloc_overflow 373 (info, (h ? &h->root : NULL), name, howto->name, 374 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 375 break; 376 377 case bfd_reloc_undefined: 378 r = info->callbacks->undefined_symbol 379 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 380 break; 381 382 case bfd_reloc_outofrange: 383 msg = _("internal error: out of range error"); 384 break; 385 386 case bfd_reloc_notsupported: 387 msg = _("internal error: unsupported relocation error"); 388 break; 389 390 case bfd_reloc_dangerous: 391 msg = _("internal error: dangerous relocation"); 392 break; 393 394 default: 395 msg = _("internal error: unknown error"); 396 break; 397 } 398 399 if (msg) 400 r = info->callbacks->warning 401 (info, msg, name, input_bfd, input_section, rel->r_offset); 402 403 if (!r) 404 return FALSE; 405 } 406 } 407 408 return TRUE; 409 } 410 411 /* Return the section that should be marked against GC for a given 412 relocation. */ 413 414 static asection * 415 openrisc_elf_gc_mark_hook (asection *sec, 416 struct bfd_link_info *info ATTRIBUTE_UNUSED, 417 Elf_Internal_Rela *rel, 418 struct elf_link_hash_entry *h, 419 Elf_Internal_Sym *sym) 420 { 421 if (h == NULL) 422 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 423 424 switch (ELF32_R_TYPE (rel->r_info)) 425 { 426 case R_OPENRISC_GNU_VTINHERIT: 427 case R_OPENRISC_GNU_VTENTRY: 428 break; 429 430 default: 431 switch (h->root.type) 432 { 433 case bfd_link_hash_defined: 434 case bfd_link_hash_defweak: 435 return h->root.u.def.section; 436 437 case bfd_link_hash_common: 438 return h->root.u.c.p->section; 439 440 default: 441 break; 442 } 443 } 444 445 return NULL; 446 } 447 448 /* Update the got entry reference counts for the section being removed. */ 449 450 static bfd_boolean 451 openrisc_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED, 452 struct bfd_link_info *info ATTRIBUTE_UNUSED, 453 asection *sec ATTRIBUTE_UNUSED, 454 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED) 455 { 456 return TRUE; 457 } 458 459 /* Look through the relocs for a section during the first phase. 460 Since we don't do .gots or .plts, we just need to consider the 461 virtual table relocs for gc. */ 462 463 static bfd_boolean 464 openrisc_elf_check_relocs (bfd *abfd, 465 struct bfd_link_info *info, 466 asection *sec, 467 const Elf_Internal_Rela *relocs) 468 { 469 Elf_Internal_Shdr *symtab_hdr; 470 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; 471 const Elf_Internal_Rela *rel; 472 const Elf_Internal_Rela *rel_end; 473 474 if (info->relocatable) 475 return TRUE; 476 477 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 478 sym_hashes = elf_sym_hashes (abfd); 479 sym_hashes_end = 480 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym); 481 if (!elf_bad_symtab (abfd)) 482 sym_hashes_end -= symtab_hdr->sh_info; 483 484 rel_end = relocs + sec->reloc_count; 485 for (rel = relocs; rel < rel_end; rel++) 486 { 487 struct elf_link_hash_entry *h; 488 unsigned long r_symndx; 489 490 r_symndx = ELF32_R_SYM (rel->r_info); 491 if (r_symndx < symtab_hdr->sh_info) 492 h = NULL; 493 else 494 { 495 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 496 while (h->root.type == bfd_link_hash_indirect 497 || h->root.type == bfd_link_hash_warning) 498 h = (struct elf_link_hash_entry *) h->root.u.i.link; 499 } 500 501 switch (ELF32_R_TYPE (rel->r_info)) 502 { 503 /* This relocation describes the C++ object vtable hierarchy. 504 Reconstruct it for later use during GC. */ 505 case R_OPENRISC_GNU_VTINHERIT: 506 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 507 return FALSE; 508 break; 509 510 /* This relocation describes which C++ vtable entries are actually 511 used. Record for later use during GC. */ 512 case R_OPENRISC_GNU_VTENTRY: 513 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 514 return FALSE; 515 break; 516 } 517 } 518 519 return TRUE; 520 } 521 522 /* Set the right machine number. */ 523 524 static bfd_boolean 525 openrisc_elf_object_p (bfd *abfd) 526 { 527 bfd_default_set_arch_mach (abfd, bfd_arch_openrisc, 0); 528 return TRUE; 529 } 530 531 /* Store the machine number in the flags field. */ 532 533 static void 534 openrisc_elf_final_write_processing (bfd *abfd, 535 bfd_boolean linker ATTRIBUTE_UNUSED) 536 { 537 unsigned long val; 538 539 switch (bfd_get_mach (abfd)) 540 { 541 default: 542 val = 0; 543 break; 544 } 545 546 elf_elfheader (abfd)->e_flags &= ~0xf; 547 elf_elfheader (abfd)->e_flags |= val; 548 } 549 550 551 #define ELF_ARCH bfd_arch_openrisc 552 #define ELF_MACHINE_CODE EM_OPENRISC 553 #define ELF_MACHINE_ALT1 EM_OPENRISC_OLD 554 #define ELF_MAXPAGESIZE 0x1000 555 556 #define TARGET_BIG_SYM bfd_elf32_openrisc_vec 557 #define TARGET_BIG_NAME "elf32-openrisc" 558 559 #define elf_info_to_howto_rel NULL 560 #define elf_info_to_howto openrisc_info_to_howto_rela 561 #define elf_backend_relocate_section openrisc_elf_relocate_section 562 #define elf_backend_gc_mark_hook openrisc_elf_gc_mark_hook 563 #define elf_backend_gc_sweep_hook openrisc_elf_gc_sweep_hook 564 #define elf_backend_check_relocs openrisc_elf_check_relocs 565 566 #define elf_backend_can_gc_sections 1 567 #define elf_backend_rela_normal 1 568 569 #define bfd_elf32_bfd_reloc_type_lookup openrisc_reloc_type_lookup 570 571 #define elf_backend_object_p openrisc_elf_object_p 572 #define elf_backend_final_write_processing openrisc_elf_final_write_processing 573 574 #include "elf32-target.h" 575