1 /* ARC-specific support for 32-bit ELF 2 Copyright (C) 1994-2015 Free Software Foundation, Inc. 3 Contributed by Cupertino Miranda (cmiranda@synopsys.com). 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 "elf-bfd.h" 26 #include "elf/arc.h" 27 #include "libiberty.h" 28 #include "opcode/arc-func.h" 29 30 #define ARC_DEBUG(...) 31 #define DEBUG(...) printf (__ARGV__) 32 #define DEBUG_ARC_RELOC(A) 33 34 struct arc_local_data 35 { 36 bfd_vma sdata_begin_symbol_vma; 37 asection * sdata_output_section; 38 bfd_vma got_symbol_vma; 39 }; 40 41 struct arc_local_data global_arc_data = 42 { 43 .sdata_begin_symbol_vma = 0, 44 .sdata_output_section = NULL, 45 .got_symbol_vma = 0, 46 }; 47 48 struct dynamic_sections 49 { 50 bfd_boolean initialized; 51 asection * sgot; 52 asection * srelgot; 53 asection * sgotplt; 54 asection * sdyn; 55 asection * splt; 56 asection * srelplt; 57 }; 58 59 static struct dynamic_sections 60 arc_create_dynamic_sections (bfd * abfd, struct bfd_link_info *info); 61 62 enum dyn_section_types 63 { 64 got = 0, 65 relgot, 66 gotplt, 67 dyn, 68 plt, 69 relplt, 70 DYN_SECTION_TYPES_END 71 }; 72 73 const char * dyn_section_names[DYN_SECTION_TYPES_END] = 74 { 75 ".got", 76 ".rela.got", 77 ".got.plt", 78 ".dynamic", 79 ".plt", 80 ".rela.plt" 81 }; 82 83 /* The default symbols representing the init and fini dyn values. 84 TODO: Check what is the relation of those strings with arclinux.em 85 and DT_INIT. */ 86 #define INIT_SYM_STRING "_init" 87 #define FINI_SYM_STRING "_fini" 88 89 char * init_str = INIT_SYM_STRING; 90 char * fini_str = FINI_SYM_STRING; 91 92 93 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 94 case VALUE: \ 95 return #TYPE; \ 96 break; 97 98 static ATTRIBUTE_UNUSED const char * 99 reloc_type_to_name (unsigned int type) 100 { 101 switch (type) 102 { 103 #include "elf/arc-reloc.def" 104 105 default: 106 return "UNKNOWN"; 107 break; 108 } 109 } 110 #undef ARC_RELOC_HOWTO 111 112 /* Try to minimize the amount of space occupied by relocation tables 113 on the ROM (not that the ROM won't be swamped by other ELF overhead). */ 114 115 #define USE_REL 1 116 117 static ATTRIBUTE_UNUSED bfd_boolean 118 is_reloc_PC_relative (reloc_howto_type *howto) 119 { 120 return (strstr (howto->name, "PC") != NULL) ? TRUE : FALSE; 121 } 122 123 static bfd_boolean 124 is_reloc_SDA_relative (reloc_howto_type *howto) 125 { 126 return (strstr (howto->name, "SDA") != NULL) ? TRUE : FALSE; 127 } 128 129 static bfd_boolean 130 is_reloc_for_GOT (reloc_howto_type * howto) 131 { 132 return (strstr (howto->name, "GOT") != NULL) ? TRUE : FALSE; 133 } 134 135 static bfd_boolean 136 is_reloc_for_PLT (reloc_howto_type * howto) 137 { 138 return (strstr (howto->name, "PLT") != NULL) ? TRUE : FALSE; 139 } 140 141 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B) 142 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B) 143 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C) 144 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C) 145 146 static long 147 arc_bfd_get_32 (bfd * abfd, void *loc, asection * input_section) 148 { 149 long insn = bfd_get_32 (abfd, loc); 150 151 if (!bfd_big_endian (abfd) 152 && input_section 153 && (input_section->flags & SEC_CODE)) 154 insn = ((0x0000fffff & insn) << 16) | ((0xffff0000 & insn) >> 16); 155 156 return insn; 157 } 158 159 static void 160 arc_bfd_put_32 (bfd * abfd, long insn, void *loc, asection * input_section) 161 { 162 if (!bfd_big_endian (abfd) 163 && input_section 164 && (input_section->flags & SEC_CODE)) 165 insn = ((0x0000fffff & insn) << 16) | ((0xffff0000 & insn) >> 16); 166 167 bfd_put_32 (abfd, insn, loc); 168 } 169 170 static bfd_reloc_status_type 171 arc_elf_reloc (bfd *abfd ATTRIBUTE_UNUSED, 172 arelent *reloc_entry, 173 asymbol *symbol_in, 174 void *data ATTRIBUTE_UNUSED, 175 asection *input_section, 176 bfd *output_bfd, 177 char ** error_message ATTRIBUTE_UNUSED) 178 { 179 if (output_bfd != NULL) 180 { 181 reloc_entry->address += input_section->output_offset; 182 183 /* In case of relocateable link and if the reloc is against a 184 section symbol, the addend needs to be adjusted according to 185 where the section symbol winds up in the output section. */ 186 if ((symbol_in->flags & BSF_SECTION_SYM) && symbol_in->section) 187 reloc_entry->addend += symbol_in->section->output_offset; 188 189 return bfd_reloc_ok; 190 } 191 192 return bfd_reloc_continue; 193 } 194 195 196 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 197 TYPE = VALUE, 198 enum howto_list 199 { 200 #include "elf/arc-reloc.def" 201 HOWTO_LIST_LAST 202 }; 203 #undef ARC_RELOC_HOWTO 204 205 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 206 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, complain_overflow_##OVERFLOW, arc_elf_reloc, #TYPE, FALSE, 0, 0, FALSE), 207 208 static struct reloc_howto_struct elf_arc_howto_table[] = 209 { 210 #include "elf/arc-reloc.def" 211 /* Example of what is generated by the preprocessor. Currently kept as an example. 212 HOWTO (R_ARC_NONE, // Type. 213 0, // Rightshift. 214 2, // Size (0 = byte, 1 = short, 2 = long). 215 32, // Bitsize. 216 FALSE, // PC_relative. 217 0, // Bitpos. 218 complain_overflow_bitfield, // Complain_on_overflow. 219 bfd_elf_generic_reloc, // Special_function. 220 "R_ARC_NONE", // Name. 221 TRUE, // Partial_inplace. 222 0, // Src_mask. 223 0, // Dst_mask. 224 FALSE), // PCrel_offset. 225 */ 226 }; 227 #undef ARC_RELOC_HOWTO 228 229 static void arc_elf_howto_init (void) 230 { 231 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 232 elf_arc_howto_table[TYPE].pc_relative = \ 233 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); 234 235 #include "elf/arc-reloc.def" 236 } 237 #undef ARC_RELOC_HOWTO 238 239 240 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 241 [TYPE] = VALUE, 242 const int howto_table_lookup[] = 243 { 244 #include "elf/arc-reloc.def" 245 }; 246 #undef ARC_RELOC_HOWTO 247 248 #define ARC_ELF_HOWTO(r_type) \ 249 (&elf_arc_howto_table[r_type]) 250 251 /* Map BFD reloc types to ARC ELF reloc types. */ 252 253 struct arc_reloc_map 254 { 255 bfd_reloc_code_real_type bfd_reloc_val; 256 unsigned char elf_reloc_val; 257 }; 258 259 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 260 { BFD_RELOC_##TYPE, R_##TYPE }, 261 static const struct arc_reloc_map arc_reloc_map[] = 262 { 263 #include "elf/arc-reloc.def" 264 {BFD_RELOC_NONE, R_ARC_NONE}, 265 {BFD_RELOC_8, R_ARC_8}, 266 {BFD_RELOC_16, R_ARC_16}, 267 {BFD_RELOC_24, R_ARC_24}, 268 {BFD_RELOC_32, R_ARC_32}, 269 }; 270 #undef ARC_RELOC_HOWTO 271 272 static reloc_howto_type * 273 bfd_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 274 bfd_reloc_code_real_type code) 275 { 276 unsigned int i; 277 static int fully_initialized = FALSE; 278 279 if (fully_initialized == FALSE) 280 { 281 arc_elf_howto_init (); 282 fully_initialized = TRUE; /* TODO: CHECK THIS IF IT STOPS WORKING. */ 283 } 284 285 for (i = ARRAY_SIZE (arc_reloc_map); i--;) 286 { 287 if (arc_reloc_map[i].bfd_reloc_val == code) 288 return elf_arc_howto_table + arc_reloc_map[i].elf_reloc_val; 289 } 290 291 return NULL; 292 } 293 294 static reloc_howto_type * 295 bfd_elf32_bfd_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char *r_name) 296 { 297 unsigned int i; 298 299 for (i = 0; i < ARRAY_SIZE (elf_arc_howto_table); i++) 300 if (elf_arc_howto_table[i].name != NULL 301 && strcasecmp (elf_arc_howto_table[i].name, r_name) == 0) 302 return elf_arc_howto_table + i; 303 304 return NULL; 305 } 306 307 308 /* Set the howto pointer for an ARC ELF reloc. */ 309 static void 310 arc_info_to_howto_rel (bfd * abfd ATTRIBUTE_UNUSED, 311 arelent * cache_ptr, 312 Elf_Internal_Rela * dst) 313 { 314 unsigned int r_type; 315 316 r_type = ELF32_R_TYPE (dst->r_info); 317 BFD_ASSERT (r_type < (unsigned int) R_ARC_max); 318 cache_ptr->howto = &elf_arc_howto_table[r_type]; 319 } 320 321 /* Set the right machine number for an ARC ELF file. */ 322 static bfd_boolean 323 arc_elf_object_p (bfd * abfd) 324 { 325 /* Make sure this is initialised, or you'll have the potential of passing 326 garbage---or misleading values---into the call to 327 bfd_default_set_arch_mach (). */ 328 int mach = bfd_mach_arc_arc700; 329 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_ARC_MACH_MSK; 330 unsigned e_machine = elf_elfheader (abfd)->e_machine; 331 332 if (e_machine == EM_ARC_COMPACT || e_machine == EM_ARC_COMPACT2) 333 { 334 switch (arch) 335 { 336 case E_ARC_MACH_ARC600: 337 mach = bfd_mach_arc_arc600; 338 break; 339 case E_ARC_MACH_ARC601: 340 mach = bfd_mach_arc_arc601; 341 break; 342 case E_ARC_MACH_ARC700: 343 mach = bfd_mach_arc_arc700; 344 break; 345 case EF_ARC_CPU_ARCV2HS: 346 case EF_ARC_CPU_ARCV2EM: 347 mach = bfd_mach_arc_arcv2; 348 break; 349 default: 350 mach = (e_machine == EM_ARC_COMPACT) ? 351 bfd_mach_arc_arc700 : bfd_mach_arc_arcv2; 352 break; 353 } 354 } 355 else 356 { 357 if (e_machine == EM_ARC) 358 { 359 (*_bfd_error_handler) 360 (_("Error: The ARC4 architecture is no longer supported.\n")); 361 return FALSE; 362 } 363 else 364 { 365 (*_bfd_error_handler) 366 (_("Warning: unset or old architecture flags. \n" 367 " Use default machine.\n")); 368 } 369 } 370 371 return bfd_default_set_arch_mach (abfd, bfd_arch_arc, mach); 372 } 373 374 /* The final processing done just before writing out an ARC ELF object file. 375 This gets the ARC architecture right based on the machine number. */ 376 377 static void 378 arc_elf_final_write_processing (bfd * abfd, bfd_boolean linker ATTRIBUTE_UNUSED) 379 { 380 unsigned long val; 381 unsigned long emf; 382 383 switch (bfd_get_mach (abfd)) 384 { 385 case bfd_mach_arc_arc600: 386 val = E_ARC_MACH_ARC600; 387 emf = EM_ARC_COMPACT; 388 break; 389 case bfd_mach_arc_arc601: 390 val = E_ARC_MACH_ARC601; 391 emf = EM_ARC_COMPACT; 392 break; 393 case bfd_mach_arc_arc700: 394 val = E_ARC_MACH_ARC700; 395 emf = EM_ARC_COMPACT; 396 break; 397 case bfd_mach_arc_arcv2: 398 val = EF_ARC_CPU_GENERIC; 399 emf = EM_ARC_COMPACT2; 400 /* TODO: Check validity of this. It can also be ARCV2EM here. 401 Previous version sets the e_machine here. */ 402 break; 403 default: 404 abort (); 405 } 406 elf_elfheader (abfd)->e_flags &= ~EF_ARC_MACH; 407 elf_elfheader (abfd)->e_flags |= val; 408 elf_elfheader (abfd)->e_machine = emf; 409 410 /* Record whatever is the current syscall ABI version. */ 411 elf_elfheader (abfd)->e_flags |= E_ARC_OSABI_CURRENT; 412 } 413 414 #define BFD_DEBUG_PIC(...) 415 416 struct arc_relocation_data 417 { 418 bfd_vma reloc_offset; 419 bfd_vma reloc_addend; 420 bfd_vma got_offset_value; 421 422 bfd_vma sym_value; 423 asection * sym_section; 424 425 reloc_howto_type *howto; 426 427 asection * input_section; 428 429 bfd_vma sdata_begin_symbol_vma; 430 bfd_boolean sdata_begin_symbol_vma_set; 431 bfd_vma got_symbol_vma; 432 433 bfd_boolean should_relocate; 434 }; 435 436 static void 437 debug_arc_reloc (struct arc_relocation_data reloc_data) 438 { 439 fprintf (stderr, "Reloc type=%s, should_relocate = %s\n", 440 reloc_data.howto->name, 441 reloc_data.should_relocate ? "true" : "false"); 442 fprintf (stderr, " offset = 0x%x, addend = 0x%x\n", 443 (unsigned int) reloc_data.reloc_offset, 444 (unsigned int) reloc_data.reloc_addend); 445 fprintf (stderr, " Symbol:\n"); 446 fprintf (stderr, " value = 0x%08x\n", 447 (unsigned int) reloc_data.sym_value); 448 if (reloc_data.sym_section != NULL) 449 { 450 fprintf (stderr, "IN IF\n"); 451 fprintf (stderr, 452 " section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n", 453 reloc_data.sym_section->name, 454 (unsigned int) reloc_data.sym_section->output_offset, 455 (unsigned int) reloc_data.sym_section->output_section->vma); 456 } 457 else 458 fprintf (stderr, " symbol section is NULL\n"); 459 460 fprintf (stderr, " Input_section:\n"); 461 if (reloc_data.input_section != NULL) 462 { 463 fprintf (stderr, 464 " section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n", 465 reloc_data.input_section->name, 466 (unsigned int) reloc_data.input_section->output_offset, 467 (unsigned int) reloc_data.input_section->output_section->vma); 468 fprintf (stderr, " changed_address = 0x%08x\n", 469 (unsigned int) (reloc_data.input_section->output_section->vma + 470 reloc_data.input_section->output_offset + 471 reloc_data.reloc_offset)); 472 } 473 else 474 fprintf (stderr, " input section is NULL\n"); 475 } 476 477 static ATTRIBUTE_UNUSED bfd_vma 478 get_middle_endian_relocation (bfd_vma reloc) 479 { 480 bfd_vma ret = 481 ((reloc & 0xffff0000) >> 16) | 482 ((reloc & 0xffff) << 16); 483 return ret; 484 } 485 486 #define ME(RELOC) (get_middle_endian_reloction(RELOC)) 487 488 #define S (reloc_data.sym_value \ 489 + reloc_data.sym_section->output_offset \ 490 + reloc_data.sym_section->output_section->vma) 491 #define A (reloc_data.reloc_addend) 492 #define B (0) 493 #define G (reloc_data.got_offset_value) 494 #define GOT (reloc_data.got_symbol_vma + 12) 495 #define L (reloc_data.sym_value \ 496 + reloc_data.sym_section->output_section->vma \ 497 + reloc_data.sym_section->output_offset) 498 #define MES (0) 499 /* P: relative offset to PCL The offset should be to the current location 500 aligned to 32 bits. */ 501 #define P ( \ 502 (reloc_data.input_section->output_section->vma \ 503 + reloc_data.input_section->output_offset \ 504 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0)) \ 505 ) & ~0x3) 506 #define PDATA ( \ 507 (reloc_data.input_section->output_section->vma \ 508 + reloc_data.input_section->output_offset \ 509 + (reloc_data.reloc_offset) \ 510 ) & ~0x3) 511 #define SECTSTAR (reloc_data.input_section->output_offset) 512 #define SECTSTART (reloc_data.input_section->output_offset) 513 #define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma) 514 515 #define none (0) 516 517 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 518 case R_##TYPE: \ 519 { \ 520 bfd_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \ 521 relocation = FORMULA ; \ 522 insn = RELOC_FUNCTION (insn, relocation); \ 523 } \ 524 break; 525 526 static bfd_reloc_status_type 527 arc_do_relocation (bfd_byte * contents, struct arc_relocation_data reloc_data) 528 { 529 bfd_vma relocation = 0; 530 bfd_vma insn; 531 bfd_vma orig_insn ATTRIBUTE_UNUSED; 532 533 if (reloc_data.should_relocate == FALSE) 534 return bfd_reloc_notsupported; 535 536 switch (reloc_data.howto->size) 537 { 538 case 2: 539 insn = arc_bfd_get_32 (reloc_data.input_section->owner, 540 contents + reloc_data.reloc_offset, 541 reloc_data.input_section); 542 break; 543 case 1: 544 case 0: 545 insn = arc_bfd_get_16 (reloc_data.input_section->owner, 546 contents + reloc_data.reloc_offset, 547 reloc_data.input_section); 548 break; 549 default: 550 insn = 0; 551 BFD_ASSERT (0); 552 break; 553 } 554 555 orig_insn = insn; 556 557 switch (reloc_data.howto->type) 558 { 559 #include "elf/arc-reloc.def" 560 561 default: 562 BFD_ASSERT (0); 563 break; 564 } 565 566 /* Check for relocation overflow. */ 567 if (reloc_data.howto->complain_on_overflow != complain_overflow_dont) 568 { 569 bfd_reloc_status_type flag; 570 flag = bfd_check_overflow (reloc_data.howto->complain_on_overflow, 571 reloc_data.howto->bitsize, 572 reloc_data.howto->rightshift, 573 bfd_arch_bits_per_address (reloc_data.input_section->owner), 574 relocation); 575 576 #undef DEBUG_ARC_RELOC 577 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A) 578 if (flag != bfd_reloc_ok) 579 { 580 fprintf (stderr, "Relocation overflows !!!!\n"); 581 582 DEBUG_ARC_RELOC (reloc_data); 583 584 fprintf (stderr, 585 "Relocation value = signed -> %d, unsigned -> %u, hex -> (0x%08x)\n", 586 (int) relocation, 587 (unsigned int) relocation, 588 (unsigned int) relocation); 589 return flag; 590 } 591 } 592 #undef DEBUG_ARC_RELOC 593 #define DEBUG_ARC_RELOC(A) 594 595 switch (reloc_data.howto->size) 596 { 597 case 2: 598 arc_bfd_put_32 (reloc_data.input_section->owner, insn, 599 contents + reloc_data.reloc_offset, 600 reloc_data.input_section); 601 break; 602 case 1: 603 case 0: 604 arc_bfd_put_16 (reloc_data.input_section->owner, insn, 605 contents + reloc_data.reloc_offset, 606 reloc_data.input_section); 607 break; 608 default: 609 ARC_DEBUG ("size = %d\n", reloc_data.howto->size); 610 BFD_ASSERT (0); 611 break; 612 } 613 614 return bfd_reloc_ok; 615 } 616 #undef S 617 #undef A 618 #undef B 619 #undef G 620 #undef GOT 621 #undef L 622 #undef MES 623 #undef P 624 #undef SECTSTAR 625 #undef SECTSTART 626 #undef _SDA_BASE_ 627 #undef none 628 629 #undef ARC_RELOC_HOWTO 630 631 static bfd_vma * 632 arc_get_local_got_offsets (bfd * abfd) 633 { 634 static bfd_vma *local_got_offsets = NULL; 635 636 if (local_got_offsets == NULL) 637 { 638 size_t size; 639 unsigned int i; 640 Elf_Internal_Shdr *symtab_hdr = &((elf_tdata (abfd))->symtab_hdr); 641 642 size = symtab_hdr->sh_info * sizeof (bfd_vma); 643 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size); 644 if (local_got_offsets == NULL) 645 return FALSE; 646 elf_local_got_offsets (abfd) = local_got_offsets; 647 for (i = 0; i < symtab_hdr->sh_info; i++) 648 local_got_offsets[i] = (bfd_vma) - 1; 649 } 650 651 return local_got_offsets; 652 } 653 654 655 /* Relocate an arc ELF section. 656 Function : elf_arc_relocate_section 657 Brief : Relocate an arc section, by handling all the relocations 658 appearing in that section. 659 Args : output_bfd : The bfd being written to. 660 info : Link information. 661 input_bfd : The input bfd. 662 input_section : The section being relocated. 663 contents : contents of the section being relocated. 664 relocs : List of relocations in the section. 665 local_syms : is a pointer to the swapped in local symbols. 666 local_section : is an array giving the section in the input file 667 corresponding to the st_shndx field of each 668 local symbol. */ 669 static bfd_boolean 670 elf_arc_relocate_section (bfd * output_bfd, 671 struct bfd_link_info * info, 672 bfd * input_bfd, 673 asection * input_section, 674 bfd_byte * contents, 675 Elf_Internal_Rela * relocs, 676 Elf_Internal_Sym * local_syms, 677 asection ** local_sections) 678 { 679 Elf_Internal_Shdr * symtab_hdr; 680 struct elf_link_hash_entry ** sym_hashes; 681 bfd_vma * local_got_offsets; 682 Elf_Internal_Rela * rel; 683 Elf_Internal_Rela * relend; 684 685 symtab_hdr = &((elf_tdata (input_bfd))->symtab_hdr); 686 sym_hashes = elf_sym_hashes (input_bfd); 687 688 rel = relocs; 689 relend = relocs + input_section->reloc_count; 690 for (; rel < relend; rel++) 691 { 692 enum elf_arc_reloc_type r_type; 693 reloc_howto_type * howto; 694 unsigned long r_symndx; 695 struct elf_link_hash_entry * h; 696 Elf_Internal_Sym * sym; 697 asection * sec; 698 699 struct arc_relocation_data reloc_data = 700 { 701 .reloc_offset = 0, /* bfd_vma reloc_offset; */ 702 .reloc_addend = 0, /* bfd_vma reloc_addend; */ 703 .got_offset_value = 0, /* bfd_vma got_offset_value; */ 704 .sym_value = 0, /* bfd_vma sym_value; */ 705 .sym_section = NULL, /* asection *sym_section; */ 706 .howto = NULL, /* reloc_howto_type *howto; */ 707 .input_section = NULL, /* asection *input_section; */ 708 .sdata_begin_symbol_vma = 0, /* bfd_vma sdata_begin_symbol_vma; */ 709 .sdata_begin_symbol_vma_set = FALSE, /* bfd_vma sdata_begin_symbol_vma_set; */ 710 .got_symbol_vma = 0, /* bfd_vma got_symbol_vma; */ 711 .should_relocate = FALSE /* bfd_boolean should_relocate; */ 712 }; 713 714 struct elf_link_hash_entry *h2; 715 716 h2 = elf_link_hash_lookup (elf_hash_table (info), "__SDATA_BEGIN__", 717 FALSE, FALSE, TRUE); 718 719 if (reloc_data.sdata_begin_symbol_vma_set == FALSE 720 && h2 != NULL && h2->root.type != bfd_link_hash_undefined) 721 { 722 reloc_data.sdata_begin_symbol_vma = 723 (h2->root.u.def.value + 724 h2->root.u.def.section->output_section->vma); 725 reloc_data.sdata_begin_symbol_vma_set = TRUE; 726 } 727 728 h2 = elf_link_hash_lookup (elf_hash_table (info), 729 "_GLOBAL_OFFSET_TABLE_", FALSE, FALSE, 730 TRUE); 731 if (h2 != NULL && h2->root.type != bfd_link_hash_undefined) 732 { 733 reloc_data.got_symbol_vma = 734 (h2->root.u.def.value + 735 h2->root.u.def.section->output_section->vma); 736 } 737 738 r_type = ELF32_R_TYPE (rel->r_info); 739 740 if (r_type >= (int) R_ARC_max) 741 { 742 bfd_set_error (bfd_error_bad_value); 743 return FALSE; 744 } 745 howto = &elf_arc_howto_table[r_type]; 746 747 reloc_data.input_section = input_section; 748 reloc_data.howto = howto; 749 reloc_data.reloc_offset = rel->r_offset; 750 reloc_data.reloc_addend = rel->r_addend; 751 752 r_symndx = ELF32_R_SYM (rel->r_info); 753 754 /* This is a final link. */ 755 h = NULL; 756 sym = NULL; 757 sec = NULL; 758 759 if (r_symndx < symtab_hdr->sh_info) /* A local symbol. */ 760 { 761 sym = local_syms + r_symndx; 762 sec = local_sections[r_symndx]; 763 764 reloc_data.sym_value = sym->st_value; 765 reloc_data.sym_section = sec; 766 767 if (is_reloc_for_GOT (reloc_data.howto)) 768 { 769 local_got_offsets = arc_get_local_got_offsets (output_bfd); 770 reloc_data.got_offset_value = local_got_offsets[r_symndx]; 771 } 772 773 reloc_data.should_relocate = TRUE; 774 } 775 else /* Global symbol. */ 776 { 777 /* Get the symbol's entry in the symtab. */ 778 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 779 780 while (h->root.type == bfd_link_hash_indirect 781 || h->root.type == bfd_link_hash_warning) 782 h = (struct elf_link_hash_entry *) h->root.u.i.link; 783 784 BFD_ASSERT ((h->dynindx == -1) >= (h->forced_local != 0)); 785 /* If we have encountered a definition for this symbol. */ 786 if (h->root.type == bfd_link_hash_defined 787 || h->root.type == bfd_link_hash_defweak) 788 { 789 reloc_data.sym_value = h->root.u.def.value; 790 reloc_data.sym_section = h->root.u.def.section; 791 792 reloc_data.should_relocate = TRUE; 793 794 if (is_reloc_for_GOT (howto)) 795 { 796 struct dynamic_sections ds = 797 arc_create_dynamic_sections (output_bfd, info); 798 799 /* TODO: Change it to use arc_do_relocation with ARC_32 800 reloc. */ 801 bfd_vma relocation = 802 reloc_data.sym_value + reloc_data.reloc_addend 803 + reloc_data.sym_section->output_offset 804 + reloc_data.sym_section->output_section->vma; 805 806 bfd_put_32 (output_bfd, relocation, ds.sgot->contents + h->got.offset); 807 808 } 809 } 810 else if (h->root.type == bfd_link_hash_undefweak) 811 { 812 /* Is weak symbol and has no definition. */ 813 continue; 814 } 815 else 816 { 817 if (is_reloc_for_GOT (howto)) 818 { 819 struct dynamic_sections ds = 820 arc_create_dynamic_sections (output_bfd, info); 821 822 reloc_data.sym_value = h->root.u.def.value; 823 reloc_data.sym_section = ds.sgot; 824 825 reloc_data.should_relocate = TRUE; 826 } 827 else if (is_reloc_for_PLT (howto)) 828 { 829 struct dynamic_sections ds = 830 arc_create_dynamic_sections (output_bfd, info); 831 832 reloc_data.sym_value = h->plt.offset; 833 reloc_data.sym_section = ds.splt; 834 835 reloc_data.should_relocate = TRUE; 836 } 837 else if (!(*info->callbacks->undefined_symbol) 838 (info, h->root.root.string, input_bfd, input_section, 839 rel->r_offset,!bfd_link_pic (info))) 840 { 841 return FALSE; 842 } 843 } 844 845 reloc_data.got_offset_value = h->got.offset; 846 } 847 848 if (is_reloc_SDA_relative (howto) && reloc_data.sdata_begin_symbol_vma_set == FALSE) 849 { 850 (*_bfd_error_handler) 851 ("Error: Linker symbol __SDATA_BEGIN__ not found"); 852 bfd_set_error (bfd_error_bad_value); 853 return FALSE; 854 } 855 856 DEBUG_ARC_RELOC (reloc_data); 857 if (arc_do_relocation (contents, reloc_data) != bfd_reloc_ok) 858 return FALSE; 859 } 860 861 return TRUE; 862 } 863 864 static struct dynamic_sections 865 arc_create_dynamic_sections (bfd * abfd, struct bfd_link_info *info) 866 { 867 static bfd * dynobj = NULL; 868 struct dynamic_sections ds = 869 { 870 .initialized = FALSE, 871 .sgot = NULL, 872 .srelgot = NULL, 873 .sgotplt = NULL, 874 .sdyn = NULL, 875 .splt = NULL, 876 .srelplt = NULL 877 }; 878 879 if (dynobj == NULL) 880 { 881 elf_hash_table (info)->dynobj = dynobj = abfd; 882 if (!_bfd_elf_create_got_section (dynobj, info)) 883 return ds; 884 } 885 else 886 dynobj = (elf_hash_table (info))->dynobj; 887 888 ds.sgot = bfd_get_section_by_name (dynobj, ".got"); 889 890 ds.srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 891 if (ds.srelgot == NULL) 892 { 893 ds.srelgot = bfd_make_section_with_flags (dynobj, ".rela.got", 894 SEC_ALLOC 895 | SEC_LOAD 896 | SEC_HAS_CONTENTS 897 | SEC_IN_MEMORY 898 | SEC_LINKER_CREATED 899 | SEC_READONLY); 900 if (ds.srelgot == NULL 901 || !bfd_set_section_alignment (dynobj, ds.srelgot, 2)) 902 return ds; 903 } 904 905 ds.sgotplt = bfd_get_section_by_name (dynobj, ".got.plt"); 906 907 ds.sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 908 ds.splt = bfd_get_section_by_name (dynobj, ".plt"); 909 ds.srelplt = bfd_get_section_by_name (dynobj, ".rela.plt"); 910 911 ds.initialized = TRUE; 912 913 return ds; 914 } 915 916 #define ADD_SYMBOL_REF_SEC_AND_RELOC(SECNAME, COND_FOR_RELOC, H) \ 917 ds.s##SECNAME->size; \ 918 { \ 919 if (COND_FOR_RELOC) ds.srel##SECNAME->size += sizeof (Elf32_External_Rela); \ 920 if (H) \ 921 if (h->dynindx == -1 && !h->forced_local) \ 922 if (! bfd_elf_link_record_dynamic_symbol (info, H)) \ 923 return FALSE; \ 924 ds.s##SECNAME->size += 4; \ 925 } 926 927 static bfd_boolean 928 elf_arc_check_relocs (bfd * abfd, 929 struct bfd_link_info * info, 930 asection * sec, 931 const Elf_Internal_Rela * relocs) 932 { 933 Elf_Internal_Shdr * symtab_hdr; 934 struct elf_link_hash_entry ** sym_hashes; 935 bfd_vma * local_got_offsets; 936 const Elf_Internal_Rela * rel; 937 const Elf_Internal_Rela * rel_end; 938 bfd * dynobj ATTRIBUTE_UNUSED; 939 940 dynobj = (elf_hash_table (info))->dynobj; 941 symtab_hdr = &((elf_tdata (abfd))->symtab_hdr); 942 sym_hashes = elf_sym_hashes (abfd); 943 local_got_offsets = arc_get_local_got_offsets (abfd); 944 945 struct dynamic_sections ds = arc_create_dynamic_sections (abfd, info); 946 947 rel_end = relocs + sec->reloc_count; 948 for (rel = relocs; rel < rel_end; rel++) 949 { 950 enum elf_arc_reloc_type r_type; 951 reloc_howto_type *howto; 952 unsigned long r_symndx; 953 struct elf_link_hash_entry *h; 954 955 r_type = ELF32_R_TYPE (rel->r_info); 956 957 if (r_type >= (int) R_ARC_max) 958 { 959 bfd_set_error (bfd_error_bad_value); 960 return FALSE; 961 } 962 howto = &elf_arc_howto_table[r_type]; 963 964 /* Load symbol information. */ 965 r_symndx = ELF32_R_SYM (rel->r_info); 966 if (r_symndx < symtab_hdr->sh_info) /* Is a local symbol. */ 967 h = NULL; 968 else /* Global one. */ 969 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 970 971 if (is_reloc_for_PLT (howto) == TRUE) 972 { 973 if (h == NULL) 974 continue; 975 else 976 h->needs_plt = 1; 977 } 978 979 if (is_reloc_for_GOT (howto) == TRUE) 980 { 981 if (h == NULL) 982 { 983 /* Local symbol. */ 984 local_got_offsets[r_symndx] = 985 ADD_SYMBOL_REF_SEC_AND_RELOC (got, bfd_link_pic (info), NULL); 986 } 987 else 988 { 989 /* Global symbol. */ 990 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 991 h->got.offset = 992 ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h); 993 } 994 } 995 } 996 997 return TRUE; 998 } 999 1000 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so" 1001 1002 /* Size of one plt entry in bytes. */ 1003 #define PLT_ENTRY_SIZE 12 1004 #define PLT_ENTRY_SIZE_V2 16 1005 1006 /* Instructions appear in memory as a sequence of half-words (16 bit); 1007 individual half-words are represented on the target in target byte order. 1008 We use 'unsigned short' on the host to represent the PLT templates, 1009 and translate to target byte order as we copy to the target. */ 1010 typedef unsigned short insn_hword; 1011 1012 1013 /* TODO: Make this PLT entry code be in a separate object file. */ 1014 /* TODO: This is a linker BTW, we should be able to link. :) */ 1015 1016 /* The zeroth entry in the absolute plt entry. */ 1017 static const insn_hword elf_arc_abs_plt0_entry[2 * PLT_ENTRY_SIZE / 2] = 1018 { 1019 0x1600, /* ld %r11, [0] */ 1020 0x700b, 1021 0x0000, 1022 0x0000, 1023 0x1600, /* ld %r10, [0] */ 1024 0x700a, /* */ 1025 0, 1026 0, 1027 0x2020, /* j [%r10] */ 1028 0x0280, /* ---"---- */ 1029 0x0000, /* pad */ 1030 0x0000 /* pad */ 1031 }; 1032 1033 /* Contents of the subsequent entries in the absolute plt. */ 1034 static const insn_hword elf_arc_abs_pltn_entry[PLT_ENTRY_SIZE / 2] = 1035 { 1036 0x2730, /* ld %r12, [%pc,func@gotpc] */ 1037 0x7f8c, /* ------ " " -------------- */ 1038 0x0000, /* ------ " " -------------- */ 1039 0x0000, /* ------ " " -------------- */ 1040 0x7c20, /* j_s.d [%r12] */ 1041 0x74ef /* mov_s %r12, %pcl */ 1042 }; 1043 1044 /* The zeroth entry in the absolute plt entry for ARCv2. */ 1045 static const insn_hword elf_arcV2_abs_plt0_entry[2 * PLT_ENTRY_SIZE_V2 / 2] = 1046 { 1047 0x1600, 0x700b, 0, 0, /* ld %r11, [0] */ 1048 0x1600, 0x700a, 0, 0, /* ld %r10, [0] */ 1049 0x2020, 0x0280, /* j [%r10] */ 1050 0x0000, 0x0000, /* -> RELOCATED TO ABS ADDRESS OF GOT <- */ 1051 0x0000, /* pad */ 1052 0x0000, /* pad */ 1053 0x0000, /* pad */ 1054 0x0000 /* pad */ 1055 }; 1056 1057 /* Contents of the subsequent entries in the absolute plt for ARCv2. */ 1058 static const insn_hword elf_arcV2_abs_pltn_entry[PLT_ENTRY_SIZE_V2 / 2] = 1059 { 1060 0x2730, /* ld %r12, [%pcl,func@gotpc] */ 1061 0x7f8c, /* ------ " " -------------- */ 1062 0x0000, /* ------ " " -------------- */ 1063 0x0000, /* ------ " " -------------- */ 1064 0x2021, /* j.d [%r12] */ 1065 0x0300, /* ------ " " -------------- */ 1066 0x240a, /* mov %r12, %pcl */ 1067 0x1fc0 /* ------ " " -------------- */ 1068 }; 1069 1070 /* The zeroth entry in the pic plt entry. */ 1071 static const insn_hword elf_arc_pic_plt0_entry[2 * PLT_ENTRY_SIZE / 2] = 1072 { 1073 0x2730, /* ld %r11, [pcl,0] : 0 to be replaced by 1074 _DYNAMIC@GOTPC+4 */ 1075 0x7f8b, 1076 0x0000, 1077 0x0000, 1078 0x2730, /* ld %r10, [pcl,0] : 0 to be replaced by 1079 -DYNAMIC@GOTPC+8 */ 1080 0x7f8a, /* */ 1081 0, 1082 0, 1083 0x2020, /* j [%r10] */ 1084 0x0280, /* ---"---- */ 1085 0x0000, /* pad */ 1086 0x0000 /* pad */ 1087 }; 1088 1089 /* Contents of the subsequent entries in the pic plt. */ 1090 static const insn_hword elf_arc_pic_pltn_entry[PLT_ENTRY_SIZE / 2] = 1091 { 1092 0x2730, /* ld %r12, [%pc,func@got] */ 1093 0x7f8c, /* ------ " " -------------- */ 1094 0x0000, /* ------ " " -------------- */ 1095 0x0000, /* ------ " " -------------- */ 1096 0x7c20, /* j_s.d [%r12] */ 1097 0x74ef, /* mov_s %r12, %pcl */ 1098 }; 1099 1100 /* The zeroth entry in the pic plt entry for ARCv2. */ 1101 static const insn_hword elf_arcV2_pic_plt0_entry[2 * PLT_ENTRY_SIZE_V2 / 2] = 1102 { 1103 0x2730, /* ld %r11, [pcl,0] : 0 to be replaced by 1104 _DYNAMIC@GOTPC+4 */ 1105 0x7f8b, 1106 0x0000, 1107 0x0000, 1108 0x2730, /* ld %r10, [pcl,0] : 0 to be replaced by 1109 -DYNAMIC@GOTPC+8 */ 1110 0x7f8a, /* */ 1111 0, 1112 0, 1113 0x2020, /* j [%r10] */ 1114 0x0280, /* ---"---- */ 1115 0x0000, /* pad */ 1116 0x0000, /* pad */ 1117 0x0000, /* pad */ 1118 0x0000, /* pad */ 1119 0x0000, /* pad */ 1120 0x0000 /* pad */ 1121 }; 1122 1123 #define elf_arcV2_pic_PLT0_ENTRY_SIZE (2 * PLT_ENTRY_SIZE_V2/2) 1124 1125 /* Contents of the subsequent entries in the pic plt for ARCv2. */ 1126 static const insn_hword elf_arcV2_pic_pltn_entry[PLT_ENTRY_SIZE_V2 / 2] = 1127 { 1128 0x2730, /* ld %r12, [%pc,func@got] */ 1129 0x7f8c, /* ------ " " -------------- */ 1130 0x0000, /* ------ " " -------------- */ 1131 0x0000, /* ------ " " -------------- */ 1132 0x2021, /* j.d [%r12] */ 1133 0x0300, /* ------ " " -------------- */ 1134 0x240a, /* mov %r12, %pcl */ 1135 0x1fc0 /* ------ " " -------------- */ 1136 }; 1137 1138 #define elf_arcV2_pic_PLTN_ENTRY_SIZE (PLT_ENTRY_SIZE_V2/2) 1139 1140 enum plt_reloc_symbol 1141 { 1142 LAST_RELOC = 0, 1143 1144 SGOT = 1, 1145 1146 RELATIVE = (1 << 8), 1147 MIDDLE_ENDIAN = (1 << 9) 1148 }; 1149 1150 #define IS_RELATIVE(S) ((S & RELATIVE) != 0) 1151 #define IS_MIDDLE_ENDIAN(S) ((S & MIDDLE_ENDIAN) != 0) 1152 #define SYM_ONLY(S) (S & 0xFF) 1153 1154 struct plt_reloc 1155 { 1156 bfd_vma offset; 1157 bfd_vma size; 1158 bfd_vma mask; 1159 enum plt_reloc_symbol symbol; 1160 bfd_vma addend; 1161 }; 1162 1163 struct plt_version_t 1164 { 1165 const insn_hword * entry; 1166 const bfd_vma entry_size; 1167 const insn_hword * elem; 1168 const bfd_vma elem_size; 1169 1170 struct plt_reloc entry_relocs[5]; 1171 struct plt_reloc elem_relocs[5]; 1172 }; 1173 1174 1175 #define PLT_DATA(NAME, ...) \ 1176 .entry = NAME##_plt0_entry, \ 1177 .entry_size = NAME##_PLT0_ENTRY_SIZE, \ 1178 .elem = NAME##_pltn_entry, \ 1179 .elem_size = NAME##_PLTN_ENTRY_SIZE 1180 1181 struct plt_version_t plt_versions[] = 1182 { 1183 { 1184 PLT_DATA (elf_arcV2_pic), 1185 .entry_relocs = 1186 { 1187 {4, 32, 0xFFFFFFFF, SGOT | RELATIVE | MIDDLE_ENDIAN, 4}, 1188 {12, 32, 0xFFFFFFFF, SGOT | RELATIVE | MIDDLE_ENDIAN, 8}, 1189 {20, 32, 0xFFFFFFFF, SGOT, 0}, 1190 {0, 0, 0, LAST_RELOC, 0} 1191 }, 1192 .elem_relocs = 1193 { 1194 {4, 32, 0xFFFFFFFF, SGOT, 0}, 1195 {0, 0, 0, LAST_RELOC, 0} 1196 } 1197 } 1198 }; 1199 #undef PLT_DATA 1200 1201 static struct plt_version_t * 1202 arc_get_plt_version (void) 1203 { 1204 return &(plt_versions[0]); 1205 } 1206 1207 static bfd_vma 1208 add_symbol_to_plt (struct bfd_link_info *info) 1209 { 1210 bfd *dynobj = (elf_hash_table (info))->dynobj; 1211 struct dynamic_sections ds = arc_create_dynamic_sections (dynobj, info); 1212 bfd_vma ret; 1213 1214 /* If this is the first .plt entry, make room for the special first entry. */ 1215 if (ds.splt->size == 0) 1216 ds.splt->size += 2 * 1217 (bfd_get_mach (dynobj) == bfd_mach_arc_arcv2 1218 ? PLT_ENTRY_SIZE_V2 : PLT_ENTRY_SIZE); 1219 1220 ret = ds.splt->size; 1221 1222 ds.splt->size += (bfd_get_mach (dynobj) == bfd_mach_arc_arcv2 1223 ? PLT_ENTRY_SIZE_V2 1224 : PLT_ENTRY_SIZE 1225 ); 1226 ds.sgotplt->size += 4; 1227 ds.srelplt->size += sizeof (Elf32_External_Rela); 1228 1229 return ret; 1230 } 1231 1232 #define PLT_DO_RELOCS_FOR_ENTRY(DS, RELOCS) \ 1233 plt_do_relocs_for_symbol (DS, RELOCS, 0, 0) 1234 1235 static void 1236 plt_do_relocs_for_symbol (struct dynamic_sections *ds, 1237 struct plt_reloc *reloc, 1238 bfd_vma plt_offset, 1239 bfd_vma symbol_got_offset) 1240 { 1241 while (SYM_ONLY (reloc->symbol) != LAST_RELOC) 1242 { 1243 bfd_vma relocation = 0; 1244 1245 switch (SYM_ONLY (reloc->symbol)) 1246 { 1247 case SGOT: 1248 relocation = 1249 ds->sgotplt->output_section->vma + 1250 ds->sgotplt->output_offset + symbol_got_offset; 1251 break; 1252 } 1253 relocation += reloc->addend; 1254 1255 relocation -= (IS_RELATIVE (reloc->symbol)) 1256 ? ds->splt->output_section->vma + ds->splt->output_offset + 1257 plt_offset + reloc->offset : 0; 1258 1259 if (IS_MIDDLE_ENDIAN (reloc->symbol)) 1260 { 1261 relocation = 1262 ((relocation & 0xffff0000) >> 16) | 1263 ((relocation & 0xffff) << 16); 1264 } 1265 1266 switch (reloc->size) 1267 { 1268 case 32: 1269 bfd_put_32 (ds->splt->output_section->owner, 1270 relocation, 1271 ds->splt->contents + plt_offset + reloc->offset); 1272 break; 1273 } 1274 1275 reloc = &(reloc[1]); /* Jump to next relocation. */ 1276 } 1277 } 1278 1279 static void 1280 relocate_plt_for_symbol (struct bfd_link_info *info, 1281 struct elf_link_hash_entry *h) 1282 { 1283 bfd * dynobj = elf_hash_table (info)->dynobj; 1284 struct plt_version_t *plt_data = arc_get_plt_version (); 1285 struct dynamic_sections ds = arc_create_dynamic_sections (dynobj, info); 1286 1287 bfd_vma plt_index = h->plt.offset / plt_data->elem_size; 1288 bfd_vma got_offset = (plt_index + 3) * 4; 1289 1290 memcpy (ds.splt->contents + h->plt.offset, plt_data->elem, 1291 plt_data->elem_size * sizeof (insn_hword)); 1292 plt_do_relocs_for_symbol (&ds, plt_data->elem_relocs, h->plt.offset, 1293 got_offset); 1294 } 1295 1296 static void 1297 relocate_plt_for_entry (struct bfd_link_info *info) 1298 { 1299 bfd * dynobj = (elf_hash_table (info))->dynobj; 1300 struct plt_version_t *plt_data = arc_get_plt_version (); 1301 struct dynamic_sections ds = arc_create_dynamic_sections (dynobj, info); 1302 1303 memcpy (ds.splt->contents, plt_data->entry, 1304 plt_data->entry_size * sizeof (insn_hword)); 1305 PLT_DO_RELOCS_FOR_ENTRY (&ds, plt_data->entry_relocs); 1306 } 1307 1308 1309 /* Desc : Adjust a symbol defined by a dynamic object and referenced by a 1310 regular object. The current definition is in some section of the 1311 dynamic object, but we're not including those sections. We have to 1312 change the definition to something the rest of the link can 1313 understand. */ 1314 1315 static bfd_boolean 1316 elf_arc_adjust_dynamic_symbol (struct bfd_link_info *info, 1317 struct elf_link_hash_entry *h) 1318 { 1319 bfd *dynobj = (elf_hash_table (info))->dynobj; 1320 struct dynamic_sections ds = arc_create_dynamic_sections (dynobj, info); 1321 1322 if (h->needs_plt == 1) 1323 { 1324 if (!bfd_link_pic (info) && !h->def_dynamic && !h->ref_dynamic) 1325 { 1326 /* This case can occur if we saw a PLT32 reloc in an input 1327 file, but the symbol was never referred to by a dynamic 1328 object. In such a case, we don't actually need to build 1329 a procedure linkage table, and we can just do a PC32 1330 reloc instead. */ 1331 BFD_ASSERT (h->needs_plt); 1332 return TRUE; 1333 } 1334 1335 /* Make sure this symbol is output as a dynamic symbol. */ 1336 if (h->dynindx == -1 && !h->forced_local 1337 && !bfd_elf_link_record_dynamic_symbol (info, h)) 1338 return FALSE; 1339 1340 if (bfd_link_pic (info) || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 1341 { 1342 bfd_vma loc = add_symbol_to_plt (info); 1343 1344 if (!bfd_link_pic (info) && !h->def_regular) 1345 { 1346 h->root.u.def.section = ds.splt; 1347 h->root.u.def.value = loc; 1348 } 1349 h->plt.offset = loc; 1350 } 1351 } 1352 else 1353 { 1354 h->plt.offset = (bfd_vma) - 1; 1355 h->needs_plt = 0; 1356 } 1357 1358 return TRUE; 1359 } 1360 1361 #define ADD_RELA(BFD, SECTION, OFFSET, SYM_IDX, TYPE, ADDEND) \ 1362 {\ 1363 struct dynamic_sections ds = arc_create_dynamic_sections (output_bfd, info); \ 1364 bfd_byte * rloc = ds.srel##SECTION->contents + \ 1365 ((ds.srel##SECTION->reloc_count++) * sizeof (Elf32_External_Rela)); \ 1366 Elf_Internal_Rela rel; \ 1367 bfd_put_32 (output_bfd, (bfd_vma) 0, ds.s##SECTION->contents + OFFSET); \ 1368 rel.r_addend = ADDEND; \ 1369 rel.r_offset = (ds.s##SECTION)->output_section->vma + (ds.s##SECTION)->output_offset + OFFSET; \ 1370 rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE); \ 1371 bfd_elf32_swap_reloca_out (BFD, &rel, rloc); \ 1372 } 1373 1374 /* Function : elf_arc_finish_dynamic_symbol 1375 Brief : Finish up dynamic symbol handling. We set the 1376 contents of various dynamic sections here. 1377 Args : output_bfd : 1378 info : 1379 h : 1380 sym : 1381 Returns : True/False as the return status. */ 1382 static bfd_boolean 1383 elf_arc_finish_dynamic_symbol (bfd * output_bfd, 1384 struct bfd_link_info *info, 1385 struct elf_link_hash_entry *h, 1386 Elf_Internal_Sym * sym) 1387 { 1388 if (h->plt.offset != (bfd_vma) - 1) 1389 relocate_plt_for_symbol (info, h); 1390 1391 if (h->got.offset != (bfd_vma) - 1) 1392 { 1393 if (bfd_link_pic (info) && (info->symbolic || h->dynindx == -1) 1394 && h->def_regular) 1395 { 1396 ADD_RELA (output_bfd, got, h->got.offset, 0, R_ARC_RELATIVE, 0); 1397 } 1398 else 1399 { 1400 ADD_RELA (output_bfd, got, h->got.offset, h->dynindx, 1401 R_ARC_GLOB_DAT, 0); 1402 } 1403 } 1404 1405 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 1406 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 1407 || strcmp (h->root.root.string, "__DYNAMIC") == 0 1408 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1409 sym->st_shndx = SHN_ABS; 1410 1411 return TRUE; 1412 } 1413 1414 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \ 1415 case TAG: \ 1416 if (SYMBOL != NULL) \ 1417 { \ 1418 h = elf_link_hash_lookup (elf_hash_table (info), SYMBOL, FALSE, FALSE, TRUE); \ 1419 } \ 1420 else if (SECTION != NULL) \ 1421 { \ 1422 s = bfd_get_section_by_name (output_bfd, SECTION); \ 1423 BFD_ASSERT (s != NULL); \ 1424 do_it = TRUE; \ 1425 } \ 1426 break; 1427 1428 /* Function : elf_arc_finish_dynamic_sections 1429 Brief : Finish up the dynamic sections handling. 1430 Args : output_bfd : 1431 info : 1432 h : 1433 sym : 1434 Returns : True/False as the return status. */ 1435 static bfd_boolean 1436 elf_arc_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info *info) 1437 { 1438 struct dynamic_sections ds = arc_create_dynamic_sections (output_bfd, info); 1439 bfd *dynobj = (elf_hash_table (info))->dynobj; 1440 1441 if (ds.sdyn) 1442 { 1443 Elf32_External_Dyn *dyncon, *dynconend; 1444 1445 dyncon = (Elf32_External_Dyn *) ds.sdyn->contents; 1446 dynconend = 1447 (Elf32_External_Dyn *) (ds.sdyn->contents + ds.sdyn->size); 1448 for (; dyncon < dynconend; dyncon++) 1449 { 1450 Elf_Internal_Dyn internal_dyn; 1451 bfd_boolean do_it = FALSE; 1452 1453 struct elf_link_hash_entry *h = NULL; 1454 asection *s = NULL; 1455 1456 bfd_elf32_swap_dyn_in (dynobj, dyncon, &internal_dyn); 1457 1458 switch (internal_dyn.d_tag) 1459 { 1460 GET_SYMBOL_OR_SECTION (DT_INIT, "_init", NULL) 1461 GET_SYMBOL_OR_SECTION (DT_FINI, "_fini", NULL) 1462 GET_SYMBOL_OR_SECTION (DT_PLTGOT, NULL, ".plt") 1463 GET_SYMBOL_OR_SECTION (DT_JMPREL, NULL, ".rela.plt") 1464 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ, NULL, ".rela.plt") 1465 GET_SYMBOL_OR_SECTION (DT_RELASZ, NULL, ".rela.plt") 1466 default: 1467 break; 1468 } 1469 1470 /* In case the dynamic symbols should be updated with a 1471 symbol. */ 1472 if (h != NULL 1473 && (h->root.type == bfd_link_hash_defined 1474 || h->root.type == bfd_link_hash_defweak) 1475 ) 1476 { 1477 asection *asec_ptr; 1478 1479 internal_dyn.d_un.d_val = h->root.u.def.value; 1480 asec_ptr = h->root.u.def.section; 1481 if (asec_ptr->output_section != NULL) 1482 { 1483 internal_dyn.d_un.d_val += 1484 (asec_ptr->output_section->vma + 1485 asec_ptr->output_offset); 1486 } 1487 else 1488 { 1489 /* The symbol is imported from another 1490 shared library and does not apply to this 1491 one. */ 1492 internal_dyn.d_un.d_val = 0; 1493 } 1494 do_it = TRUE; 1495 } 1496 else if (s != NULL) /* With a section information. */ 1497 { 1498 switch (internal_dyn.d_tag) 1499 { 1500 case DT_PLTGOT: 1501 case DT_JMPREL: 1502 internal_dyn.d_un.d_ptr = s->vma; 1503 do_it = TRUE; 1504 break; 1505 1506 case DT_PLTRELSZ: 1507 internal_dyn.d_un.d_val = s->size; 1508 do_it = TRUE; 1509 break; 1510 1511 case DT_RELASZ: 1512 internal_dyn.d_un.d_val -= s->size; 1513 do_it = TRUE; 1514 break; 1515 1516 default: 1517 break; 1518 } 1519 } 1520 1521 if (do_it == TRUE) 1522 bfd_elf32_swap_dyn_out (output_bfd, &internal_dyn, dyncon); 1523 } 1524 1525 if (ds.splt->size > 0) 1526 { 1527 relocate_plt_for_entry (info); 1528 } 1529 1530 elf_section_data (ds.srelplt->output_section)->this_hdr.sh_entsize = 0xc; 1531 } 1532 1533 /* Fill in the first three entries in the global offset table. */ 1534 if (ds.sgot) 1535 { 1536 if (ds.sgot->size > 0) 1537 { 1538 if (ds.sdyn == NULL) 1539 bfd_put_32 (output_bfd, (bfd_vma) 0, 1540 ds.sgotplt->contents); 1541 else 1542 bfd_put_32 (output_bfd, 1543 ds.sdyn->output_section->vma + ds.sdyn->output_offset, 1544 ds.sgotplt->contents); 1545 bfd_put_32 (output_bfd, (bfd_vma) 0, ds.sgotplt->contents + 4); 1546 bfd_put_32 (output_bfd, (bfd_vma) 0, ds.sgotplt->contents + 8); 1547 1548 elf_section_data (ds.sgot->output_section)->this_hdr.sh_entsize = 4; 1549 } 1550 } 1551 1552 if (ds.srelgot 1553 /* Check that the linker script has not dumped the .srelgot section. */ 1554 && ds.srelgot->output_section 1555 && elf_section_data (ds.srelgot->output_section)) 1556 { 1557 /* TODO: Make it work even if I remove this. */ 1558 elf_section_data (ds.srelgot->output_section)->this_hdr.sh_entsize = 0xc; 1559 } 1560 1561 return TRUE; 1562 } 1563 1564 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \ 1565 h = elf_link_hash_lookup (elf_hash_table (info), NAME, FALSE, FALSE, FALSE); \ 1566 if ((h != NULL && (h->ref_regular || h->def_regular))) \ 1567 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \ 1568 return FALSE; 1569 1570 /* Set the sizes of the dynamic sections. */ 1571 static bfd_boolean 1572 elf_arc_size_dynamic_sections (bfd * output_bfd, struct bfd_link_info *info) 1573 { 1574 bfd * dynobj; 1575 asection * s; 1576 bfd_boolean relocs_exist; 1577 bfd_boolean reltext_exist; 1578 struct dynamic_sections ds = arc_create_dynamic_sections (output_bfd, info); 1579 1580 dynobj = (elf_hash_table (info))->dynobj; 1581 BFD_ASSERT (dynobj != NULL); 1582 1583 if ((elf_hash_table (info))->dynamic_sections_created) 1584 { 1585 struct elf_link_hash_entry *h; 1586 1587 /* Set the contents of the .interp section to the interpreter. */ 1588 if (!bfd_link_pic (info)) 1589 { 1590 s = bfd_get_section_by_name (dynobj, ".interp"); 1591 BFD_ASSERT (s != NULL); 1592 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 1593 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1594 } 1595 1596 /* Add some entries to the .dynamic section. We fill in some of the 1597 values later, in elf_bfd_final_link, but we must add the entries 1598 now so that we know the final size of the .dynamic section. 1599 Checking if the .init section is present. We also create DT_INIT 1600 and DT_FINI entries if the init_str has been changed by the user. */ 1601 1602 ADD_DYNAMIC_SYMBOL ("init", DT_INIT); 1603 ADD_DYNAMIC_SYMBOL ("fini", DT_FINI); 1604 } 1605 else 1606 { 1607 /* We may have created entries in the .rela.got section. However, if 1608 we are not creating the dynamic sections, we will not actually 1609 use these entries. Reset the size of .rela.got, which will cause 1610 it to get stripped from the output file below. */ 1611 ds.srelgot->size = 0; 1612 } 1613 1614 for (s = dynobj->sections; s != NULL; s = s->next) 1615 { 1616 bfd_boolean is_dynamic_section = FALSE; 1617 1618 /* Skip any non dynamic section. */ 1619 if (strstr (s->name, ".plt") != NULL 1620 || strstr (s->name, ".got") != NULL 1621 || strstr (s->name, ".rel") != NULL) 1622 is_dynamic_section = TRUE; 1623 1624 /* Allocate memory for the section contents. */ 1625 if (!is_dynamic_section) 1626 continue; 1627 1628 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->size); 1629 if (s->contents == NULL && s->size != 0) 1630 return FALSE; 1631 1632 if (s->size == 0) 1633 { 1634 s->flags |= SEC_EXCLUDE; 1635 continue; 1636 } 1637 1638 if (strcmp (s->name, ".rela.plt") != 0) 1639 { 1640 const char *outname = bfd_get_section_name (output_bfd, 1641 s->output_section); 1642 asection *target = bfd_get_section_by_name (output_bfd, 1643 outname + 4); 1644 1645 relocs_exist = TRUE; 1646 if (target != NULL && target->size != 0 1647 && (target->flags & SEC_READONLY) != 0 1648 && (target->flags & SEC_ALLOC) != 0) 1649 reltext_exist = TRUE; 1650 } 1651 } 1652 1653 if (ds.sdyn) 1654 { 1655 if (ds.splt && ds.splt->size != 0) 1656 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0) 1657 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0) 1658 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA) 1659 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0) 1660 ) 1661 return FALSE; 1662 1663 if (relocs_exist == TRUE) 1664 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0) 1665 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0) 1666 || !_bfd_elf_add_dynamic_entry (info, DT_RELENT, 1667 sizeof (Elf32_External_Rela)) 1668 ) 1669 return FALSE; 1670 1671 if (reltext_exist == TRUE) 1672 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0)) 1673 return FALSE; 1674 } 1675 1676 return TRUE; 1677 } 1678 1679 1680 #define TARGET_LITTLE_SYM arc_elf32_le_vec 1681 #define TARGET_LITTLE_NAME "elf32-littlearc" 1682 #define TARGET_BIG_SYM arc_elf32_be_vec 1683 #define TARGET_BIG_NAME "elf32-bigarc" 1684 #define ELF_ARCH bfd_arch_arc 1685 #define ELF_MACHINE_CODE EM_ARC_COMPACT 1686 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2 1687 #define ELF_MAXPAGESIZE 0x2000 1688 1689 #define elf_info_to_howto_rel arc_info_to_howto_rel 1690 #define elf_backend_object_p arc_elf_object_p 1691 #define elf_backend_final_write_processing arc_elf_final_write_processing 1692 1693 #define elf_backend_relocate_section elf_arc_relocate_section 1694 #define elf_backend_check_relocs elf_arc_check_relocs 1695 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections 1696 1697 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol 1698 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol 1699 1700 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections 1701 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections 1702 1703 #define elf_backend_can_gc_sections 1 1704 #define elf_backend_want_got_plt 1 1705 #define elf_backend_plt_readonly 1 1706 #define elf_backend_want_plt_sym 0 1707 #define elf_backend_got_header_size 12 1708 1709 #define elf_backend_may_use_rel_p 0 1710 #define elf_backend_may_use_rela_p 1 1711 #define elf_backend_default_use_rela_p 1 1712 1713 #include "elf32-target.h" 1714