1 /* Xstormy16-specific support for 32-bit ELF. 2 Copyright (C) 2000-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., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "libbfd.h" 24 #include "elf-bfd.h" 25 #include "elf/xstormy16.h" 26 #include "libiberty.h" 27 28 /* Handle the R_XSTORMY16_24 reloc, which has an odd bit arrangement. */ 29 30 static bfd_reloc_status_type 31 xstormy16_elf_24_reloc (bfd *abfd, 32 arelent *reloc_entry, 33 asymbol *symbol, 34 void * data, 35 asection *input_section, 36 bfd *output_bfd, 37 char **error_message ATTRIBUTE_UNUSED) 38 { 39 bfd_vma relocation, x; 40 41 if (output_bfd != NULL) 42 { 43 reloc_entry->address += input_section->output_offset; 44 return bfd_reloc_ok; 45 } 46 47 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 48 return bfd_reloc_outofrange; 49 50 if (bfd_is_com_section (symbol->section)) 51 relocation = 0; 52 else 53 relocation = symbol->value; 54 55 relocation += symbol->section->output_section->vma; 56 relocation += symbol->section->output_offset; 57 relocation += reloc_entry->addend; 58 59 x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 60 x &= 0x0000ff00; 61 x |= relocation & 0xff; 62 x |= (relocation << 8) & 0xffff0000; 63 bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address); 64 65 if (relocation & ~ (bfd_vma) 0xffffff) 66 return bfd_reloc_overflow; 67 68 return bfd_reloc_ok; 69 } 70 71 static reloc_howto_type xstormy16_elf_howto_table [] = 72 { 73 /* This reloc does nothing. */ 74 HOWTO (R_XSTORMY16_NONE, /* type */ 75 0, /* rightshift */ 76 2, /* size (0 = byte, 1 = short, 2 = long) */ 77 32, /* bitsize */ 78 FALSE, /* pc_relative */ 79 0, /* bitpos */ 80 complain_overflow_bitfield, /* complain_on_overflow */ 81 bfd_elf_generic_reloc, /* special_function */ 82 "R_XSTORMY16_NONE", /* name */ 83 FALSE, /* partial_inplace */ 84 0, /* src_mask */ 85 0, /* dst_mask */ 86 FALSE), /* pcrel_offset */ 87 88 /* A 32 bit absolute relocation. */ 89 HOWTO (R_XSTORMY16_32, /* type */ 90 0, /* rightshift */ 91 2, /* size (0 = byte, 1 = short, 2 = long) */ 92 32, /* bitsize */ 93 FALSE, /* pc_relative */ 94 0, /* bitpos */ 95 complain_overflow_dont, /* complain_on_overflow */ 96 bfd_elf_generic_reloc, /* special_function */ 97 "R_XSTORMY16_32", /* name */ 98 FALSE, /* partial_inplace */ 99 0, /* src_mask */ 100 0xffffffff, /* dst_mask */ 101 FALSE), /* pcrel_offset */ 102 103 /* A 16 bit absolute relocation. */ 104 HOWTO (R_XSTORMY16_16, /* type */ 105 0, /* rightshift */ 106 1, /* size (0 = byte, 1 = short, 2 = long) */ 107 16, /* bitsize */ 108 FALSE, /* pc_relative */ 109 0, /* bitpos */ 110 complain_overflow_bitfield, /* complain_on_overflow */ 111 bfd_elf_generic_reloc, /* special_function */ 112 "R_XSTORMY16_16", /* name */ 113 FALSE, /* partial_inplace */ 114 0, /* src_mask */ 115 0xffff, /* dst_mask */ 116 FALSE), /* pcrel_offset */ 117 118 /* An 8 bit absolute relocation. */ 119 HOWTO (R_XSTORMY16_8, /* type */ 120 0, /* rightshift */ 121 0, /* size (0 = byte, 1 = short, 2 = long) */ 122 8, /* bitsize */ 123 FALSE, /* pc_relative */ 124 0, /* bitpos */ 125 complain_overflow_unsigned, /* complain_on_overflow */ 126 bfd_elf_generic_reloc, /* special_function */ 127 "R_XSTORMY16_8", /* name */ 128 FALSE, /* partial_inplace */ 129 0, /* src_mask */ 130 0xff, /* dst_mask */ 131 FALSE), /* pcrel_offset */ 132 133 /* A 32 bit pc-relative relocation. */ 134 HOWTO (R_XSTORMY16_PC32, /* type */ 135 0, /* rightshift */ 136 2, /* size (0 = byte, 1 = short, 2 = long) */ 137 32, /* bitsize */ 138 TRUE, /* pc_relative */ 139 0, /* bitpos */ 140 complain_overflow_dont, /* complain_on_overflow */ 141 bfd_elf_generic_reloc, /* special_function */ 142 "R_XSTORMY16_PC32", /* name */ 143 FALSE, /* partial_inplace */ 144 0, /* src_mask */ 145 0xffffffff, /* dst_mask */ 146 TRUE), /* pcrel_offset */ 147 148 /* A 16 bit pc-relative relocation. */ 149 HOWTO (R_XSTORMY16_PC16, /* type */ 150 0, /* rightshift */ 151 1, /* size (0 = byte, 1 = short, 2 = long) */ 152 16, /* bitsize */ 153 TRUE, /* pc_relative */ 154 0, /* bitpos */ 155 complain_overflow_signed, /* complain_on_overflow */ 156 bfd_elf_generic_reloc, /* special_function */ 157 "R_XSTORMY16_PC16", /* name */ 158 FALSE, /* partial_inplace */ 159 0, /* src_mask */ 160 0xffffffff, /* dst_mask */ 161 TRUE), /* pcrel_offset */ 162 163 /* An 8 bit pc-relative relocation. */ 164 HOWTO (R_XSTORMY16_PC8, /* type */ 165 0, /* rightshift */ 166 0, /* size (0 = byte, 1 = short, 2 = long) */ 167 8, /* bitsize */ 168 TRUE, /* pc_relative */ 169 0, /* bitpos */ 170 complain_overflow_signed, /* complain_on_overflow */ 171 bfd_elf_generic_reloc, /* special_function */ 172 "R_XSTORMY16_PC8", /* name */ 173 FALSE, /* partial_inplace */ 174 0, /* src_mask */ 175 0xffffffff, /* dst_mask */ 176 TRUE), /* pcrel_offset */ 177 178 /* A 12-bit pc-relative relocation suitable for the branch instructions. */ 179 HOWTO (R_XSTORMY16_REL_12, /* type */ 180 1, /* rightshift */ 181 1, /* size (0 = byte, 1 = short, 2 = long) */ 182 11, /* bitsize */ 183 TRUE, /* pc_relative */ 184 1, /* bitpos */ 185 complain_overflow_signed, /* complain_on_overflow */ 186 bfd_elf_generic_reloc, /* special_function */ 187 "R_XSTORMY16_REL_12", /* name */ 188 FALSE, /* partial_inplace */ 189 0, /* src_mask */ 190 0x0ffe, /* dst_mask */ 191 TRUE), /* pcrel_offset */ 192 193 /* A 24-bit absolute relocation suitable for the jump instructions. */ 194 HOWTO (R_XSTORMY16_24, /* type */ 195 0, /* rightshift */ 196 2, /* size (0 = byte, 1 = short, 2 = long) */ 197 24, /* bitsize */ 198 FALSE, /* pc_relative */ 199 0, /* bitpos */ 200 complain_overflow_unsigned, /* complain_on_overflow */ 201 xstormy16_elf_24_reloc, /* special_function */ 202 "R_XSTORMY16_24", /* name */ 203 TRUE, /* partial_inplace */ 204 0, /* src_mask */ 205 0xffff00ff, /* dst_mask */ 206 TRUE), /* pcrel_offset */ 207 208 /* A 16 bit absolute relocation to a function pointer. */ 209 HOWTO (R_XSTORMY16_FPTR16, /* type */ 210 0, /* rightshift */ 211 1, /* size (0 = byte, 1 = short, 2 = long) */ 212 16, /* bitsize */ 213 FALSE, /* pc_relative */ 214 0, /* bitpos */ 215 complain_overflow_bitfield, /* complain_on_overflow */ 216 bfd_elf_generic_reloc, /* special_function */ 217 "R_XSTORMY16_FPTR16", /* name */ 218 FALSE, /* partial_inplace */ 219 0, /* src_mask */ 220 0xffffffff, /* dst_mask */ 221 FALSE), /* pcrel_offset */ 222 223 /* Low order 16 bit value of a high memory address. */ 224 HOWTO (R_XSTORMY16_LO16, /* type */ 225 0, /* rightshift */ 226 1, /* size (0 = byte, 1 = short, 2 = long) */ 227 16, /* bitsize */ 228 FALSE, /* pc_relative */ 229 0, /* bitpos */ 230 complain_overflow_dont, /* complain_on_overflow */ 231 bfd_elf_generic_reloc, /* special_function */ 232 "R_XSTORMY16_LO16", /* name */ 233 FALSE, /* partial_inplace */ 234 0, /* src_mask */ 235 0xffff, /* dst_mask */ 236 FALSE), /* pcrel_offset */ 237 238 /* High order 16 bit value of a high memory address. */ 239 HOWTO (R_XSTORMY16_HI16, /* type */ 240 16, /* rightshift */ 241 1, /* size (0 = byte, 1 = short, 2 = long) */ 242 16, /* bitsize */ 243 FALSE, /* pc_relative */ 244 0, /* bitpos */ 245 complain_overflow_dont, /* complain_on_overflow */ 246 bfd_elf_generic_reloc, /* special_function */ 247 "R_XSTORMY16_HI16", /* name */ 248 FALSE, /* partial_inplace */ 249 0, /* src_mask */ 250 0xffff, /* dst_mask */ 251 FALSE), /* pcrel_offset */ 252 253 /* A 12 bit absolute relocation. */ 254 HOWTO (R_XSTORMY16_12, /* type */ 255 0, /* rightshift */ 256 1, /* size (0 = byte, 1 = short, 2 = long) */ 257 12, /* bitsize */ 258 FALSE, /* pc_relative */ 259 0, /* bitpos */ 260 complain_overflow_signed, /* complain_on_overflow */ 261 bfd_elf_generic_reloc, /* special_function */ 262 "R_XSTORMY16_12", /* name */ 263 FALSE, /* partial_inplace */ 264 0x0000, /* src_mask */ 265 0x0fff, /* dst_mask */ 266 FALSE), /* pcrel_offset */ 267 }; 268 269 static reloc_howto_type xstormy16_elf_howto_table2 [] = 270 { 271 /* GNU extension to record C++ vtable hierarchy */ 272 HOWTO (R_XSTORMY16_GNU_VTINHERIT, /* type */ 273 0, /* rightshift */ 274 2, /* size (0 = byte, 1 = short, 2 = long) */ 275 0, /* bitsize */ 276 FALSE, /* pc_relative */ 277 0, /* bitpos */ 278 complain_overflow_dont, /* complain_on_overflow */ 279 NULL, /* special_function */ 280 "R_XSTORMY16_GNU_VTINHERIT", /* name */ 281 FALSE, /* partial_inplace */ 282 0, /* src_mask */ 283 0, /* dst_mask */ 284 FALSE), /* pcrel_offset */ 285 286 /* GNU extension to record C++ vtable member usage */ 287 HOWTO (R_XSTORMY16_GNU_VTENTRY, /* type */ 288 0, /* rightshift */ 289 2, /* size (0 = byte, 1 = short, 2 = long) */ 290 0, /* bitsize */ 291 FALSE, /* pc_relative */ 292 0, /* bitpos */ 293 complain_overflow_dont, /* complain_on_overflow */ 294 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 295 "R_XSTORMY16_GNU_VTENTRY", /* name */ 296 FALSE, /* partial_inplace */ 297 0, /* src_mask */ 298 0, /* dst_mask */ 299 FALSE), /* pcrel_offset */ 300 301 }; 302 303 /* Map BFD reloc types to XSTORMY16 ELF reloc types. */ 304 305 typedef struct xstormy16_reloc_map 306 { 307 bfd_reloc_code_real_type bfd_reloc_val; 308 unsigned int xstormy16_reloc_val; 309 reloc_howto_type * table; 310 } reloc_map; 311 312 static const reloc_map xstormy16_reloc_map [] = 313 { 314 { BFD_RELOC_NONE, R_XSTORMY16_NONE, xstormy16_elf_howto_table }, 315 { BFD_RELOC_32, R_XSTORMY16_32, xstormy16_elf_howto_table }, 316 { BFD_RELOC_16, R_XSTORMY16_16, xstormy16_elf_howto_table }, 317 { BFD_RELOC_8, R_XSTORMY16_8, xstormy16_elf_howto_table }, 318 { BFD_RELOC_32_PCREL, R_XSTORMY16_PC32, xstormy16_elf_howto_table }, 319 { BFD_RELOC_16_PCREL, R_XSTORMY16_PC16, xstormy16_elf_howto_table }, 320 { BFD_RELOC_8_PCREL, R_XSTORMY16_PC8, xstormy16_elf_howto_table }, 321 { BFD_RELOC_XSTORMY16_REL_12, R_XSTORMY16_REL_12, xstormy16_elf_howto_table }, 322 { BFD_RELOC_XSTORMY16_24, R_XSTORMY16_24, xstormy16_elf_howto_table }, 323 { BFD_RELOC_XSTORMY16_FPTR16, R_XSTORMY16_FPTR16, xstormy16_elf_howto_table }, 324 { BFD_RELOC_LO16, R_XSTORMY16_LO16, xstormy16_elf_howto_table }, 325 { BFD_RELOC_HI16, R_XSTORMY16_HI16, xstormy16_elf_howto_table }, 326 { BFD_RELOC_XSTORMY16_12, R_XSTORMY16_12, xstormy16_elf_howto_table }, 327 { BFD_RELOC_VTABLE_INHERIT, R_XSTORMY16_GNU_VTINHERIT, xstormy16_elf_howto_table2 }, 328 { BFD_RELOC_VTABLE_ENTRY, R_XSTORMY16_GNU_VTENTRY, xstormy16_elf_howto_table2 }, 329 }; 330 331 static reloc_howto_type * 332 xstormy16_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 333 bfd_reloc_code_real_type code) 334 { 335 unsigned int i; 336 337 for (i = ARRAY_SIZE (xstormy16_reloc_map); --i;) 338 { 339 const reloc_map * entry; 340 341 entry = xstormy16_reloc_map + i; 342 343 if (entry->bfd_reloc_val == code) 344 return entry->table + (entry->xstormy16_reloc_val 345 - entry->table[0].type); 346 } 347 348 return NULL; 349 } 350 351 static reloc_howto_type * 352 xstormy16_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 353 const char *r_name) 354 { 355 unsigned int i; 356 357 for (i = 0; 358 i < (sizeof (xstormy16_elf_howto_table) 359 / sizeof (xstormy16_elf_howto_table[0])); 360 i++) 361 if (xstormy16_elf_howto_table[i].name != NULL 362 && strcasecmp (xstormy16_elf_howto_table[i].name, r_name) == 0) 363 return &xstormy16_elf_howto_table[i]; 364 365 for (i = 0; 366 i < (sizeof (xstormy16_elf_howto_table2) 367 / sizeof (xstormy16_elf_howto_table2[0])); 368 i++) 369 if (xstormy16_elf_howto_table2[i].name != NULL 370 && strcasecmp (xstormy16_elf_howto_table2[i].name, r_name) == 0) 371 return &xstormy16_elf_howto_table2[i]; 372 373 return NULL; 374 } 375 376 /* Set the howto pointer for an XSTORMY16 ELF reloc. */ 377 378 static void 379 xstormy16_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED, 380 arelent * cache_ptr, 381 Elf_Internal_Rela * dst) 382 { 383 unsigned int r_type = ELF32_R_TYPE (dst->r_info); 384 385 if (r_type <= (unsigned int) R_XSTORMY16_12) 386 cache_ptr->howto = &xstormy16_elf_howto_table [r_type]; 387 else if (r_type - R_XSTORMY16_GNU_VTINHERIT 388 <= (unsigned int) R_XSTORMY16_GNU_VTENTRY) 389 cache_ptr->howto 390 = &xstormy16_elf_howto_table2 [r_type - R_XSTORMY16_GNU_VTINHERIT]; 391 else 392 abort (); 393 } 394 395 /* We support 16-bit pointers to code above 64k by generating a thunk 396 below 64k containing a JMPF instruction to the final address. We 397 cannot, unfortunately, minimize the number of thunks unless the 398 -relax switch is given, as otherwise we have no idea where the 399 sections will fall in the address space. */ 400 401 static bfd_boolean 402 xstormy16_elf_check_relocs (bfd *abfd, 403 struct bfd_link_info *info, 404 asection *sec, 405 const Elf_Internal_Rela *relocs) 406 { 407 const Elf_Internal_Rela *rel, *relend; 408 struct elf_link_hash_entry **sym_hashes; 409 Elf_Internal_Shdr *symtab_hdr; 410 bfd_vma *local_plt_offsets; 411 asection *splt; 412 bfd *dynobj; 413 414 if (info->relocatable) 415 return TRUE; 416 417 symtab_hdr = &elf_tdata(abfd)->symtab_hdr; 418 sym_hashes = elf_sym_hashes (abfd); 419 local_plt_offsets = elf_local_got_offsets (abfd); 420 splt = NULL; 421 dynobj = elf_hash_table(info)->dynobj; 422 423 relend = relocs + sec->reloc_count; 424 for (rel = relocs; rel < relend; ++rel) 425 { 426 unsigned long r_symndx; 427 struct elf_link_hash_entry *h; 428 bfd_vma *offset; 429 430 r_symndx = ELF32_R_SYM (rel->r_info); 431 if (r_symndx < symtab_hdr->sh_info) 432 h = NULL; 433 else 434 { 435 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 436 while (h->root.type == bfd_link_hash_indirect 437 || h->root.type == bfd_link_hash_warning) 438 h = (struct elf_link_hash_entry *) h->root.u.i.link; 439 440 /* PR15323, ref flags aren't set for references in the same 441 object. */ 442 h->root.non_ir_ref = 1; 443 } 444 445 switch (ELF32_R_TYPE (rel->r_info)) 446 { 447 /* This relocation describes a 16-bit pointer to a function. 448 We may need to allocate a thunk in low memory; reserve memory 449 for it now. */ 450 case R_XSTORMY16_FPTR16: 451 if (rel->r_addend != 0) 452 { 453 (*info->callbacks->warning) 454 (info, _("non-zero addend in @fptr reloc"), 0, 455 abfd, 0, 0); 456 } 457 458 if (dynobj == NULL) 459 elf_hash_table (info)->dynobj = dynobj = abfd; 460 if (splt == NULL) 461 { 462 splt = bfd_get_linker_section (dynobj, ".plt"); 463 if (splt == NULL) 464 { 465 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 466 | SEC_IN_MEMORY | SEC_LINKER_CREATED 467 | SEC_READONLY | SEC_CODE); 468 469 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt", 470 flags); 471 if (splt == NULL 472 || ! bfd_set_section_alignment (dynobj, splt, 1)) 473 return FALSE; 474 } 475 } 476 477 if (h != NULL) 478 offset = &h->plt.offset; 479 else 480 { 481 if (local_plt_offsets == NULL) 482 { 483 size_t size; 484 unsigned int i; 485 486 size = symtab_hdr->sh_info * sizeof (bfd_vma); 487 local_plt_offsets = bfd_alloc (abfd, size); 488 if (local_plt_offsets == NULL) 489 return FALSE; 490 elf_local_got_offsets (abfd) = local_plt_offsets; 491 492 for (i = 0; i < symtab_hdr->sh_info; i++) 493 local_plt_offsets[i] = (bfd_vma) -1; 494 } 495 offset = &local_plt_offsets[r_symndx]; 496 } 497 498 if (*offset == (bfd_vma) -1) 499 { 500 *offset = splt->size; 501 splt->size += 4; 502 } 503 break; 504 505 /* This relocation describes the C++ object vtable hierarchy. 506 Reconstruct it for later use during GC. */ 507 case R_XSTORMY16_GNU_VTINHERIT: 508 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 509 return FALSE; 510 break; 511 512 /* This relocation describes which C++ vtable entries are actually 513 used. Record for later use during GC. */ 514 case R_XSTORMY16_GNU_VTENTRY: 515 BFD_ASSERT (h != NULL); 516 if (h != NULL 517 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 518 return FALSE; 519 break; 520 } 521 } 522 523 return TRUE; 524 } 525 526 /* A subroutine of xstormy16_elf_relax_section. If the global symbol H 527 is within the low 64k, remove any entry for it in the plt. */ 528 529 struct relax_plt_data 530 { 531 asection *splt; 532 bfd_boolean *again; 533 }; 534 535 static bfd_boolean 536 xstormy16_relax_plt_check (struct elf_link_hash_entry *h, void * xdata) 537 { 538 struct relax_plt_data *data = (struct relax_plt_data *) xdata; 539 540 if (h->plt.offset != (bfd_vma) -1) 541 { 542 bfd_vma address; 543 544 if (h->root.type == bfd_link_hash_undefined 545 || h->root.type == bfd_link_hash_undefweak) 546 address = 0; 547 else 548 address = (h->root.u.def.section->output_section->vma 549 + h->root.u.def.section->output_offset 550 + h->root.u.def.value); 551 552 if (address <= 0xffff) 553 { 554 h->plt.offset = -1; 555 data->splt->size -= 4; 556 *data->again = TRUE; 557 } 558 } 559 560 return TRUE; 561 } 562 563 /* A subroutine of xstormy16_elf_relax_section. If the global symbol H 564 previously had a plt entry, give it a new entry offset. */ 565 566 static bfd_boolean 567 xstormy16_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata) 568 { 569 bfd_vma *entry = (bfd_vma *) xdata; 570 571 if (h->plt.offset != (bfd_vma) -1) 572 { 573 h->plt.offset = *entry; 574 *entry += 4; 575 } 576 577 return TRUE; 578 } 579 580 static bfd_boolean 581 xstormy16_elf_relax_section (bfd *dynobj, 582 asection *splt, 583 struct bfd_link_info *info, 584 bfd_boolean *again) 585 { 586 struct relax_plt_data relax_plt_data; 587 bfd *ibfd; 588 589 /* Assume nothing changes. */ 590 *again = FALSE; 591 592 if (info->relocatable) 593 return TRUE; 594 595 /* We only relax the .plt section at the moment. */ 596 if (dynobj != elf_hash_table (info)->dynobj 597 || strcmp (splt->name, ".plt") != 0) 598 return TRUE; 599 600 /* Quick check for an empty plt. */ 601 if (splt->size == 0) 602 return TRUE; 603 604 /* Map across all global symbols; see which ones happen to 605 fall in the low 64k. */ 606 relax_plt_data.splt = splt; 607 relax_plt_data.again = again; 608 elf_link_hash_traverse (elf_hash_table (info), xstormy16_relax_plt_check, 609 &relax_plt_data); 610 611 /* Likewise for local symbols, though that's somewhat less convenient 612 as we have to walk the list of input bfds and swap in symbol data. */ 613 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next) 614 { 615 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd); 616 Elf_Internal_Shdr *symtab_hdr; 617 Elf_Internal_Sym *isymbuf = NULL; 618 unsigned int idx; 619 620 if (! local_plt_offsets) 621 continue; 622 623 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 624 if (symtab_hdr->sh_info != 0) 625 { 626 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 627 if (isymbuf == NULL) 628 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr, 629 symtab_hdr->sh_info, 0, 630 NULL, NULL, NULL); 631 if (isymbuf == NULL) 632 return FALSE; 633 } 634 635 for (idx = 0; idx < symtab_hdr->sh_info; ++idx) 636 { 637 Elf_Internal_Sym *isym; 638 asection *tsec; 639 bfd_vma address; 640 641 if (local_plt_offsets[idx] == (bfd_vma) -1) 642 continue; 643 644 isym = &isymbuf[idx]; 645 if (isym->st_shndx == SHN_UNDEF) 646 continue; 647 else if (isym->st_shndx == SHN_ABS) 648 tsec = bfd_abs_section_ptr; 649 else if (isym->st_shndx == SHN_COMMON) 650 tsec = bfd_com_section_ptr; 651 else 652 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx); 653 654 address = (tsec->output_section->vma 655 + tsec->output_offset 656 + isym->st_value); 657 if (address <= 0xffff) 658 { 659 local_plt_offsets[idx] = -1; 660 splt->size -= 4; 661 *again = TRUE; 662 } 663 } 664 665 if (isymbuf != NULL 666 && symtab_hdr->contents != (unsigned char *) isymbuf) 667 { 668 if (! info->keep_memory) 669 free (isymbuf); 670 else 671 { 672 /* Cache the symbols for elf_link_input_bfd. */ 673 symtab_hdr->contents = (unsigned char *) isymbuf; 674 } 675 } 676 } 677 678 /* If we changed anything, walk the symbols again to reallocate 679 .plt entry addresses. */ 680 if (*again && splt->size > 0) 681 { 682 bfd_vma entry = 0; 683 684 elf_link_hash_traverse (elf_hash_table (info), 685 xstormy16_relax_plt_realloc, &entry); 686 687 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next) 688 { 689 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd); 690 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info; 691 unsigned int idx; 692 693 if (! local_plt_offsets) 694 continue; 695 696 for (idx = 0; idx < nlocals; ++idx) 697 if (local_plt_offsets[idx] != (bfd_vma) -1) 698 { 699 local_plt_offsets[idx] = entry; 700 entry += 4; 701 } 702 } 703 } 704 705 return TRUE; 706 } 707 708 static bfd_boolean 709 xstormy16_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 710 struct bfd_link_info *info) 711 { 712 bfd *dynobj; 713 asection *splt; 714 715 if (info->relocatable) 716 return TRUE; 717 718 dynobj = elf_hash_table (info)->dynobj; 719 if (dynobj == NULL) 720 return TRUE; 721 722 splt = bfd_get_linker_section (dynobj, ".plt"); 723 BFD_ASSERT (splt != NULL); 724 725 splt->contents = bfd_zalloc (dynobj, splt->size); 726 if (splt->contents == NULL) 727 return FALSE; 728 729 return TRUE; 730 } 731 732 /* Relocate an XSTORMY16 ELF section. 733 734 The RELOCATE_SECTION function is called by the new ELF backend linker 735 to handle the relocations for a section. 736 737 The relocs are always passed as Rela structures; if the section 738 actually uses Rel structures, the r_addend field will always be 739 zero. 740 741 This function is responsible for adjusting the section contents as 742 necessary, and (if using Rela relocs and generating a relocatable 743 output file) adjusting the reloc addend as necessary. 744 745 This function does not have to worry about setting the reloc 746 address or the reloc symbol index. 747 748 LOCAL_SYMS is a pointer to the swapped in local symbols. 749 750 LOCAL_SECTIONS is an array giving the section in the input file 751 corresponding to the st_shndx field of each local symbol. 752 753 The global hash table entry for the global symbols can be found 754 via elf_sym_hashes (input_bfd). 755 756 When generating relocatable output, this function must handle 757 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 758 going to be the section symbol corresponding to the output 759 section, which means that the addend must be adjusted 760 accordingly. */ 761 762 static bfd_boolean 763 xstormy16_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED, 764 struct bfd_link_info * info, 765 bfd * input_bfd, 766 asection * input_section, 767 bfd_byte * contents, 768 Elf_Internal_Rela * relocs, 769 Elf_Internal_Sym * local_syms, 770 asection ** local_sections) 771 { 772 Elf_Internal_Shdr * symtab_hdr; 773 struct elf_link_hash_entry ** sym_hashes; 774 Elf_Internal_Rela * rel; 775 Elf_Internal_Rela * relend; 776 bfd *dynobj; 777 asection *splt; 778 779 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 780 sym_hashes = elf_sym_hashes (input_bfd); 781 relend = relocs + input_section->reloc_count; 782 783 dynobj = elf_hash_table (info)->dynobj; 784 splt = NULL; 785 if (dynobj != NULL) 786 splt = bfd_get_linker_section (dynobj, ".plt"); 787 788 for (rel = relocs; rel < relend; rel ++) 789 { 790 reloc_howto_type * howto; 791 unsigned long r_symndx; 792 Elf_Internal_Sym * sym; 793 asection * sec; 794 struct elf_link_hash_entry * h; 795 bfd_vma relocation; 796 bfd_reloc_status_type r; 797 const char * name = NULL; 798 int r_type; 799 800 r_type = ELF32_R_TYPE (rel->r_info); 801 802 if ( r_type == R_XSTORMY16_GNU_VTINHERIT 803 || r_type == R_XSTORMY16_GNU_VTENTRY) 804 continue; 805 806 r_symndx = ELF32_R_SYM (rel->r_info); 807 howto = xstormy16_elf_howto_table + ELF32_R_TYPE (rel->r_info); 808 h = NULL; 809 sym = NULL; 810 sec = NULL; 811 812 if (r_symndx < symtab_hdr->sh_info) 813 { 814 sym = local_syms + r_symndx; 815 sec = local_sections [r_symndx]; 816 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 817 } 818 else 819 { 820 bfd_boolean unresolved_reloc, warned, ignored; 821 822 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 823 r_symndx, symtab_hdr, sym_hashes, 824 h, sec, relocation, 825 unresolved_reloc, warned, ignored); 826 } 827 828 if (sec != NULL && discarded_section (sec)) 829 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 830 rel, 1, relend, howto, 0, contents); 831 832 if (info->relocatable) 833 continue; 834 835 if (h != NULL) 836 name = h->root.root.string; 837 else 838 { 839 name = (bfd_elf_string_from_elf_section 840 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 841 if (name == NULL || *name == '\0') 842 name = bfd_section_name (input_bfd, sec); 843 } 844 845 switch (ELF32_R_TYPE (rel->r_info)) 846 { 847 case R_XSTORMY16_24: 848 { 849 bfd_vma reloc = relocation + rel->r_addend; 850 unsigned int x; 851 852 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 853 x &= 0x0000ff00; 854 x |= reloc & 0xff; 855 x |= (reloc << 8) & 0xffff0000; 856 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 857 858 if (reloc & ~0xffffff) 859 r = bfd_reloc_overflow; 860 else 861 r = bfd_reloc_ok; 862 break; 863 } 864 865 case R_XSTORMY16_FPTR16: 866 { 867 bfd_vma *plt_offset; 868 869 if (h != NULL) 870 plt_offset = &h->plt.offset; 871 else 872 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx; 873 874 if (relocation <= 0xffff) 875 { 876 /* If the symbol is in range for a 16-bit address, we should 877 have deallocated the plt entry in relax_section. */ 878 BFD_ASSERT (*plt_offset == (bfd_vma) -1); 879 } 880 else 881 { 882 /* If the symbol is out of range for a 16-bit address, 883 we must have allocated a plt entry. */ 884 BFD_ASSERT (*plt_offset != (bfd_vma) -1); 885 886 /* If this is the first time we've processed this symbol, 887 fill in the plt entry with the correct symbol address. */ 888 if ((*plt_offset & 1) == 0) 889 { 890 unsigned int x; 891 892 x = 0x00000200; /* jmpf */ 893 x |= relocation & 0xff; 894 x |= (relocation << 8) & 0xffff0000; 895 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset); 896 *plt_offset |= 1; 897 } 898 899 relocation = (splt->output_section->vma 900 + splt->output_offset 901 + (*plt_offset & -2)); 902 } 903 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 904 contents, rel->r_offset, 905 relocation, 0); 906 break; 907 } 908 909 default: 910 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 911 contents, rel->r_offset, 912 relocation, rel->r_addend); 913 break; 914 } 915 916 if (r != bfd_reloc_ok) 917 { 918 const char * msg = NULL; 919 920 switch (r) 921 { 922 case bfd_reloc_overflow: 923 r = info->callbacks->reloc_overflow 924 (info, (h ? &h->root : NULL), name, howto->name, 925 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 926 break; 927 928 case bfd_reloc_undefined: 929 r = info->callbacks->undefined_symbol 930 (info, name, input_bfd, input_section, rel->r_offset, 931 TRUE); 932 break; 933 934 case bfd_reloc_outofrange: 935 msg = _("internal error: out of range error"); 936 break; 937 938 case bfd_reloc_notsupported: 939 msg = _("internal error: unsupported relocation error"); 940 break; 941 942 case bfd_reloc_dangerous: 943 msg = _("internal error: dangerous relocation"); 944 break; 945 946 default: 947 msg = _("internal error: unknown error"); 948 break; 949 } 950 951 if (msg) 952 r = info->callbacks->warning 953 (info, msg, name, input_bfd, input_section, rel->r_offset); 954 955 if (! r) 956 return FALSE; 957 } 958 } 959 960 return TRUE; 961 } 962 963 /* This must exist if dynobj is ever set. */ 964 965 static bfd_boolean 966 xstormy16_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED, 967 struct bfd_link_info *info) 968 { 969 bfd *dynobj; 970 asection *splt; 971 972 /* As an extra sanity check, verify that all plt entries have 973 been filled in. */ 974 975 if ((dynobj = elf_hash_table (info)->dynobj) != NULL 976 && (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL) 977 { 978 bfd_byte *contents = splt->contents; 979 unsigned int i, size = splt->size; 980 981 for (i = 0; i < size; i += 4) 982 { 983 unsigned int x = bfd_get_32 (dynobj, contents + i); 984 985 BFD_ASSERT (x != 0); 986 } 987 } 988 989 return TRUE; 990 } 991 992 /* Return the section that should be marked against GC for a given 993 relocation. */ 994 995 static asection * 996 xstormy16_elf_gc_mark_hook (asection *sec, 997 struct bfd_link_info *info, 998 Elf_Internal_Rela *rel, 999 struct elf_link_hash_entry *h, 1000 Elf_Internal_Sym *sym) 1001 { 1002 if (h != NULL) 1003 switch (ELF32_R_TYPE (rel->r_info)) 1004 { 1005 case R_XSTORMY16_GNU_VTINHERIT: 1006 case R_XSTORMY16_GNU_VTENTRY: 1007 return NULL; 1008 } 1009 1010 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 1011 } 1012 1013 #define ELF_ARCH bfd_arch_xstormy16 1014 #define ELF_MACHINE_CODE EM_XSTORMY16 1015 #define ELF_MAXPAGESIZE 0x100 1016 1017 #define TARGET_LITTLE_SYM xstormy16_elf32_vec 1018 #define TARGET_LITTLE_NAME "elf32-xstormy16" 1019 1020 #define elf_info_to_howto_rel NULL 1021 #define elf_info_to_howto xstormy16_info_to_howto_rela 1022 #define elf_backend_relocate_section xstormy16_elf_relocate_section 1023 #define elf_backend_gc_mark_hook xstormy16_elf_gc_mark_hook 1024 #define elf_backend_check_relocs xstormy16_elf_check_relocs 1025 #define elf_backend_always_size_sections \ 1026 xstormy16_elf_always_size_sections 1027 #define elf_backend_omit_section_dynsym \ 1028 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) 1029 #define elf_backend_finish_dynamic_sections \ 1030 xstormy16_elf_finish_dynamic_sections 1031 1032 #define elf_backend_can_gc_sections 1 1033 #define elf_backend_rela_normal 1 1034 1035 #define bfd_elf32_bfd_reloc_type_lookup xstormy16_reloc_type_lookup 1036 #define bfd_elf32_bfd_reloc_name_lookup \ 1037 xstormy16_reloc_name_lookup 1038 #define bfd_elf32_bfd_relax_section xstormy16_elf_relax_section 1039 1040 #include "elf32-target.h" 1041